Spaces:
Sleeping
Sleeping
| from __future__ import annotations | |
| from typing import Any | |
| from config import load_settings | |
| from .graph_loader import all_junction_ids | |
| from .storage import read_json | |
| def load_map_atlas() -> dict[str, Any]: | |
| return read_json(load_settings().map_atlas_path) | |
| def validate_map_atlas(atlas: dict[str, Any] | None = None) -> list[str]: | |
| atlas = atlas or load_map_atlas() | |
| valid_junctions = set(all_junction_ids()) | |
| errors: list[str] = [] | |
| district_ids: set[str] = set() | |
| landmark_ids: set[str] = set() | |
| for district in atlas.get("districts", []): | |
| district_id = str(district.get("id", "")).strip() | |
| if not district_id or district_id in district_ids: | |
| errors.append(f"Invalid or duplicate district id: {district_id!r}") | |
| district_ids.add(district_id) | |
| errors.extend(_junction_errors(district, valid_junctions, district_id)) | |
| errors.extend(_anchor_errors(district, district_id)) | |
| for landmark in atlas.get("landmarks", []): | |
| landmark_id = str(landmark.get("id", "")).strip() | |
| if not landmark_id or landmark_id in landmark_ids: | |
| errors.append(f"Invalid or duplicate landmark id: {landmark_id!r}") | |
| landmark_ids.add(landmark_id) | |
| district_id = landmark.get("district_id") | |
| if district_id and district_id not in district_ids: | |
| errors.append(f"Landmark {landmark_id} references unknown district {district_id}") | |
| errors.extend(_junction_errors(landmark, valid_junctions, landmark_id)) | |
| errors.extend(_anchor_errors(landmark, landmark_id)) | |
| return errors | |
| def places_for_junction(junction_id: int) -> list[dict[str, Any]]: | |
| atlas = load_map_atlas() | |
| matches: list[dict[str, Any]] = [] | |
| for entry in [*atlas.get("districts", []), *atlas.get("landmarks", [])]: | |
| junctions = set(entry.get("junction_ids", [])) | |
| if entry.get("junction_id") is not None: | |
| junctions.add(entry["junction_id"]) | |
| junctions.update(entry.get("nearby_junction_ids", [])) | |
| if junction_id in junctions: | |
| matches.append(entry) | |
| return matches | |
| def primary_place_for_junction(junction_id: int) -> dict[str, Any] | None: | |
| places = places_for_junction(junction_id) | |
| landmarks = [place for place in places if place.get("category") != "district"] | |
| return (landmarks or places or [None])[0] | |
| def public_atlas_payload() -> dict[str, Any]: | |
| atlas = load_map_atlas() | |
| return { | |
| "schema_version": atlas.get("schema_version", 1), | |
| "map_id": atlas.get("map_id", "london_main"), | |
| "districts": atlas.get("districts", []), | |
| "landmarks": atlas.get("landmarks", []), | |
| } | |
| def _junction_errors(entry: dict[str, Any], valid: set[int], entry_id: str) -> list[str]: | |
| values = list(entry.get("junction_ids", [])) + list(entry.get("nearby_junction_ids", [])) | |
| if entry.get("junction_id") is not None: | |
| values.append(entry["junction_id"]) | |
| return [f"{entry_id} references unknown junction {value}" for value in values if value not in valid] | |
| def _anchor_errors(entry: dict[str, Any], entry_id: str) -> list[str]: | |
| anchor = entry.get("anchor") or {} | |
| x = anchor.get("x") | |
| y = anchor.get("y") | |
| if not isinstance(x, (int, float)) or not isinstance(y, (int, float)): | |
| return [f"{entry_id} has an invalid anchor"] | |
| if not 0 <= x <= 1450 or not 0 <= y <= 1090: | |
| return [f"{entry_id} anchor is outside the map"] | |
| return [] | |