mapricot 0.1.0__tar.gz

mapricot-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,37 @@
+name: CI
+# Tests against the live API on every push and pull request, and weekly to catch API changes.
+on:
+  push:
+    branches: [main]
+  pull_request:
+  schedule:
+    - cron: '17 6 * * 1'
+  workflow_dispatch:
+permissions:
+  contents: read
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    strategy:
+      matrix:
+        python: ['3.11', '3.14']
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
+      - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
+        with:
+          python-version: ${{ matrix.python }}
+      - run: python -m unittest discover -s tests -v
+        env:
+          PYTHONPATH: src
+          MAPRICOT_KEY: ${{ secrets.MAPRICOT_KEY }}
+  endpoints:
+    # Fails when the API gains an endpoint that this client has no method for.
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
+      - run: |
+          curl -fsS https://api.mapricot.com/openapi.json | jq -r '.paths | keys[] | sub("\\{.*"; "")' | while read -r path; do
+            grep -rqF "$path" src || { echo "::error::No method for $path"; exit 1; }
+          done

mapricot-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,26 @@
+name: Release
+# Publishes the version in a GitHub release's tag, such as v0.1.0, after the live tests pass.
+on:
+  release:
+    types: [published]
+permissions:
+  contents: read
+  id-token: write
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: release
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
+      - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
+        with:
+          python-version: '3.14'
+      - name: Check the tag matches __version__
+        run: grep -qx "__version__ = \"${GITHUB_REF_NAME#v}\"" src/mapricot/__init__.py
+      - run: python -m unittest discover -s tests -v
+        env:
+          PYTHONPATH: src
+          MAPRICOT_KEY: ${{ secrets.MAPRICOT_KEY }}
+      - run: pip install build && python -m build
+      - uses: pypa/gh-action-pypi-publish@7245906fb61fa33a13554f9d5fb856fe61758086 # v1.14.3

mapricot-0.1.0/.gitignore

@@ -0,0 +1,2 @@
+dist/
+__pycache__/

mapricot-0.1.0/LICENSE

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

