gmaps-boundary 0.1.0__tar.gz

gmaps_boundary-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+.scratch/
+.venv/
+dist/
+__pycache__/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+.vscode/

gmaps_boundary-0.1.0/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+This project follows [Semantic Versioning](https://semver.org/).
+
+## 0.1.0 - 2026-11-11
+
+- `fetch_boundary` and `find_place` helpers.
+- `BoundaryClient` and `AsyncBoundaryClient` with proxy, retry and locale settings.
+- Lookup by place name, Google Maps place URL or `Place`.
+- Automatic zoom selection within a tile cap.
+- `http_client` option to send requests through your own httpx session.
+- `gmaps-boundary` command with GeoJSON output.
+- PNG preview over an OpenStreetMap basemap, from the command or `save_preview`.

gmaps_boundary-0.1.0/LICENSE

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

gmaps_boundary-0.1.0/PKG-INFO

@@ -0,0 +1,214 @@
+Metadata-Version: 2.5
+Name: gmaps-boundary
+Version: 0.1.0
+Summary: Fetch the boundary polygon Google Maps draws for a locality, city or postal code, as GeoJSON.
+Project-URL: Homepage, https://github.com/kujjwal02/gmaps-boundary
+Project-URL: Issues, https://github.com/kujjwal02/gmaps-boundary/issues
+Project-URL: Changelog, https://github.com/kujjwal02/gmaps-boundary/blob/main/CHANGELOG.md
+Author: Ujjwal Kumar
+License-Expression: MIT
+License-File: LICENSE
+Keywords: boundary,geofence,geojson,gis,google maps,locality,polygon
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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 :: Scientific/Engineering :: GIS
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: numpy>=1.24
+Requires-Dist: shapely>=2.0
+Provides-Extra: preview
+Requires-Dist: matplotlib>=3.7; extra == 'preview'
+Description-Content-Type: text/markdown
+
+# gmaps-boundary
+
+Fetch the boundary polygon that Google Maps draws for a locality, city or postal code, as GeoJSON.
+
+When you search for an area on Google Maps, the map outlines it with a red dotted line. This library reads that outline from the map's vector tiles and returns it as a polygon. It needs no API key and no browser.
+
+![Boundary of Indiranagar, Bengaluru, drawn over OpenStreetMap](https://raw.githubusercontent.com/kujjwal02/gmaps-boundary/main/docs/indiranagar.png)
+
+## Install
+
+```bash
+pip install gmaps-boundary
+```
+
+Python 3.10 or newer. Dependencies: `httpx`, `shapely`, `numpy`.
+
+## Use it
+
+```python
+from gmaps_boundary import fetch_boundary
+
+boundary = fetch_boundary("Indiranagar, Bengaluru")
+
+boundary.place.name  # 'Indiranagar'
+boundary.geometry  # shapely Polygon in WGS 84 (x = longitude, y = latitude)
+boundary.bounds  # (west, south, east, north)
+boundary.zoom  # 17
+boundary.resolution_m  # 0.07, the size of one coordinate step in metres
+boundary.to_geojson()  # GeoJSON Feature as a dict
+```
+
+`fetch_boundary` accepts any of these:
+
+- a place name: `"Indiranagar, Bengaluru"`, `"560038"`, `"Manhattan, New York"`
+- a full Google Maps place URL, the one that contains `!1s0x...:0x...`
+- a `Place` object, from `find_place` or built by hand
+
+`Boundary` implements `__geo_interface__`, so GeoPandas and other libraries accept it directly:
+
+```python
+import geopandas
+
+frame = geopandas.GeoDataFrame.from_features([boundary.to_geojson()], crs="EPSG:4326")
+```
+
+### Many places
+
+Reuse one client. It keeps connections open and applies the same settings to every request.
+
+```python
+from gmaps_boundary import BoundaryClient
+
+with BoundaryClient(proxy="http://user:pass@host:8080", request_delay_s=0.2) as client:
+    for name in ["Indiranagar, Bengaluru", "Koramangala, Bengaluru"]:
+        boundary = client.fetch_boundary(name)
+```
+
+### Your own HTTP session
+
+Pass your own `httpx.Client` to control cookies, headers, proxies, timeouts and connection limits. The boundary client sends every request through it and never closes it.
+
+```python
+import httpx
+from gmaps_boundary import BoundaryClient
+
+session = httpx.Client(
+    headers={"User-Agent": "Mozilla/5.0 ..."},
+    cookies={"NID": "..."},
+    proxy="http://user:pass@host:8080",
+    timeout=30.0,
+)
+with BoundaryClient(http_client=session) as client:
+    boundary = client.fetch_boundary("Indiranagar, Bengaluru")
+session.close()
+```
+
+`AsyncBoundaryClient` takes an `httpx.AsyncClient` the same way. Set a browser User-Agent on your session: Google answers the default httpx one differently. `http_client` cannot be combined with `proxy`, `timeout_s`, `user_agent` or `transport`; set those on the session.
+
+### Async
+
+`AsyncBoundaryClient` fetches tiles concurrently. A locality takes about 6 seconds with `concurrency=8`, against about 25 seconds for the sync client.
+
+```python
+import asyncio
+from gmaps_boundary import AsyncBoundaryClient
+
+
+async def main() -> None:
+    async with AsyncBoundaryClient(concurrency=8) as client:
+        boundary = await client.fetch_boundary("Koramangala, Bengaluru")
+
+
+asyncio.run(main())
+```
+
+### Command line
+
+```bash
+gmaps-boundary "Indiranagar, Bengaluru" -o indiranagar.geojson
+gmaps-boundary "560038" --zoom 16 --indent 2 > pincode.geojson
+gmaps-boundary "Manhattan, New York" -o manhattan.geojson --preview manhattan.png
+```
+
+`--preview` draws the boundary over an OpenStreetMap map and needs `pip install 'gmaps-boundary[preview]'`. Add `--no-basemap` to draw the outline alone, with no request to OpenStreetMap. Run `gmaps-boundary --help` for every option.
+
+The same drawing is available from Python:
+
+```python
+from gmaps_boundary.preview import save_preview
+
+save_preview(boundary, "indiranagar.png")  # over OpenStreetMap
+save_preview(boundary, "outline.png", basemap=False)  # outline only
+```
+
+The basemap uses at most 20 tiles from `tile.openstreetmap.org` per image. Map data (C) OpenStreetMap contributors.
+
+## Name lookup
+
+A name goes to Google Maps search, and the library takes the place Google opens for it.
+
+- A name that matches nothing, or a category search such as `"cafes in Indiranagar"`, raises `PlaceNotFoundError`.
+- An ambiguous name resolves to Google's top pick, which depends on the region of your IP address. `"Springfield"` can resolve to a landmark instead of a city. Add the city, state or country to the name, and check `boundary.place.address`.
+- A name that resolves to a place without a boundary, such as a shop or a road, raises `NoBoundaryError`.
+- To check a name before you fetch, call `find_place(name)`. It makes one request and returns the `Place`.
+
+## Zoom and accuracy
+
+Coordinates come from Google's tiles as integers, 4096 steps per tile side. A higher zoom means smaller steps and more vertices.
+
+| zoom | step at the equator | typical use |
+|---|---|---|
+| 17 | 0.07 m | localities, postal codes |
+| 15 | 0.30 m | large districts |
+| 14 | 0.60 m | cities |
+| 12 | 2.4 m | regions |
+
+Zoom 17 is the finest zoom that carries boundaries. With `zoom=None`, the default, the library picks the finest zoom that fits `max_tiles` (default 500 tile requests per pass). Pass `zoom=` to fix it, or raise `max_tiles` for more detail on a large place.
+
+For Indiranagar, the zoom 17 polygon has 214 vertices. Its bounds match the viewport Google Maps itself uses for the place to within 0.2 m.
+
+## Errors
+
+Every error is a subclass of `GmapsBoundaryError`.
+
+| error | meaning |
+|---|---|
+| `PlaceNotFoundError` | The name matches no single place. Try a more specific name. |
+| `NoBoundaryError` | Google Maps draws no boundary for the place, for example a shop or a road. |
+| `TooManyTilesError` | The place does not fit `max_tiles` at the requested zoom. |
+| `ResponseFormatError` | A response had an unexpected shape. Google may have changed the format. |
+| `RequestFailedError` | A request failed after every retry. |
+
+## How it works
+
+1. A name is resolved to a place through Google Maps search. This gives the feature id and the label point.
+2. Google Maps highlights a place through a vector tile layer named `spotlit`. Each tile carries a mask polygon that covers everything outside the place.
+3. The library reads the outline at a coarse zoom first. That pass sizes the job and tells the fine pass which tiles to fetch.
+4. For each fine tile, the place part is the tile square minus the mask. The parts are merged into one polygon and converted to longitude and latitude.
+
+## Limits
+
+- The tile and search formats are undocumented. Google can change them without notice. The library then raises `ResponseFormatError` instead of returning a wrong polygon.
+- A place made of separate pieces is returned as a `MultiPolygon`. A piece that lies more than about 10 km from the label point and does not touch the rest can be missed.
+- Short `maps.app.goo.gl` links are not accepted. Open the link and copy the full URL.
+- The boundary is what Google Maps displays. It is not an official administrative boundary.
+
+## Terms of use
+
+This library is not affiliated with Google. It reads undocumented endpoints, which the Google Maps Platform Terms of Service do not permit for all uses. You are responsible for how you use it and for the data you collect. Keep the request rate low.
+
+## Development
+
+```bash
+uv sync
+uv run pytest             # offline, replays recorded responses
+uv run pytest -m live     # calls Google
+uv run ruff check . && uv run ruff format --check . && uv run mypy
+uv run python tests/record_fixtures.py   # refresh the recorded responses
+```
+
+## License
+
+MIT

gmaps_boundary-0.1.0/README.md

@@ -0,0 +1,183 @@
+# gmaps-boundary
+
+Fetch the boundary polygon that Google Maps draws for a locality, city or postal code, as GeoJSON.
+
+When you search for an area on Google Maps, the map outlines it with a red dotted line. This library reads that outline from the map's vector tiles and returns it as a polygon. It needs no API key and no browser.
+
+![Boundary of Indiranagar, Bengaluru, drawn over OpenStreetMap](https://raw.githubusercontent.com/kujjwal02/gmaps-boundary/main/docs/indiranagar.png)
+
+## Install
+
+```bash
+pip install gmaps-boundary
+```
+
+Python 3.10 or newer. Dependencies: `httpx`, `shapely`, `numpy`.
+
+## Use it
+
+```python
+from gmaps_boundary import fetch_boundary
+
+boundary = fetch_boundary("Indiranagar, Bengaluru")
+
+boundary.place.name  # 'Indiranagar'
+boundary.geometry  # shapely Polygon in WGS 84 (x = longitude, y = latitude)
+boundary.bounds  # (west, south, east, north)
+boundary.zoom  # 17
+boundary.resolution_m  # 0.07, the size of one coordinate step in metres
+boundary.to_geojson()  # GeoJSON Feature as a dict
+```
+
+`fetch_boundary` accepts any of these:
+
+- a place name: `"Indiranagar, Bengaluru"`, `"560038"`, `"Manhattan, New York"`
+- a full Google Maps place URL, the one that contains `!1s0x...:0x...`
+- a `Place` object, from `find_place` or built by hand
+
+`Boundary` implements `__geo_interface__`, so GeoPandas and other libraries accept it directly:
+
+```python
+import geopandas
+
+frame = geopandas.GeoDataFrame.from_features([boundary.to_geojson()], crs="EPSG:4326")
+```
+
+### Many places
+
+Reuse one client. It keeps connections open and applies the same settings to every request.
+
+```python
+from gmaps_boundary import BoundaryClient
+
+with BoundaryClient(proxy="http://user:pass@host:8080", request_delay_s=0.2) as client:
+    for name in ["Indiranagar, Bengaluru", "Koramangala, Bengaluru"]:
+        boundary = client.fetch_boundary(name)
+```
+
+### Your own HTTP session
+
+Pass your own `httpx.Client` to control cookies, headers, proxies, timeouts and connection limits. The boundary client sends every request through it and never closes it.
+
+```python
+import httpx
+from gmaps_boundary import BoundaryClient
+
+session = httpx.Client(
+    headers={"User-Agent": "Mozilla/5.0 ..."},
+    cookies={"NID": "..."},
+    proxy="http://user:pass@host:8080",
+    timeout=30.0,
+)
+with BoundaryClient(http_client=session) as client:
+    boundary = client.fetch_boundary("Indiranagar, Bengaluru")
+session.close()
+```
+
+`AsyncBoundaryClient` takes an `httpx.AsyncClient` the same way. Set a browser User-Agent on your session: Google answers the default httpx one differently. `http_client` cannot be combined with `proxy`, `timeout_s`, `user_agent` or `transport`; set those on the session.
+
+### Async
+
+`AsyncBoundaryClient` fetches tiles concurrently. A locality takes about 6 seconds with `concurrency=8`, against about 25 seconds for the sync client.
+
+```python
+import asyncio
+from gmaps_boundary import AsyncBoundaryClient
+
+
+async def main() -> None:
+    async with AsyncBoundaryClient(concurrency=8) as client:
+        boundary = await client.fetch_boundary("Koramangala, Bengaluru")
+
+
+asyncio.run(main())
+```
+
+### Command line
+
+```bash
+gmaps-boundary "Indiranagar, Bengaluru" -o indiranagar.geojson
+gmaps-boundary "560038" --zoom 16 --indent 2 > pincode.geojson
+gmaps-boundary "Manhattan, New York" -o manhattan.geojson --preview manhattan.png
+```
+
+`--preview` draws the boundary over an OpenStreetMap map and needs `pip install 'gmaps-boundary[preview]'`. Add `--no-basemap` to draw the outline alone, with no request to OpenStreetMap. Run `gmaps-boundary --help` for every option.
+
+The same drawing is available from Python:
+
+```python
+from gmaps_boundary.preview import save_preview
+
+save_preview(boundary, "indiranagar.png")  # over OpenStreetMap
+save_preview(boundary, "outline.png", basemap=False)  # outline only
+```
+
+The basemap uses at most 20 tiles from `tile.openstreetmap.org` per image. Map data (C) OpenStreetMap contributors.
+
+## Name lookup
+
+A name goes to Google Maps search, and the library takes the place Google opens for it.
+
+- A name that matches nothing, or a category search such as `"cafes in Indiranagar"`, raises `PlaceNotFoundError`.
+- An ambiguous name resolves to Google's top pick, which depends on the region of your IP address. `"Springfield"` can resolve to a landmark instead of a city. Add the city, state or country to the name, and check `boundary.place.address`.
+- A name that resolves to a place without a boundary, such as a shop or a road, raises `NoBoundaryError`.
+- To check a name before you fetch, call `find_place(name)`. It makes one request and returns the `Place`.
+
+## Zoom and accuracy
+
+Coordinates come from Google's tiles as integers, 4096 steps per tile side. A higher zoom means smaller steps and more vertices.
+
+| zoom | step at the equator | typical use |
+|---|---|---|
+| 17 | 0.07 m | localities, postal codes |
+| 15 | 0.30 m | large districts |
+| 14 | 0.60 m | cities |
+| 12 | 2.4 m | regions |
+
+Zoom 17 is the finest zoom that carries boundaries. With `zoom=None`, the default, the library picks the finest zoom that fits `max_tiles` (default 500 tile requests per pass). Pass `zoom=` to fix it, or raise `max_tiles` for more detail on a large place.
+
+For Indiranagar, the zoom 17 polygon has 214 vertices. Its bounds match the viewport Google Maps itself uses for the place to within 0.2 m.
+
+## Errors
+
+Every error is a subclass of `GmapsBoundaryError`.
+
+| error | meaning |
+|---|---|
+| `PlaceNotFoundError` | The name matches no single place. Try a more specific name. |
+| `NoBoundaryError` | Google Maps draws no boundary for the place, for example a shop or a road. |
+| `TooManyTilesError` | The place does not fit `max_tiles` at the requested zoom. |
+| `ResponseFormatError` | A response had an unexpected shape. Google may have changed the format. |
+| `RequestFailedError` | A request failed after every retry. |
+
+## How it works
+
+1. A name is resolved to a place through Google Maps search. This gives the feature id and the label point.
+2. Google Maps highlights a place through a vector tile layer named `spotlit`. Each tile carries a mask polygon that covers everything outside the place.
+3. The library reads the outline at a coarse zoom first. That pass sizes the job and tells the fine pass which tiles to fetch.
+4. For each fine tile, the place part is the tile square minus the mask. The parts are merged into one polygon and converted to longitude and latitude.
+
+## Limits
+
+- The tile and search formats are undocumented. Google can change them without notice. The library then raises `ResponseFormatError` instead of returning a wrong polygon.
+- A place made of separate pieces is returned as a `MultiPolygon`. A piece that lies more than about 10 km from the label point and does not touch the rest can be missed.
+- Short `maps.app.goo.gl` links are not accepted. Open the link and copy the full URL.
+- The boundary is what Google Maps displays. It is not an official administrative boundary.
+
+## Terms of use
+
+This library is not affiliated with Google. It reads undocumented endpoints, which the Google Maps Platform Terms of Service do not permit for all uses. You are responsible for how you use it and for the data you collect. Keep the request rate low.
+
+## Development
+
+```bash
+uv sync
+uv run pytest             # offline, replays recorded responses
+uv run pytest -m live     # calls Google
+uv run ruff check . && uv run ruff format --check . && uv run mypy
+uv run python tests/record_fixtures.py   # refresh the recorded responses
+```
+
+## License
+
+MIT

gmaps_boundary-0.1.0/pyproject.toml

@@ -0,0 +1,79 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "gmaps-boundary"
+version = "0.1.0"
+description = "Fetch the boundary polygon Google Maps draws for a locality, city or postal code, as GeoJSON."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "Ujjwal Kumar" }]
+keywords = ["google maps", "boundary", "polygon", "geojson", "locality", "geofence", "gis"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering :: GIS",
+    "Typing :: Typed",
+]
+dependencies = [
+    "httpx>=0.27",
+    "numpy>=1.24",
+    "shapely>=2.0",
+]
+
+[project.optional-dependencies]
+preview = ["matplotlib>=3.7"]
+
+[project.scripts]
+gmaps-boundary = "gmaps_boundary.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/kujjwal02/gmaps-boundary"
+Issues = "https://github.com/kujjwal02/gmaps-boundary/issues"
+Changelog = "https://github.com/kujjwal02/gmaps-boundary/blob/main/CHANGELOG.md"
+
+[dependency-groups]
+dev = [
+    "matplotlib>=3.7",
+    "mypy>=1.13",
+    "pytest>=8",
+    "ruff>=0.8",
+    "types-shapely>=2.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/gmaps_boundary"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src", "tests", "README.md", "LICENSE", "CHANGELOG.md"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-m 'not live'"
+markers = ["live: calls Google over the network"]
+
+[tool.ruff]
+line-length = 100
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP", "SIM", "RUF", "PT", "C4"]
+
+[tool.mypy]
+strict = true
+files = ["src", "tests"]
+
+[[tool.mypy.overrides]]
+module = ["matplotlib.*"]
+ignore_missing_imports = true

gmaps_boundary-0.1.0/src/gmaps_boundary/__init__.py

@@ -0,0 +1,45 @@
+"""Fetch the boundary polygon Google Maps draws for a place.
+
+Public names:
+    fetch_boundary, find_place: one-off helpers.
+    BoundaryClient, AsyncBoundaryClient: reusable clients.
+    Boundary, Place: the returned types.
+    MAX_ZOOM: the finest tile zoom that carries boundaries.
+    preview.save_preview: draw a boundary to a PNG (needs the preview extra).
+    GmapsBoundaryError and its subclasses: PlaceNotFoundError, NoBoundaryError,
+        TooManyTilesError, ResponseFormatError, RequestFailedError.
+"""
+
+from importlib.metadata import version
+
+from ._boundary import Boundary
+from ._places import Place
+from ._tiles import MAX_ZOOM
+from .client import AsyncBoundaryClient, BoundaryClient, fetch_boundary, find_place
+from .errors import (
+    GmapsBoundaryError,
+    NoBoundaryError,
+    PlaceNotFoundError,
+    RequestFailedError,
+    ResponseFormatError,
+    TooManyTilesError,
+)
+
+__version__ = version("gmaps-boundary")
+
+__all__ = [
+    "MAX_ZOOM",
+    "AsyncBoundaryClient",
+    "Boundary",
+    "BoundaryClient",
+    "GmapsBoundaryError",
+    "NoBoundaryError",
+    "Place",
+    "PlaceNotFoundError",
+    "RequestFailedError",
+    "ResponseFormatError",
+    "TooManyTilesError",
+    "__version__",
+    "fetch_boundary",
+    "find_place",
+]

gmaps_boundary-0.1.0/src/gmaps_boundary/_boundary.py

@@ -0,0 +1,61 @@
+"""The public ``Boundary`` type."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Any
+
+from shapely import MultiPolygon, Polygon
+from shapely.geometry import mapping
+
+from ._places import Place
+from ._tiles import TILE_EXTENT
+
+_EQUATOR_LENGTH_M = 40_075_016.686
+
+PolygonalGeometry = Polygon | MultiPolygon
+
+
+@dataclass(frozen=True)
+class Boundary:
+    """The boundary Google Maps draws for a place.
+
+    ``geometry`` is a shapely geometry in WGS 84, with x as longitude and y as latitude.
+    ``zoom`` is the tile zoom the boundary was read at. A higher zoom has more vertices.
+    """
+
+    place: Place
+    zoom: int
+    geometry: PolygonalGeometry
+
+    @property
+    def bounds(self) -> tuple[float, float, float, float]:
+        """``(west, south, east, north)`` in degrees."""
+        west, south, east, north = self.geometry.bounds
+        return west, south, east, north
+
+    @property
+    def resolution_m(self) -> float:
+        """The size of one coordinate step at this zoom and latitude, in metres."""
+        metres_per_tile = _EQUATOR_LENGTH_M * math.cos(math.radians(self.place.latitude))
+        return metres_per_tile / ((1 << self.zoom) * TILE_EXTENT)
+
+    @property
+    def __geo_interface__(self) -> dict[str, Any]:
+        return self.to_geojson()
+
+    def to_geojson(self) -> dict[str, Any]:
+        """Return a GeoJSON Feature. Its properties describe the place."""
+        return {
+            "type": "Feature",
+            "properties": {
+                "name": self.place.name,
+                "address": self.place.address,
+                "feature_id": self.place.feature_id,
+                "label_latitude": self.place.latitude,
+                "label_longitude": self.place.longitude,
+                "zoom": self.zoom,
+            },
+            "geometry": mapping(self.geometry),
+        }