Skip to content

armgit / Aleph

Public Imported from GitHub
0

Give satellite imagery, terrain data, buildings, streetview photos to your LLM

4.3 KB
Raw Blame
"""Place search, reverse lookup, and nearby OSM points of interest."""

import json
from urllib.parse import urlsplit

from .common import APP_AGENT, RequestError, number, url
from .geo import around, distance, point
from .osm import POI_KEYS

GEOCODER = "https://photon.komoot.io"


def geocode(client, *, query=None, at=None, limit=5, street=False, endpoint=GEOCODER):
    number(limit, "limit", 1, 50, whole=True)
    endpoint = endpoint.rstrip("/")
    address = urlsplit(endpoint)
    if address.scheme not in ("http", "https") or not address.netloc:
        raise ValueError("The geocoder URL must use HTTP or HTTPS.")
    params = dict(limit=limit)
    if query is not None:
        if not query.strip():
            raise ValueError("Enter a nonempty place name.")
        params["q"] = query
        if street:
            params["layer"] = "street"
        path = "/api/"
    else:
        params["lat"], params["lon"] = point(at)
        path = "/reverse/"
    try:
        data = json.loads(client.get(url(endpoint + path, **params), user_agent=APP_AGENT))
    except (OSError, ValueError) as error:
        raise RequestError("provider_unavailable", f"Geocoder request failed: {error}") from error
    if not isinstance(data.get("features"), list):
        raise RequestError("provider_unavailable", "The geocoder returned an unreadable response.")
    results, seen = [], set()
    for feature in data["features"]:
        props = feature["properties"]
        lon, lat = feature["geometry"]["coordinates"][:2]
        point((lat, lon))
        kind = {"N": "node", "W": "way", "R": "relation"}[props["osm_type"]]
        identity = f"{kind}/{int(props['osm_id'])}"
        if identity in seen:
            continue
        seen.add(identity)
        name = props.get("name") or props.get("street") or "Unnamed place"
        label = ", ".join(dict.fromkeys(str(v) for v in (
            name, props.get("housenumber"), props.get("city"),
            props.get("state"), props.get("country"),
        ) if v))
        result = dict(id=identity, name=name, label=label, lat=lat, lon=lon,
                      category=f"{props.get('osm_key', 'place')}:{props.get('osm_value', 'unknown')}",
                      source="OpenStreetMap", source_url=f"https://www.openstreetmap.org/{identity}")
        if at is not None:
            result["distance_m"] = round(distance(at, (lat, lon)), 2)
        results.append(result)
    return results


def choose(client, query, *, match=None, best_match=False, street=False, endpoint=GEOCODER):
    candidates = geocode(client, query=query, street=street, endpoint=endpoint, limit=10)
    if not candidates:
        raise RequestError("place_not_found", "No matching place was found. Include a city or country.")
    if match is None and (best_match or len(candidates) == 1):
        return candidates[0]
    for candidate in candidates:
        if candidate["id"] == match:
            return candidate
    raise RequestError("ambiguous_place", "Choose a returned place with --match TYPE/ID.", candidates=candidates)


def nearby(client, at, *, radius=100, limit=10, progress=lambda *args: None):
    lat, lon = point(at)
    number(radius, "radius", 1, 5000)
    number(limit, "limit", 1, 50, whole=True)
    items, metadata = client.maps.data(around((lat, lon), radius * 2), poi=True, progress=progress)
    results = []
    for item in items:
        tags = item["tags"]
        if not any(key in tags for key in POI_KEYS):
            continue
        center = item.get("center")
        if center is None:
            continue
        separation = distance(at, center)
        # Ways/relations are represented by their bounding-box center, not an entrance.
        if separation > radius:
            continue
        identity = f"{item['type']}/{item['id']}"
        categories = [f"{key}:{tags[key]}" for key in POI_KEYS if key in tags]
        results.append(dict(id=identity, name=tags.get("name"), categories=categories,
                            lat=center[0], lon=center[1], distance_m=round(separation, 2),
                            location_type="point" if item["type"] == "node" else "bbox_center",
                            source="OpenStreetMap", source_url=f"https://www.openstreetmap.org/{identity}",
                            osm_data_at=metadata["osm_data_at"]))
    results.sort(key=lambda item: (item["distance_m"], item["id"]))
    return results[:limit]