mapricot-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.5
+Name: mapricot
+Version: 0.1.0
+Summary: Official client for the Mapricot API: geocoding, places, routing, and IP geolocation.
+Project-URL: Homepage, https://mapricot.com/
+Project-URL: Documentation, https://mapricot.com/docs/python/
+Project-URL: Source, https://github.com/mapricothq/mapricot/tree/main/sdks/python
+Project-URL: Issues, https://github.com/mapricothq/mapricot/issues
+License-Expression: MIT
+License-File: LICENSE
+Keywords: geocoding,ip-geolocation,maps,places,routing
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Mapricot for Python
+
+The official Python client for the [Mapricot API](https://mapricot.com/): address and place search, reverse geocoding, nearby places, routing, and IP geolocation, with 250,000 free requests every month.
+
+```sh
+pip install mapricot
+```
+
+It needs Python 3.11 or later and has no dependencies.
+
+## Quick start
+
+Create a server key in the [dashboard](https://app.mapricot.com/) and set it as `MAPRICOT_KEY`:
+
+```sh
+export MAPRICOT_KEY="mapricot_sk_…"
+```
+
+```python
+from mapricot import Mapricot
+
+client = Mapricot()
+
+data = client.search("128 SW 3rd Ave, Portland", limit=1)
+place = data["results"][0]
+print(place["label"], place["lat"], place["lon"])
+```
+
+Pass the key yourself with `Mapricot("mapricot_sk_…")`.
+
+## Methods
+
+Each method returns the API's JSON as a typed dict, with the same field names as the [API reference](https://mapricot.com/api-reference/).
+
+| Method | Endpoint |
+| --- | --- |
+| `client.search(q, focus=, country=, limit=, lang=)` | [`GET /v1/search`](https://mapricot.com/docs/geocoding/#find-an-address) |
+| `client.autocomplete(q, focus=, country=, limit=, lang=)` | [`GET /v1/autocomplete`](https://mapricot.com/docs/places/#suggest-as-people-type) |
+| `client.reverse(lat, lon, limit=, lang=)` | [`GET /v1/reverse`](https://mapricot.com/docs/geocoding/#find-the-address-at-a-point) |
+| `client.nearby(lat, lon, category=, radius=, limit=, lang=)` | [`GET /v1/nearby`](https://mapricot.com/docs/places/#list-places-around-a-point) |
+| `client.place(id, lang=)` | [`GET /v1/places/{id}`](https://mapricot.com/docs/places/#look-up-a-saved-place) |
+| `client.route(waypoints, mode=)` | [`POST /v1/route`](https://mapricot.com/docs/routing/#get-a-route) |
+| `client.ip(address)` | [`GET /v1/ip/{ip}`](https://mapricot.com/docs/ip-geolocation/#look-up-an-address) |
+| `client.account()` | `GET /v1/account`, which checks a key and is never billed |
+
+`focus` and each waypoint are `{"lat": …, "lon": …}`. `country` and `category` take a list or a comma-separated string.
+
+```python
+nearby = client.nearby(45.52, -122.68, category=["food:coffee_shop"], radius=1000)
+route = client.route([{"lat": 45.5189, "lon": -122.6793}, {"lat": 45.5214, "lon": -122.6828}], mode="walk")
+print(route["routes"][0]["durationSeconds"])
+```
+
+A route's `polyline` is encoded with six decimal places. Decode it with precision 6, as [decoding a route polyline](https://mapricot.com/docs/polyline/) shows.
+
+If your app shows results, show the credits in each response's `attribution`.
+
+## Errors and retries
+
+An error response raises `MapricotError`, with the HTTP `status`, the API's error `code`, a `message`, and the `request_id`:
+
+```python
+from mapricot import MapricotError
+
+try:
+    client.search("")
+except MapricotError as error:
+    print(error.status, error.code, error.message)  # 400 invalid_request The service rejected the request.
+```
+
+The client retries `503` responses and `429 concurrency_exceeded`, up to twice, waiting longer each time. Errors aren't billed. Set `max_retries=` and `timeout=` (seconds) on `Mapricot(...)` to change this. The [API reference](https://mapricot.com/api-reference/#errors) lists every status.
+
+## Links
+
+- [Mapricot](https://mapricot.com/)
+- [Python docs](https://mapricot.com/docs/python/)
+- [API reference](https://mapricot.com/api-reference/)
+- [Pricing](https://mapricot.com/pricing/)

mapricot-0.1.0/README.md

@@ -0,0 +1,78 @@
+# Mapricot for Python
+
+The official Python client for the [Mapricot API](https://mapricot.com/): address and place search, reverse geocoding, nearby places, routing, and IP geolocation, with 250,000 free requests every month.
+
+```sh
+pip install mapricot
+```
+
+It needs Python 3.11 or later and has no dependencies.
+
+## Quick start
+
+Create a server key in the [dashboard](https://app.mapricot.com/) and set it as `MAPRICOT_KEY`:
+
+```sh
+export MAPRICOT_KEY="mapricot_sk_…"
+```
+
+```python
+from mapricot import Mapricot
+
+client = Mapricot()
+
+data = client.search("128 SW 3rd Ave, Portland", limit=1)
+place = data["results"][0]
+print(place["label"], place["lat"], place["lon"])
+```
+
+Pass the key yourself with `Mapricot("mapricot_sk_…")`.
+
+## Methods
+
+Each method returns the API's JSON as a typed dict, with the same field names as the [API reference](https://mapricot.com/api-reference/).
+
+| Method | Endpoint |
+| --- | --- |
+| `client.search(q, focus=, country=, limit=, lang=)` | [`GET /v1/search`](https://mapricot.com/docs/geocoding/#find-an-address) |
+| `client.autocomplete(q, focus=, country=, limit=, lang=)` | [`GET /v1/autocomplete`](https://mapricot.com/docs/places/#suggest-as-people-type) |
+| `client.reverse(lat, lon, limit=, lang=)` | [`GET /v1/reverse`](https://mapricot.com/docs/geocoding/#find-the-address-at-a-point) |
+| `client.nearby(lat, lon, category=, radius=, limit=, lang=)` | [`GET /v1/nearby`](https://mapricot.com/docs/places/#list-places-around-a-point) |
+| `client.place(id, lang=)` | [`GET /v1/places/{id}`](https://mapricot.com/docs/places/#look-up-a-saved-place) |
+| `client.route(waypoints, mode=)` | [`POST /v1/route`](https://mapricot.com/docs/routing/#get-a-route) |
+| `client.ip(address)` | [`GET /v1/ip/{ip}`](https://mapricot.com/docs/ip-geolocation/#look-up-an-address) |
+| `client.account()` | `GET /v1/account`, which checks a key and is never billed |
+
+`focus` and each waypoint are `{"lat": …, "lon": …}`. `country` and `category` take a list or a comma-separated string.
+
+```python
+nearby = client.nearby(45.52, -122.68, category=["food:coffee_shop"], radius=1000)
+route = client.route([{"lat": 45.5189, "lon": -122.6793}, {"lat": 45.5214, "lon": -122.6828}], mode="walk")
+print(route["routes"][0]["durationSeconds"])
+```
+
+A route's `polyline` is encoded with six decimal places. Decode it with precision 6, as [decoding a route polyline](https://mapricot.com/docs/polyline/) shows.
+
+If your app shows results, show the credits in each response's `attribution`.
+
+## Errors and retries
+
+An error response raises `MapricotError`, with the HTTP `status`, the API's error `code`, a `message`, and the `request_id`:
+
+```python
+from mapricot import MapricotError
+
+try:
+    client.search("")
+except MapricotError as error:
+    print(error.status, error.code, error.message)  # 400 invalid_request The service rejected the request.
+```
+
+The client retries `503` responses and `429 concurrency_exceeded`, up to twice, waiting longer each time. Errors aren't billed. Set `max_retries=` and `timeout=` (seconds) on `Mapricot(...)` to change this. The [API reference](https://mapricot.com/api-reference/#errors) lists every status.
+
+## Links
+
+- [Mapricot](https://mapricot.com/)
+- [Python docs](https://mapricot.com/docs/python/)
+- [API reference](https://mapricot.com/api-reference/)
+- [Pricing](https://mapricot.com/pricing/)

mapricot-0.1.0/RELEASING.md

@@ -0,0 +1,15 @@
+# Releasing
+
+1. Bump the version in `src/mapricot/__init__.py` (`__version__`), following [semantic versioning](https://semver.org/), and merge it to `main`.
+2. Publish a GitHub release whose tag is that version with a `v`, such as `v0.2.0`: `gh release create v0.2.0 --generate-notes`.
+3. The release workflow runs the live tests, builds, and publishes to PyPI.
+
+## Keeping up with the API
+
+CI runs every Monday as well as on each push. Its `endpoints` job fails when [the API's OpenAPI description](https://api.mapricot.com/openapi.json) lists an endpoint this client has no method for, and its tests fail when a live response changes. Add or fix the method and its test, and release a new minor version. A new endpoint is added to every Mapricot SDK at the same time.
+
+## One-time setup
+
+- A repository secret or organization secret `MAPRICOT_KEY`: a server key with the `places`, `routing`, and `ip-geolocation` scopes and a monthly cap, used by the live tests.
+- A `release` environment in this repository.
+- On pypi.org, a pending trusted publisher for the `mapricot` project: this repository, workflow `release.yml`, environment `release`.

mapricot-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mapricot"
+dynamic = ["version"]
+description = "Official client for the Mapricot API: geocoding, places, routing, and IP geolocation."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+keywords = ["geocoding", "places", "routing", "ip-geolocation", "maps"]
+classifiers = ["Programming Language :: Python :: 3", "Typing :: Typed"]
+
+[project.urls]
+Homepage = "https://mapricot.com/"
+Documentation = "https://mapricot.com/docs/python/"
+Source = "https://github.com/mapricothq/mapricot/tree/main/sdks/python"
+Issues = "https://github.com/mapricothq/mapricot/issues"
+
+[tool.hatch.version]
+path = "src/mapricot/__init__.py"

mapricot-0.1.0/src/mapricot/__init__.py

@@ -0,0 +1,252 @@
+"""Official client for the Mapricot API: geocoding, places, routing, and IP geolocation."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Literal, NotRequired, Sequence, TypedDict
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Account",
+    "Address",
+    "Attribution",
+    "IpLocation",
+    "Leg",
+    "Mapricot",
+    "MapricotError",
+    "Place",
+    "PlaceResult",
+    "Places",
+    "Point",
+    "Route",
+    "Routes",
+]
+
+
+class Point(TypedDict):
+    lat: float
+    lon: float
+
+
+class Attribution(TypedDict):
+    source: str
+    text: str
+    url: str
+
+
+class Address(TypedDict, total=False):
+    houseNumber: str
+    street: str
+    postalCode: str
+    locality: str
+    region: str
+    regionCode: str
+    country: str
+    countryCode: str
+
+
+class Place(TypedDict):
+    id: str
+    type: str
+    name: str
+    label: str
+    lat: float
+    lon: float
+    address: NotRequired[Address]
+    categories: NotRequired[list[str]]
+    distanceMeters: NotRequired[int]
+    source: str
+
+
+class Places(TypedDict):
+    results: list[Place]
+    attribution: list[Attribution]
+
+
+class PlaceResult(TypedDict):
+    result: Place
+    attribution: list[Attribution]
+
+
+class Leg(TypedDict):
+    distanceMeters: int
+    durationSeconds: int
+
+
+class Route(TypedDict):
+    distanceMeters: int
+    durationSeconds: int
+    polyline: str
+    """Encoded polyline with six decimal places of precision."""
+    legs: list[Leg]
+
+
+class Routes(TypedDict):
+    routes: list[Route]
+    attribution: NotRequired[list[Attribution]]
+
+
+class IpLocation(TypedDict):
+    ip: str
+    found: bool
+    continentCode: NotRequired[str]
+    countryCode: NotRequired[str]
+    countryName: NotRequired[str]
+    regionCode: NotRequired[str]
+    regionName: NotRequired[str]
+    city: NotRequired[str]
+    location: NotRequired[Point]
+    source: str
+    attributionUrl: str
+    licenseUrl: str
+    datasetRelease: str
+
+
+class Account(TypedDict):
+    id: str
+    name: str
+    status: str
+    created_at: str
+
+
+class MapricotError(Exception):
+    """An error response from the API, with its HTTP status, error code, and request ID."""
+
+    def __init__(self, status: int, code: str, message: str, request_id: str | None):
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.message = message
+        self.request_id = request_id
+
+
+class Mapricot:
+    """A client for https://api.mapricot.com. The key defaults to the MAPRICOT_KEY environment variable."""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str = "https://api.mapricot.com",
+        timeout: float = 30,
+        max_retries: int = 2,
+    ):
+        api_key = api_key or os.environ.get("MAPRICOT_KEY")
+        if not api_key:
+            raise ValueError("Pass api_key or set MAPRICOT_KEY.")
+        self._api_key = api_key
+        self._base_url = base_url
+        self._timeout = timeout
+        self._max_retries = max_retries
+
+    def search(
+        self,
+        q: str,
+        *,
+        focus: Point | None = None,
+        country: str | Sequence[str] | None = None,
+        limit: int | None = None,
+        lang: str | None = None,
+    ) -> Places:
+        """Find addresses and places matching free text."""
+        return self._request("GET", "/v1/search", q=q, focus=focus, country=country, limit=limit, lang=lang)
+
+    def autocomplete(
+        self,
+        q: str,
+        *,
+        focus: Point | None = None,
+        country: str | Sequence[str] | None = None,
+        limit: int | None = None,
+        lang: str | None = None,
+    ) -> Places:
+        """Suggest addresses and places as someone types."""
+        return self._request("GET", "/v1/autocomplete", q=q, focus=focus, country=country, limit=limit, lang=lang)
+
+    def reverse(self, lat: float, lon: float, *, limit: int | None = None, lang: str | None = None) -> Places:
+        """Find the address nearest a coordinate, or the area around it."""
+        return self._request("GET", "/v1/reverse", lat=lat, lon=lon, limit=limit, lang=lang)
+
+    def nearby(
+        self,
+        lat: float,
+        lon: float,
+        *,
+        category: str | Sequence[str] | None = None,
+        radius: int | None = None,
+        limit: int | None = None,
+        lang: str | None = None,
+    ) -> Places:
+        """List places around a coordinate, optionally by category."""
+        return self._request(
+            "GET", "/v1/nearby", lat=lat, lon=lon, category=category, radius=radius, limit=limit, lang=lang
+        )
+
+    def place(self, id: str, *, lang: str | None = None) -> PlaceResult:
+        """Look up one place by its Mapricot ID."""
+        return self._request("GET", f"/v1/places/{urllib.parse.quote(id, safe='')}", lang=lang)
+
+    def route(self, waypoints: Sequence[Point], *, mode: Literal["drive", "walk", "bicycle"] | None = None) -> Routes:
+        """Find a route through 2 to 20 waypoints."""
+        body: dict[str, Any] = {"waypoints": list(waypoints)}
+        if mode:
+            body["mode"] = mode
+        return self._request("POST", "/v1/route", body=body)
+
+    def ip(self, address: str) -> IpLocation:
+        """Approximate location of a public IP address."""
+        return self._request("GET", f"/v1/ip/{urllib.parse.quote(address, safe='')}")
+
+    def account(self) -> Account:
+        """The key's account. Not billed, so it checks a key for free."""
+        return self._request("GET", "/v1/account")
+
+    def _request(self, method: str, path: str, body: dict[str, Any] | None = None, **params: Any) -> Any:
+        query = urllib.parse.urlencode({name: _format(value) for name, value in params.items() if value is not None})
+        url = self._base_url + path + (f"?{query}" if query else "")
+        headers = {"Authorization": f"Bearer {self._api_key}", "User-Agent": f"mapricot-python/{__version__}"}
+        data = None
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+            data = json.dumps(body).encode()
+
+        attempt = 0
+        while True:
+            request = urllib.request.Request(url, data=data, headers=headers, method=method)
+            try:
+                with urllib.request.urlopen(request, timeout=self._timeout) as response:
+                    return json.load(response)
+            except urllib.error.HTTPError as response:
+                with response:
+                    error = _error_from(response)
+            if attempt >= self._max_retries or not _retryable(error):
+                raise error
+            time.sleep(0.5 * 2**attempt)
+            attempt += 1
+
+
+def _format(value: Any) -> str:
+    if isinstance(value, dict):
+        return f"{value['lat']},{value['lon']}"
+    if isinstance(value, (list, tuple)):
+        return ",".join(value)
+    return str(value)
+
+
+def _error_from(response: urllib.error.HTTPError) -> MapricotError:
+    request_id = response.headers.get("X-Request-Id")
+    try:
+        error = json.load(response)["error"]
+        return MapricotError(response.code, error["code"], error["message"], request_id)
+    except (ValueError, KeyError, TypeError):
+        return MapricotError(response.code, "unknown", f"HTTP {response.code}", request_id)
+
+
+def _retryable(error: MapricotError) -> bool:
+    return error.status == 503 or error.code == "concurrency_exceeded"

mapricot-0.1.0/tests/test_live.py

@@ -0,0 +1,60 @@
+import os
+import unittest
+
+from mapricot import Mapricot, MapricotError
+
+
+@unittest.skipUnless(os.environ.get("MAPRICOT_KEY"), "set MAPRICOT_KEY to run tests against the live API")
+class LiveTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Mapricot()
+
+    def test_search(self):
+        data = self.client.search("128 SW 3rd Ave, Portland", country=["US"], limit=1)
+        self.assertEqual(data["results"][0]["address"]["locality"], "Portland")
+        self.assertTrue(data["attribution"])
+
+    def test_autocomplete(self):
+        data = self.client.autocomplete("stumptown", focus={"lat": 45.52, "lon": -122.68}, limit=1)
+        self.assertIn("Stumptown", data["results"][0]["name"])
+
+    def test_reverse(self):
+        data = self.client.reverse(45.5217, -122.6733, limit=1)
+        self.assertIsInstance(data["results"][0]["distanceMeters"], int)
+
+    def test_nearby(self):
+        data = self.client.nearby(45.52, -122.68, category=["food:coffee_shop"], radius=1000, limit=1)
+        self.assertIn("food:coffee_shop", data["results"][0]["categories"])
+
+    def test_place(self):
+        found = self.client.search("Pioneer Courthouse Square, Portland", limit=1)["results"][0]
+        self.assertEqual(self.client.place(found["id"])["result"]["id"], found["id"])
+
+    def test_route(self):
+        data = self.client.route([{"lat": 43.7396, "lon": 7.4275}, {"lat": 43.734, "lon": 7.4222}], mode="walk")
+        self.assertEqual(len(data["routes"][0]["legs"]), 1)
+        self.assertTrue(data["routes"][0]["polyline"])
+
+    def test_ip(self):
+        data = self.client.ip("8.8.8.8")
+        self.assertTrue(data["found"])
+        self.assertEqual(data["countryCode"], "US")
+
+    def test_account(self):
+        self.assertEqual(self.client.account()["status"], "active")
+
+    def test_invalid_request(self):
+        with self.assertRaises(MapricotError) as caught:
+            self.client.search("")
+        self.assertEqual(caught.exception.status, 400)
+        self.assertEqual(caught.exception.code, "invalid_request")
+        self.assertTrue(caught.exception.request_id)
+
+
+class BadKeyTest(unittest.TestCase):
+    def test_unauthorized(self):
+        with self.assertRaises(MapricotError) as caught:
+            Mapricot("mapricot_sk_bad").account()
+        self.assertEqual(caught.exception.status, 401)
+        self.assertEqual(caught.exception.code, "unauthorized")

mapricot-0.1.0/tests/test_retry.py

@@ -0,0 +1,48 @@
+import json
+import threading
+import unittest
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+from mapricot import Mapricot, MapricotError
+
+
+def serve(statuses):
+    seen = []
+
+    class Handler(BaseHTTPRequestHandler):
+        def do_GET(self):
+            seen.append(self.path)
+            status, code = statuses.pop(0) if statuses else (200, None)
+            body = {"ok": True} if status == 200 else {"error": {"code": code, "message": code}, "request_id": "r1"}
+            self.send_response(status)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("X-Request-Id", "r1")
+            self.end_headers()
+            self.wfile.write(json.dumps(body).encode())
+
+        def log_message(self, *args):
+            pass
+
+    server = HTTPServer(("127.0.0.1", 0), Handler)
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+    return server, seen, f"http://127.0.0.1:{server.server_port}"
+
+
+class RetryTest(unittest.TestCase):
+    def test_retries_503_and_concurrency_exceeded(self):
+        server, seen, base_url = serve([(503, "origin_overloaded"), (429, "concurrency_exceeded")])
+        self.addCleanup(server.server_close)
+        self.addCleanup(server.shutdown)
+        client = Mapricot("k", base_url=base_url)
+        self.assertEqual(client.search("x", focus={"lat": 1, "lon": 2}, country=["US", "CA"]), {"ok": True})
+        self.assertEqual(len(seen), 3)
+        self.assertEqual(seen[0], "/v1/search?q=x&focus=1%2C2&country=US%2CCA")
+
+    def test_does_not_retry_credit_exhausted(self):
+        server, seen, base_url = serve([(429, "credit_exhausted")])
+        self.addCleanup(server.server_close)
+        self.addCleanup(server.shutdown)
+        with self.assertRaises(MapricotError) as caught:
+            Mapricot("k", base_url=base_url).account()
+        self.assertEqual((caught.exception.status, caught.exception.code, caught.exception.request_id), (429, "credit_exhausted", "r1"))
+        self.assertEqual(len(seen), 1)