From 8688b7475e6d9a270b04e7318d6d5d248f14bdff Mon Sep 17 00:00:00 2001 From: Andras Schmelczer Date: Sun, 31 May 2026 15:36:33 +0100 Subject: [PATCH 1/9] scraping and data --- .gitignore | 2 + finder/Dockerfile | 25 + finder/constants.py | 52 +- finder/docker-compose.yml | 57 ++ finder/flaresolverr.py | 91 +++ finder/gdal-ecw/Dockerfile | 53 ++ finder/http_client.py | 4 +- finder/main.py | 39 +- finder/onthemarket.py | 219 ++++++- finder/rightmove.py | 228 +++++++- finder/scraper.py | 100 ++++ finder/storage.py | 10 + finder/test_onthemarket.py | 206 +++++++ finder/test_rightmove.py | 113 ++++ finder/test_transform.py | 129 +++- finder/test_zoopla.py | 288 +++++++++ finder/transform.py | 101 +++- finder/zoopla.py | 381 +++++++++++- finder/zoopla_flaresolverr.py | 164 ++++++ frontend/src/components/map/Map.tsx | 13 +- .../src/components/map/MobileDrawer.test.tsx | 107 ++++ frontend/src/lib/color-opacity.ts | 11 + frontend/src/lib/crime-types.ts | 35 ++ pipeline/download/inspire.py | 5 +- pipeline/download/satellite_highres.py | 505 ++++++++++++++++ pipeline/download/test_satellite_highres.py | 97 ++++ pipeline/test_validate_outputs.py | 52 ++ pipeline/transform/crime_spatial.py | 358 ++++++++++++ pipeline/transform/join_epc_pp.py | 3 + pipeline/transform/merge.py | 549 +++++++----------- pipeline/transform/noise_overlay_tiles.py | 2 +- .../transform/postcode_boundaries/__main__.py | 8 +- .../transform/postcode_boundaries/loader.py | 105 ++++ .../test_postcode_boundaries.py | 44 ++ .../transform/postcode_boundaries/uprn.py | 38 +- pipeline/transform/property_border_tiles.py | 138 +++++ pipeline/transform/test_crime_spatial.py | 147 +++++ pipeline/transform/test_join_epc_pp.py | 2 + pipeline/transform/test_merge.py | 367 ++++++++++-- pipeline/transform/test_tree_density.py | 64 ++ pipeline/transform/tree_density.py | 284 ++++++++- pipeline/transform/tree_overlay_tiles.py | 155 ++++- pipeline/validate_outputs.py | 100 ++++ 43 files changed, 4920 insertions(+), 531 deletions(-) create mode 100644 finder/Dockerfile create mode 100644 finder/docker-compose.yml create mode 100644 finder/flaresolverr.py create mode 100644 finder/gdal-ecw/Dockerfile create mode 100644 finder/test_onthemarket.py create mode 100644 finder/test_rightmove.py create mode 100644 finder/test_zoopla.py create mode 100644 finder/zoopla_flaresolverr.py create mode 100644 frontend/src/components/map/MobileDrawer.test.tsx create mode 100644 frontend/src/lib/color-opacity.ts create mode 100644 frontend/src/lib/crime-types.ts create mode 100644 pipeline/download/satellite_highres.py create mode 100644 pipeline/download/test_satellite_highres.py create mode 100644 pipeline/transform/crime_spatial.py create mode 100644 pipeline/transform/postcode_boundaries/loader.py create mode 100644 pipeline/transform/property_border_tiles.py create mode 100644 pipeline/transform/test_crime_spatial.py diff --git a/.gitignore b/.gitignore index 4b1aeaa..6ab0ba9 100644 --- a/.gitignore +++ b/.gitignore @@ -22,6 +22,8 @@ video/auth.* *.jpeg *.mp4 +**/*.log + r5-java/tmp property-data property-data2 diff --git a/finder/Dockerfile b/finder/Dockerfile new file mode 100644 index 0000000..bb5f2b5 --- /dev/null +++ b/finder/Dockerfile @@ -0,0 +1,25 @@ +# Finder scraper image. Runs via docker-compose sharing the media_gluetun VPN +# network namespace; the source tree is bind-mounted at runtime, so this image +# only needs the Python deps. The venv lives OUTSIDE the bind-mount target +# (/opt/venv) so the mount doesn't shadow it. +FROM python:3.12-slim + +ENV UV_PROJECT_ENVIRONMENT=/opt/venv \ + UV_COMPILE_BYTECODE=1 \ + UV_LINK_MODE=copy \ + PYTHONUNBUFFERED=1 + +RUN apt-get update \ + && apt-get install -y --no-install-recommends ca-certificates curl \ + && rm -rf /var/lib/apt/lists/* + +COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv + +WORKDIR /app/finder + +# Install dependencies into /opt/venv (cached layer; project code is mounted at runtime). +COPY pyproject.toml uv.lock ./ +RUN uv sync --no-install-project --frozen + +# Source is bind-mounted over /app/finder by compose. `uv run` uses /opt/venv. +CMD ["sleep", "infinity"] diff --git a/finder/constants.py b/finder/constants.py index 82a834b..17e6938 100644 --- a/finder/constants.py +++ b/finder/constants.py @@ -6,7 +6,9 @@ REPO_DIR = FINDER_DIR.parent DATA_DIR = Path(os.environ.get("DATA_DIR", str(FINDER_DIR / "data"))) ARCGIS_PATH = Path( - os.environ.get("ARCGIS_PATH", str(REPO_DIR / "property-data" / "arcgis_data.parquet")) + os.environ.get( + "ARCGIS_PATH", str(REPO_DIR / "property-data" / "arcgis_data.parquet") + ) ) PAGE_SIZE = 24 DELAY_BETWEEN_PAGES = 0.3 @@ -19,6 +21,19 @@ MAX_BEDROOMS = 20 # sanity cap — values above this are almost certainly parsi TYPEAHEAD_URL = "https://los.rightmove.co.uk/typeahead" SEARCH_URL = "https://www.rightmove.co.uk/api/property-search/listing/search" RIGHTMOVE_BASE = "https://www.rightmove.co.uk" +# Detail page (plain HTTPS GET, no Cloudflare). Its window.__PAGE_MODEL embeds +# propertyData.address.{outcode,incode}, which together form the property's TRUE +# full postcode — the search API only exposes the outcode. {id} is the numeric +# listing id from the search response. +RIGHTMOVE_DETAIL_URL = "https://www.rightmove.co.uk/properties/{id}" + +# The Rightmove search API gives only an outcode-level display address, so the +# true full postcode is recovered from each listing's detail page (see +# finder/rightmove.py::parse_detail_postcode). One extra GET per listing is a +# big throughput increase over the ~1000-result-per-outcode search, so detail +# fetching is gated and capped per outcode (mirrors ZOOPLA_* below). Default ON. +RIGHTMOVE_FETCH_DETAILS = True # fetch detail pages for true per-listing postcodes +RIGHTMOVE_MAX_DETAILS_PER_OUTCODE = 4000 # max detail-page fetches per outcode # OnTheMarket ONTHEMARKET_BASE = "https://www.onthemarket.com" @@ -26,6 +41,41 @@ ONTHEMARKET_BASE = "https://www.onthemarket.com" # Zoopla ZOOPLA_BASE = "https://www.zoopla.co.uk" +# Zoopla search cards only carry an outcode-level address, so the full postcode +# and precise coordinates are scraped from each listing's detail page. These +# bound that extra work (see finder/zoopla.py and finder/scraper.py). +ZOOPLA_FETCH_DETAILS = True # fetch detail pages for precise per-listing postcodes +ZOOPLA_MAX_DETAILS_PER_OUTCODE = 4000 # max detail-page fetches per outcode +ZOOPLA_DETAIL_GOTO_TIMEOUT_MS = 1500000 # per detail-page navigation timeout +# Fraction of a single outcode's wall-clock budget (ZOOPLA_OUTCODE_TIMEOUT_SECONDS) +# spent fetching details; the remainder is reserved for search pagination so +# detail fetches can never trip the timeout and discard collected listings. +ZOOPLA_DETAIL_BUDGET_FRACTION = 0.6 + +# Gluetun VPN. Network endpoints are env-overridable because they are +# deployment-specific: when finder runs in a SEPARATE container they use the +# `gluetun` hostname (defaults below); when finder SHARES gluetun's network +# namespace (docker-compose.yml, network_mode container:media_gluetun) they +# become localhost and GLUETUN_PROXY is empty (the shared netns already tunnels +# all traffic, so no HTTP proxy is needed). +# GLUETUN_PROXY="" (empty) => direct connection (no proxy); used in shared-netns. +GLUETUN_PROXY = os.environ.get("GLUETUN_PROXY", "http://gluetun:8888") or None +GLUETUN_CONTROL_URL = os.environ.get("GLUETUN_CONTROL_URL", "http://gluetun:8000") +GLUETUN_API_KEY = "My8AbvnKhfyFdRhpTVfoTfa5DkAMmg8K" +# Egress-IP rotations to try per Cloudflare challenge. Keep at 0 for Zoopla: +# rotating among Gluetun's datacenter IPs doesn't clear Cloudflare and would +# rotate away from the IP a cleared Cloudflare session was bound to, voiding it. +# Raise only with residential IPs where rotation helps. +GLUETUN_MAX_ROTATIONS = 0 # max egress-IP rotations per Cloudflare challenge + +# Zoopla fetcher: "flaresolverr" (default) solves Cloudflare via the FlareSolverr +# sidecar (docker-compose.yml) and needs no display/VNC — verified to return the +# RSC flight stream with postcode + coordinates; "camoufox" drives a local +# anti-fingerprint browser (needs an interactive solve on datacenter IPs). +ZOOPLA_FETCHER = os.environ.get("ZOOPLA_FETCHER", "flaresolverr") +FLARESOLVERR_URL = os.environ.get("FLARESOLVERR_URL", "http://gluetun:8191/v1") +FLARESOLVERR_MAX_TIMEOUT_MS = 120000 # per-request solve budget; first solve is slow + # Greater London-ish postcode areas. This intentionally uses broad area # prefixes so a manual scrape can include central/inner London plus common # outer-London and near-London outcodes without maintaining a long borough list. diff --git a/finder/docker-compose.yml b/finder/docker-compose.yml new file mode 100644 index 0000000..af87d52 --- /dev/null +++ b/finder/docker-compose.yml @@ -0,0 +1,57 @@ +# Finder scraper + FlareSolverr, both sharing the EXISTING media_gluetun VPN +# container's network namespace. Everything egresses through the VPN, and +# FlareSolverr solves Zoopla's Cloudflare automatically (no VNC needed). +# +# Prerequisites: +# - The `media_gluetun` container (qmcgaw/gluetun) is running on this host. +# It is managed by a different compose; it is referenced here as external +# via network_mode "container:media_gluetun". +# - Because these services share gluetun's netns, they reach each other and +# gluetun on localhost (flaresolverr :8191, gluetun control :8000) and need +# NO published ports (which is exactly why this avoids the dev-container +# port-forwarding pain). +# +# Usage: +# cd finder +# docker compose up -d --build flaresolverr finder # start the sidecars +# docker compose exec finder uv run python main.py --source zoopla --outcodes SW9 --test +# docker compose exec finder uv run python main.py --source all # full run +# docker compose down +# +# NOTE: a manually-started `finder_flaresolverr` container from testing must be +# removed first (`docker rm -f finder_flaresolverr`) to avoid a name clash. + +services: + flaresolverr: + image: ghcr.io/flaresolverr/flaresolverr:latest + container_name: finder_flaresolverr + network_mode: "container:media_gluetun" + environment: + LOG_LEVEL: info + TZ: Europe/London + restart: unless-stopped + + finder: + build: + context: . + dockerfile: Dockerfile + image: finder-scraper:latest + container_name: finder_scraper + network_mode: "container:media_gluetun" + depends_on: + - flaresolverr + volumes: + - .:/app/finder # live-mounted finder source + - ../property-data:/app/property-data:ro # ARCGIS postcode data + working_dir: /app/finder + environment: + # Shared netns: sidecars are on localhost, and the netns already tunnels + # all traffic through the VPN, so no HTTP proxy is used. + ZOOPLA_FETCHER: flaresolverr + FLARESOLVERR_URL: http://localhost:8191/v1 + GLUETUN_CONTROL_URL: http://localhost:8000 + GLUETUN_PROXY: "" # empty => direct (shared netns already tunnels) + DATA_DIR: /app/finder/data + ARCGIS_PATH: /app/property-data/arcgis_data.parquet + restart: "no" + command: ["sleep", "infinity"] # stays up; run scrapes via `docker compose exec` diff --git a/finder/flaresolverr.py b/finder/flaresolverr.py new file mode 100644 index 0000000..dd91222 --- /dev/null +++ b/finder/flaresolverr.py @@ -0,0 +1,91 @@ +"""FlareSolverr client — fetch Cloudflare-protected pages as rendered HTML. + +FlareSolverr (https://github.com/FlareSolverr/FlareSolverr) drives an +undetected browser to pass Cloudflare's challenge and returns the fully +rendered HTML. It runs as a sidecar service (see docker-compose.yml) sharing +the Gluetun VPN network namespace, so its browser egresses through the VPN. + +Verified working against Zoopla's managed Turnstile on a datacenter VPN IP, +provided a reused session and a generous maxTimeout (~120s) — the first +challenge solve is slow, subsequent requests on the warm session are fast. +""" + +import logging + +import httpx + +from constants import FLARESOLVERR_MAX_TIMEOUT_MS, FLARESOLVERR_URL + +log = logging.getLogger("flaresolverr") + + +class FlareSolverrError(Exception): + """Raised when FlareSolverr cannot fetch/solve a URL.""" + + +class FlareSolverrSession: + """A reusable FlareSolverr browser session (context manager). + + Reusing one session keeps the cleared Cloudflare cookies warm across + requests, so only the first fetch pays the full challenge-solve cost.""" + + def __init__( + self, + url: str = FLARESOLVERR_URL, + session: str = "finder", + max_timeout_ms: int = FLARESOLVERR_MAX_TIMEOUT_MS, + ) -> None: + self._url = url + self._session = session + self._max_timeout = max_timeout_ms + # Read timeout must comfortably exceed maxTimeout (FlareSolverr blocks + # for up to maxTimeout while solving before responding). + self._client = httpx.Client(timeout=httpx.Timeout(self._max_timeout / 1000 + 30)) + self._active = False + + def _post(self, payload: dict) -> dict: + try: + resp = self._client.post(self._url, json=payload) + resp.raise_for_status() + data = resp.json() + except (httpx.HTTPError, ValueError) as exc: + raise FlareSolverrError( + f"FlareSolverr request to {self._url} failed: {exc}" + ) from exc + if data.get("status") != "ok": + raise FlareSolverrError( + f"FlareSolverr {payload.get('cmd')} failed: {data.get('message')}" + ) + return data + + def __enter__(self) -> "FlareSolverrSession": + # Start from a clean session (ignore destroy errors for a fresh name). + try: + self._post({"cmd": "sessions.destroy", "session": self._session}) + except FlareSolverrError: + pass + self._post({"cmd": "sessions.create", "session": self._session}) + self._active = True + log.info("FlareSolverr session %r ready at %s", self._session, self._url) + return self + + def get(self, url: str) -> str: + """Fetch a URL through FlareSolverr; return the solved HTML.""" + data = self._post( + { + "cmd": "request.get", + "session": self._session, + "url": url, + "maxTimeout": self._max_timeout, + } + ) + solution = data.get("solution") or {} + return solution.get("response", "") or "" + + def __exit__(self, *exc_info) -> None: + if self._active: + try: + self._post({"cmd": "sessions.destroy", "session": self._session}) + except FlareSolverrError as exc: + log.debug("FlareSolverr session destroy failed: %s", exc) + self._client.close() diff --git a/finder/gdal-ecw/Dockerfile b/finder/gdal-ecw/Dockerfile new file mode 100644 index 0000000..d272d22 --- /dev/null +++ b/finder/gdal-ecw/Dockerfile @@ -0,0 +1,53 @@ +# GDAL with ECW (read) support, for decoding Environment Agency Vertical Aerial +# Photography in the satellite-highres pipeline (pipeline/download/satellite_highres.py). +# +# EA VAP ships as ECW **v2** rasters, which are readable by the open-source +# libecwj2 3.3 SDK -- the same library the official OSGeo image uses when built +# with WITH_ECW=yes. We therefore avoid the proprietary, login-gated Hexagon +# ERDAS ECW/JP2 SDK (which is only needed for ECW v3) and its licensing +# restrictions entirely. +# +# We build only the ECW driver as a GDAL *plugin* on top of the official runtime +# image (no full GDAL rebuild). The plugin's GDAL sources are pinned to the exact +# commit reported by the base image so libgdal and the plugin stay ABI-compatible. +# +# Build: docker build -t perfect-postcode/gdal-ecw:latest docker/gdal-ecw +# Verify: docker run --rm perfect-postcode/gdal-ecw:latest gdalinfo --formats | grep -i ECW + +FROM ghcr.io/osgeo/gdal:ubuntu-full-latest + +ARG LIBECWJ2_URL=https://github.com/rouault/libecwj2-3.3-builds/releases/download/v1/install-libecwj2-3.3-ubuntu-20.04.tar.gz + +RUN apt-get update && apt-get install -y --no-install-recommends \ + cmake g++ make git curl ca-certificates \ + && rm -rf /var/lib/apt/lists/* + +# Open-source ECW v2 SDK (extracts to /opt/libecwj2-3.3) + make its libs loadable. +RUN curl --retry 3 --retry-all-errors --retry-delay 3 -fsSL -o /tmp/libecwj2.tar.gz "$LIBECWJ2_URL" \ + && tar -C / -xzf /tmp/libecwj2.tar.gz \ + && rm -f /tmp/libecwj2.tar.gz \ + && (cd /opt/libecwj2-3.3/lib && for so in *.so*; do \ + ln -sf "/opt/libecwj2-3.3/lib/$so" "/usr/lib/x86_64-linux-gnu/$so"; \ + done) \ + && ldconfig + +# Build the ECW driver plugin against the base image's exact GDAL sources. +RUN set -eux; \ + GDAL_COMMIT="$(gdalinfo --version | sed -nE 's/.*-([0-9a-f]{8,}).*/\1/p')"; \ + test -n "$GDAL_COMMIT"; \ + echo "Building ECW plugin for GDAL commit ${GDAL_COMMIT}"; \ + mkdir -p /tmp/gdal && cd /tmp/gdal && git init -q; \ + git fetch --depth 1 -q https://github.com/OSGeo/gdal.git "$GDAL_COMMIT"; \ + git checkout -q FETCH_HEAD; \ + cmake -S frmts/ecw -B /tmp/ecw-build \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_PREFIX_PATH=/usr \ + -DECW_ROOT=/opt/libecwj2-3.3; \ + cmake --build /tmp/ecw-build -j"$(nproc)"; \ + PLUGIN_DIR=/usr/lib/x86_64-linux-gnu/gdalplugins; \ + mkdir -p "$PLUGIN_DIR"; \ + find /tmp/ecw-build -name 'gdal_ECW*.so' -exec cp {} "$PLUGIN_DIR/" \; ; \ + rm -rf /tmp/gdal /tmp/ecw-build + +# Fail the build if the driver is not actually available. +RUN gdalinfo --formats | grep -iq 'ECW.*rw' && echo "ECW driver OK" diff --git a/finder/http_client.py b/finder/http_client.py index b803c84..3f7aaa0 100644 --- a/finder/http_client.py +++ b/finder/http_client.py @@ -5,7 +5,7 @@ import time import httpx from fake_useragent import UserAgent -from constants import MAX_RETRIES, RETRY_BASE_DELAY +from constants import GLUETUN_PROXY, MAX_RETRIES, RETRY_BASE_DELAY log = logging.getLogger("rightmove") @@ -15,10 +15,12 @@ _ua = UserAgent( def make_client() -> httpx.Client: + # Route through the Gluetun HTTP proxy (VPN egress) when configured. return httpx.Client( timeout=30, headers={"User-Agent": _ua.random, "Accept": "application/json"}, follow_redirects=True, + proxy=GLUETUN_PROXY or None, ) diff --git a/finder/main.py b/finder/main.py index e6ce585..15b6811 100644 --- a/finder/main.py +++ b/finder/main.py @@ -57,6 +57,16 @@ def parse_args() -> argparse.Namespace: default=DATA_DIR, help=f"Directory for parquet output. Defaults to {DATA_DIR}.", ) + parser.add_argument( + "--outcodes", + type=str, + default=None, + help=( + "Comma-separated outcodes to scrape (e.g. 'SW9' or 'SW9,E14,BR1') " + "instead of the full Greater London set. Must fall within the " + "London-ish areas; takes precedence over --test/--limit-outcodes." + ), + ) parser.add_argument( "--limit-outcodes", type=int, @@ -116,17 +126,32 @@ def main() -> int: from scraper import ( build_postcode_coords, build_postcode_index, + filter_londonish_outcodes, load_outcodes, run_scrape, ) - outcodes = load_outcodes() - if args.test and args.limit_outcodes is None: - preferred = [outcode for outcode in TEST_OUTCODES if outcode in set(outcodes)] - if preferred: - outcodes = preferred - if args.limit_outcodes is not None: - outcodes = outcodes[: args.limit_outcodes] + if args.outcodes is not None: + requested = [code.strip().upper() for code in args.outcodes.split(",") if code.strip()] + if not requested: + raise SystemExit("--outcodes was empty") + outcodes = filter_londonish_outcodes(requested) + dropped = sorted(set(requested) - set(outcodes)) + if dropped: + log.warning("Ignoring outcodes outside the Greater London-ish areas: %s", ", ".join(dropped)) + if not outcodes: + raise SystemExit( + "None of the requested outcodes are within the Greater London-ish areas " + f"({', '.join(requested)})." + ) + else: + outcodes = load_outcodes() + if args.test and args.limit_outcodes is None: + preferred = [outcode for outcode in TEST_OUTCODES if outcode in set(outcodes)] + if preferred: + outcodes = preferred + if args.limit_outcodes is not None: + outcodes = outcodes[: args.limit_outcodes] if not outcodes: raise SystemExit("No Greater London-ish outcodes loaded; nothing to scrape.") diff --git a/finder/onthemarket.py b/finder/onthemarket.py index 7a96e4e..00b90c4 100644 --- a/finder/onthemarket.py +++ b/finder/onthemarket.py @@ -10,6 +10,30 @@ Each rendered page contains 30 listings under `humanised-property-type`, `features` (a list where the first element is typically `"Tenure: "`), and `details-url`. Pagination is via `?page=N`; the loop terminates when `paginationControls.next` is null. + +Postcodes +--------- +The search card exposes only an *outcode*-level address (e.g. "Padfield Road, +London, SE5") and a map pin, so the old behaviour derived the postcode from the +nearest postcode to that pin — a guess that frequently lands on a neighbouring +unit (the pin can sit on the wrong side of a street boundary). + +Each *detail* page (`/details/{id}/`) is a plain HTTPS GET whose `__NEXT_DATA__` +embeds the property's analytics dataLayer at +`props.initialReduxState.metadata.dataLayer`, which carries the property's own +`postcode` (full unit postcode, e.g. "SE5 9AA") keyed to this listing by +`property-id`. Crucially this is NOT the agent's office postcode — that lives +separately at `…property.agent.postcode` ("SE5 8RS" for the same listing) and +is the classic trap when blindly scanning the page for a postcode. We read the +dataLayer postcode, verify `property-id` matches the listing, and accept it only +when its outcode agrees with the coordinate-nearest postcode (via +``resolve_listing_postcode``) — exactly the trust rule the other scrapers use. +Measured over a sample of real listings this yields a trustworthy, usually +exact-unit postcode for ~11/12 listings; the rest safely fall back to the +coordinate-nearest postcode. + +Detail fetching costs one extra HTTPS GET per listing, so it is gated behind +``OTM_FETCH_DETAILS`` and capped at ``OTM_MAX_DETAILS_PER_OUTCODE`` per outcode. """ import json @@ -31,14 +55,26 @@ from spatial import PostcodeSpatialIndex from transform import ( clean_listing_address, extract_full_postcode, + extract_outcode, fix_coords, map_property_type, normalize_sub_type, parse_display_size, + resolve_listing_postcode, ) log = logging.getLogger("rightmove") +# Detail-page postcode recovery (see module docstring). When enabled, each +# listing's detail page is fetched so its analytics dataLayer postcode — the +# property's own full unit postcode — can replace the coordinate-nearest guess. +# Bounded per outcode so a large outcode can't balloon into unbounded extra +# HTTPS GETs. Kept at parity with the Rightmove/Zoopla detail caps (400) so a +# typical outcode's listings all get their real postcode rather than a +# coordinate-nearest guess. +OTM_FETCH_DETAILS = True +OTM_MAX_DETAILS_PER_OUTCODE = 400 + _NEXT_DATA_RE = re.compile( r'', re.DOTALL, @@ -51,6 +87,11 @@ _HTML_HEADERS = { "Accept-Language": "en-GB,en;q=0.9", } +# listingId -> recovered full postcode (or None). Failures are cached too so a +# broken or postcode-less detail page is not re-fetched within a run (the same +# listing can reappear across overlapping outcode searches). +_detail_postcode_cache: dict[str, str | None] = {} + def _fetch_page_json(client: httpx.Client, outcode: str, page_num: int) -> dict | None: """GET one search-results page and return the embedded __NEXT_DATA__ JSON. @@ -119,6 +160,116 @@ def _fetch_page_json(client: httpx.Client, outcode: str, page_num: int) -> dict return None +def parse_detail_postcode(html: str, listing_id: str | None = None) -> str | None: + """Extract the property's own full postcode from an OnTheMarket detail page. + + Pure and network-free so it is unit-testable: callers pass `page.content()` + / the GET body and this does the parsing. + + The postcode lives in the analytics dataLayer embedded in `__NEXT_DATA__` at + ``props.initialReduxState.metadata.dataLayer.postcode`` and is the + property's own unit postcode (e.g. "SE5 9AA"). It is deliberately NOT the + agent's office postcode, which sits separately at + ``…property.agent.postcode`` — the trap when scanning a detail page for "a" + postcode. When ``listing_id`` is given, the dataLayer's ``property-id`` must + match it, guaranteeing we read this listing's postcode and not a stray one. + + Returns a normalized full postcode (e.g. "SE5 9AA") or ``None`` when the + page has no usable property postcode. Trust (outcode-vs-coordinates + agreement) is enforced later in ``transform_property``. + """ + if not html: + return None + + match = _NEXT_DATA_RE.search(html) + if not match: + return None + try: + data = json.loads(match.group(1)) + except json.JSONDecodeError: + return None + + try: + data_layer = data["props"]["initialReduxState"]["metadata"]["dataLayer"] + except (KeyError, TypeError): + return None + if not isinstance(data_layer, dict): + return None + + # Guard against reading a different listing's postcode: the dataLayer is the + # property's own analytics payload, so its property-id must match. + if listing_id is not None: + page_id = data_layer.get("property-id") + if page_id is not None and str(page_id) != str(listing_id): + return None + + raw_postcode = data_layer.get("postcode") + if not isinstance(raw_postcode, str): + return None + return extract_full_postcode(raw_postcode) + + +def _fetch_detail_postcode( + client: httpx.Client, details_url: str, listing_id: str +) -> str | None: + """GET one listing's detail page and return its dataLayer postcode (or None). + + Results (including failures) are cached by listing id so a listing that + reappears across overlapping outcode searches is fetched at most once. Plain + HTTPS GET — OnTheMarket detail pages have no Cloudflare challenge. Network / + parse errors degrade gracefully to None so the caller falls back to the + coordinate-nearest postcode. + """ + if listing_id in _detail_postcode_cache: + return _detail_postcode_cache[listing_id] + + full_url = ( + ONTHEMARKET_BASE + details_url + if details_url and not details_url.startswith("http") + else details_url + ) + result: str | None = None + if full_url: + for attempt in range(MAX_RETRIES): + try: + resp = client.get( + full_url, headers=_HTML_HEADERS, follow_redirects=True + ) + except ( + httpx.ConnectError, + httpx.ReadTimeout, + httpx.WriteTimeout, + httpx.PoolTimeout, + ) as exc: + delay = RETRY_BASE_DELAY * (2**attempt) + random.uniform(0, 1) + log.warning( + "%s from %s, retry %d/%d in %.1fs", + type(exc).__name__, full_url, attempt + 1, MAX_RETRIES, delay, + ) + time.sleep(delay) + continue + + if resp.status_code == 200: + result = parse_detail_postcode(resp.text, listing_id) + break + if resp.status_code in (429, 500, 502, 503, 504): + delay = RETRY_BASE_DELAY * (2**attempt) + random.uniform(0, 1) + log.warning( + "HTTP %d from %s, retry %d/%d in %.1fs", + resp.status_code, full_url, attempt + 1, MAX_RETRIES, delay, + ) + time.sleep(delay) + continue + log.debug( + "OnTheMarket detail %s returned HTTP %d (no postcode)", + listing_id, resp.status_code, + ) + break + + _detail_postcode_cache[listing_id] = result + return result + + def _parse_price(price_value) -> int: """Parse a formatted price string like '£450,000' into an integer. Returns 0 for POA/auction/null values.""" @@ -166,9 +317,19 @@ def _extract_floor_area(features: list) -> float | None: def transform_property( - raw: dict, pc_index: PostcodeSpatialIndex + raw: dict, + pc_index: PostcodeSpatialIndex, + detail_postcode: str | None = None, ) -> dict | None: - """Transform a raw OnTheMarket listing dict into our output schema.""" + """Transform a raw OnTheMarket listing dict into our output schema. + + ``detail_postcode`` is the property's own full postcode recovered from its + detail page (see ``parse_detail_postcode`` / ``_fetch_detail_postcode``), + or ``None`` when no detail fetch was done / no postcode was found. When + present and trustworthy (its outcode agrees with the coordinate-nearest + postcode) it supersedes the coordinate guess and is labelled + ``"detail_address"``. + """ loc = raw.get("location") or {} raw_lat = loc.get("lat") raw_lng = loc.get("lon") @@ -184,8 +345,29 @@ def transform_property( return None raw_address = raw.get("address", "") or "" extracted_postcode = extract_full_postcode(raw_address) - postcode = extracted_postcode or inferred_postcode - postcode_source = "address" if extracted_postcode else "coordinates" + + # Prefer the property's own detail-page postcode when we have one and it is + # trustworthy. The detail postcode is a full unit postcode (better than the + # coordinate-nearest guess and than the usually outcode-only card address), + # but a stale/mislabelled value would silently override the spatially + # correct one, so apply the same outcode-agreement trust rule the address + # postcode uses: keep it only when its outcode matches the + # coordinate-nearest postcode's outcode. + detail_postcode = extract_full_postcode(detail_postcode) + if detail_postcode and extract_outcode(detail_postcode) == extract_outcode( + inferred_postcode + ): + postcode, postcode_source = detail_postcode, "detail_address" + else: + if detail_postcode: + log.debug( + "OnTheMarket %s: rejecting detail postcode %s " + "(outcode mismatch with inferred %s)", + raw.get("id", "?"), detail_postcode, inferred_postcode, + ) + postcode, postcode_source = resolve_listing_postcode( + extracted_postcode, inferred_postcode + ) raw_beds = raw.get("bedrooms") or 0 raw_baths = raw.get("bathrooms") or 0 @@ -223,6 +405,10 @@ def transform_property( "Inferred postcode": inferred_postcode, "Listing raw address": raw_address, "Address per Property Register": clean_listing_address(raw_address), + # OnTheMarket search JSON exposes only a street-level address; no UPRN + # or house number/name is available without a detail-page fetch. + "UPRN": None, + "Property number or name": None, "Leasehold/Freehold": _extract_tenure(features), "Property type": map_property_type(sub_type), "Property sub-type": normalize_sub_type(sub_type), @@ -242,10 +428,17 @@ def search_outcode( pc_index: PostcodeSpatialIndex, max_properties: int | None = None, ) -> list[dict]: - """Paginate through OnTheMarket sale results for one outcode.""" + """Paginate through OnTheMarket sale results for one outcode. + + When ``OTM_FETCH_DETAILS`` is enabled, up to + ``OTM_MAX_DETAILS_PER_OUTCODE`` listings per outcode have their detail page + fetched for the property's own postcode (see ``_fetch_detail_postcode``); + the rest fall back to the coordinate-nearest postcode. + """ properties: list[dict] = [] seen_ids: set[str] = set() page_num = 1 + details_fetched = 0 while True: data = _fetch_page_json(client, outcode, page_num) @@ -269,8 +462,22 @@ def search_outcode( if listing_id and listing_id in seen_ids: continue seen_ids.add(listing_id) + + detail_postcode = None + if OTM_FETCH_DETAILS and listing_id: + # Cached lookups are free; only fresh GETs count toward the cap + # and incur the inter-request delay. + cached = listing_id in _detail_postcode_cache + if cached or details_fetched < OTM_MAX_DETAILS_PER_OUTCODE: + detail_postcode = _fetch_detail_postcode( + client, raw.get("details-url") or "", listing_id + ) + if not cached: + details_fetched += 1 + time.sleep(DELAY_BETWEEN_PAGES) + try: - transformed = transform_property(raw, pc_index) + transformed = transform_property(raw, pc_index, detail_postcode) except Exception as exc: log.warning( "OnTheMarket %s property %s failed to transform: %s", diff --git a/finder/rightmove.py b/finder/rightmove.py index 883c68a..956b73d 100644 --- a/finder/rightmove.py +++ b/finder/rightmove.py @@ -1,4 +1,6 @@ +import json import logging +import re import time import httpx @@ -6,12 +8,15 @@ import httpx from constants import ( PAGE_SIZE, DELAY_BETWEEN_PAGES, + RIGHTMOVE_DETAIL_URL, + RIGHTMOVE_FETCH_DETAILS, + RIGHTMOVE_MAX_DETAILS_PER_OUTCODE, SEARCH_URL, TYPEAHEAD_URL, ) from http_client import fetch_with_retry from spatial import PostcodeSpatialIndex -from transform import transform_property +from transform import extract_full_postcode, normalize_postcode, transform_property log = logging.getLogger("rightmove") @@ -23,6 +28,176 @@ outcode_cache: dict[str, str] = {} _MAX_INDEX = 1008 +# --------------------------------------------------------------------------- +# Detail-page postcode extraction +# --------------------------------------------------------------------------- +# +# The search API (_paginate) only returns an outcode-level `displayAddress` +# (e.g. "Akerman Road, Brixton, London, SW9") — never the full postcode. Each +# listing's detail page, however, embeds the property's OWN full postcode in a +# `window.__PAGE_MODEL` script as `propertyData.address.{outcode, incode}` +# (e.g. outcode "SW9" + incode "0HD" → "SW9 0HD"), independently corroborated by +# `propertyData.propertyUrls.similarPropertiesUrl` ("/property-for-sale/SW9-0HD.html"). +# This is the property's own postcode, NOT a nearest station/school: the +# `nearestStations`/`nearestAirports` arrays carry only names + distances, no +# postcodes, and the address outcode always matches the searched outcode. +# Recon over 24 live listings across SW9/E1/M1/LS6/E20 (incl. APPROXIMATE_POINT +# new-builds) found the full postcode present 100% of the time. There is no +# UPRN or house-number field anywhere in propertyData, so those stay None. +# +# __PAGE_MODEL is a "devalue"-style flattened object graph: its `data` field is +# a JSON STRING holding a flat array where every integer inside a container is +# an index reference into that same array (so the graph can dedupe). We +# brace-match the (large, deeply-nested) object literal — a non-greedy regex +# cannot — then rehydrate the reference graph before reading the address. + +_PAGE_MODEL_RE = re.compile(r"window\.__PAGE_MODEL\s*=\s*") + + +def _extract_page_model_literal(html: str) -> str | None: + """Return the `{...}` object literal assigned to window.__PAGE_MODEL. + + Brace-matches with string/escape awareness so embedded braces and quotes in + string values don't end the match early. Returns None when absent.""" + marker = _PAGE_MODEL_RE.search(html) + if not marker: + return None + start = marker.end() + if start >= len(html) or html[start] != "{": + return None + depth = 0 + in_str = False + esc = False + for j in range(start, len(html)): + ch = html[j] + if in_str: + if esc: + esc = False + elif ch == "\\": + esc = True + elif ch == '"': + in_str = False + elif ch == '"': + in_str = True + elif ch == "{": + depth += 1 + elif ch == "}": + depth -= 1 + if depth == 0: + return html[start : j + 1] + return None + + +def _rehydrate(flat: list) -> object: + """Resolve a devalue-style flattened reference array into a nested object. + + Index 0 is the root; every int inside a dict/list is an index back into + ``flat``. Memoised so shared/cyclic references resolve once.""" + cache: dict[int, object] = {} + + def resolve(idx: int) -> object: + if not isinstance(idx, int) or idx < 0 or idx >= len(flat): + return None + if idx in cache: + return cache[idx] + node = flat[idx] + if isinstance(node, dict): + out: dict = {} + cache[idx] = out + for key, value in node.items(): + out[key] = resolve(value) if isinstance(value, int) else value + return out + if isinstance(node, list): + arr: list = [] + cache[idx] = arr + for value in node: + arr.append(resolve(value) if isinstance(value, int) else value) + return arr + cache[idx] = node + return node + + return resolve(0) + + +def parse_detail_postcode(html: str) -> str | None: + """Extract a Rightmove property's TRUE full postcode from its detail HTML. + + Pure and network-free so it is unit-testable: callers pass the page HTML. + Reads ``propertyData.address.outcode`` + ``.incode`` from window.__PAGE_MODEL + and returns a normalised full postcode (e.g. "SW9 0HD"), or None when the + page has no parseable address (the property location wrapper can be empty — + the caller then keeps the coordinate fallback). The returned outcode is + re-validated against the joined postcode so a malformed incode is dropped. + """ + if not html: + return None + literal = _extract_page_model_literal(html) + if not literal: + return None + try: + outer = json.loads(literal) + flat = json.loads(outer["data"]) + except (ValueError, KeyError, TypeError): + return None + if not isinstance(flat, list) or not flat: + return None + + root = _rehydrate(flat) + if not isinstance(root, dict): + return None + property_data = root.get("propertyData") + if not isinstance(property_data, dict): + return None + address = property_data.get("address") + if not isinstance(address, dict): + return None + + outcode = address.get("outcode") + incode = address.get("incode") + if not isinstance(outcode, str) or not isinstance(incode, str): + return None + outcode, incode = outcode.strip(), incode.strip() + if not outcode or not incode: + return None + + # Round-trip through the shared postcode validator/normaliser: this both + # canonicalises spacing and rejects an outcode/incode pair that doesn't form + # a structurally-valid UK postcode. + return extract_full_postcode(normalize_postcode(f"{outcode} {incode}")) + + +# listingId -> true full postcode (or None when unavailable). Failures are +# cached too, so a broken/duplicate listing is fetched at most once per run (the +# same listing can reappear across overlapping outcode searches). +_detail_postcode_cache: dict[str, str | None] = {} + + +def _fetch_detail_postcode(client: httpx.Client, property_id: str) -> str | None: + """GET a listing detail page and return its true full postcode (or None). + + Results (including failures) are cached by listing id. The detail page is a + plain HTML GET — no Cloudflare, unlike Zoopla — so a single httpx call + suffices; any error degrades gracefully to the coordinate fallback.""" + if not property_id: + return None + if property_id in _detail_postcode_cache: + return _detail_postcode_cache[property_id] + + postcode: str | None = None + url = RIGHTMOVE_DETAIL_URL.format(id=property_id) + try: + resp = client.get(url, headers={"Accept": "text/html"}) + if resp.status_code == 200: + postcode = parse_detail_postcode(resp.text) + else: + log.debug("Rightmove detail %s returned HTTP %d", url, resp.status_code) + except httpx.HTTPError as exc: + log.debug("Rightmove detail fetch failed %s: %s", url, exc) + + _detail_postcode_cache[property_id] = postcode + return postcode + + def resolve_outcode_id(client: httpx.Client, outcode: str) -> str | None: """Look up Rightmove's internal ID for an outcode via typeahead API.""" if outcode in outcode_cache: @@ -44,6 +219,31 @@ def resolve_outcode_id(client: httpx.Client, outcode: str) -> str | None: return None +def _detail_postcode_for( + client: httpx.Client, + prop: dict, + fetch_details: bool, + detail_budget: dict, +) -> str | None: + """Look up a listing's true postcode, honouring the per-outcode fetch cap. + + Cached listings are always served (they cost neither a cap slot nor a GET); + a fresh fetch is made only while ``detail_budget['remaining'] > 0``.""" + if not fetch_details: + return None + property_id = str(prop.get("id") or "") + if not property_id: + return None + if property_id in _detail_postcode_cache: + return _detail_postcode_cache[property_id] + if detail_budget["remaining"] <= 0: + return None + detail_budget["remaining"] -= 1 + postcode = _fetch_detail_postcode(client, property_id) + time.sleep(DELAY_BETWEEN_PAGES) + return postcode + + def _paginate( client: httpx.Client, outcode_id: str, @@ -51,11 +251,19 @@ def _paginate( channel_cfg: dict, pc_index: PostcodeSpatialIndex, max_properties: int | None = None, + fetch_details: bool = False, + detail_cap: int = 0, ) -> tuple[list[dict], int]: - """Paginate through search results. Returns (properties, result_count).""" + """Paginate through search results. Returns (properties, result_count). + + When ``fetch_details`` is set, up to ``detail_cap`` listings per outcode have + their detail page fetched for the property's TRUE full postcode (see + ``parse_detail_postcode``); the rest fall back to coordinate-derived + postcodes.""" properties = [] index = 0 result_count = 0 + detail_budget = {"remaining": detail_cap} while True: params = { @@ -82,7 +290,12 @@ def _paginate( for prop in raw_props: try: - transformed = transform_property(prop, outcode, pc_index) + detail_postcode = _detail_postcode_for( + client, prop, fetch_details, detail_budget + ) + transformed = transform_property( + prop, outcode, pc_index, detail_postcode=detail_postcode + ) except Exception as exc: log.warning( "Rightmove %s/%s property %s failed to transform: %s", @@ -127,7 +340,12 @@ def search_outcode( pc_index: PostcodeSpatialIndex, max_properties: int | None = None, ) -> list[dict]: - """Paginate through unfiltered sale results for one outcode+channel.""" + """Paginate through unfiltered sale results for one outcode+channel. + + Each listing's detail page is fetched for the property's TRUE full postcode + (gated by ``RIGHTMOVE_FETCH_DETAILS`` and capped per outcode by + ``RIGHTMOVE_MAX_DETAILS_PER_OUTCODE``); listings beyond the cap keep the + coordinate-derived postcode.""" properties, _ = _paginate( client, outcode_id, @@ -135,6 +353,8 @@ def search_outcode( channel_cfg, pc_index, max_properties=max_properties, + fetch_details=RIGHTMOVE_FETCH_DETAILS, + detail_cap=RIGHTMOVE_MAX_DETAILS_PER_OUTCODE, ) if max_properties is not None and len(properties) >= max_properties: diff --git a/finder/scraper.py b/finder/scraper.py index 1111577..25ddf90 100644 --- a/finder/scraper.py +++ b/finder/scraper.py @@ -15,6 +15,10 @@ from constants import ( DATA_DIR, DELAY_BETWEEN_OUTCODES, LONDON_OUTCODE_PREFIXES, + ZOOPLA_DETAIL_BUDGET_FRACTION, + ZOOPLA_FETCH_DETAILS, + ZOOPLA_FETCHER, + ZOOPLA_MAX_DETAILS_PER_OUTCODE, ) from http_client import make_client @@ -371,6 +375,36 @@ def _zoopla_outcode_timeout_seconds() -> int: return timeout +def _zoopla_detail_cap() -> int: + """Max detail-page fetches per outcode (0 disables detail fetching). + + Zoopla search cards only expose an outcode-level address, so the full + postcode/coordinates come from each listing's detail page. The cap bounds + the extra page loads so an outcode stays within ZOOPLA_OUTCODE_TIMEOUT_SECONDS + (the per-outcode SIGALRM budget covers the detail fetches too). Configure via + ZOOPLA_FETCH_DETAILS / ZOOPLA_MAX_DETAILS_PER_OUTCODE in constants.py.""" + return ZOOPLA_MAX_DETAILS_PER_OUTCODE if ZOOPLA_FETCH_DETAILS else 0 + + +def _open_zoopla_detail_tab(page, detail_cap: int): + """Open a second tab on the same context for detail-page fetches. + + Sharing the persistent context means the detail tab inherits the search + tab's Cloudflare clearance cookies. Returns None when detail fetching is + disabled or the tab cannot be created (the scrape then degrades to + outcode-level postcodes rather than failing).""" + if detail_cap <= 0: + return None + try: + return page.context.new_page() + except Exception as exc: + log.warning( + "Zoopla detail tab unavailable (%s); using outcode-level postcodes", + _exception_detail(exc), + ) + return None + + @contextmanager def _wall_clock_timeout(seconds: int, label: str): """SIGALRM-based wall-clock guard (POSIX). Raises OutcodeTimeout on expiry. @@ -438,6 +472,50 @@ def _close_zoopla_browser(browser, label: str) -> None: log.warning("%s browser force-close failed: %s", label, _exception_detail(exc)) +def _scrape_zoopla_flaresolverr( + outcodes: list[str], + pc_index: PostcodeSpatialIndex, + pc_coords: dict[str, tuple[float, float]], + results: dict[str, list[dict]], + errors: list[str], + max_properties_per_source: int | None, +) -> None: + """Scrape Zoopla via the FlareSolverr sidecar (no browser/VNC).""" + from flaresolverr import FlareSolverrError, FlareSolverrSession + from zoopla_flaresolverr import search_outcode as fs_search_outcode + + try: + session = FlareSolverrSession(session="zoopla") + session.__enter__() + except FlareSolverrError as exc: + errors.append(f"zoopla: FlareSolverr unavailable: {exc}") + log.warning("Zoopla skipped: FlareSolverr unavailable: %s", exc) + return + + try: + for outcode in outcodes: + remaining = _source_remaining(results, "zoopla", max_properties_per_source) + if remaining == 0: + log.info("Zoopla cap reached") + return + try: + props, _ = fs_search_outcode( + outcode, + pc_index, + pc_coords, + session, + max_properties=remaining, + detail_cap=ZOOPLA_MAX_DETAILS_PER_OUTCODE, + ) + added = _store_properties(results, "zoopla", props, max_properties_per_source) + log.info("Zoopla %s: +%d", outcode, added) + except Exception as exc: # noqa: BLE001 - one outcode must not kill the run + _record_error(errors, "zoopla", outcode, exc) + time.sleep(DELAY_BETWEEN_OUTCODES) + finally: + session.__exit__(None, None, None) + + def _scrape_zoopla( outcodes: list[str], pc_index: PostcodeSpatialIndex, @@ -446,6 +524,12 @@ def _scrape_zoopla( errors: list[str], max_properties_per_source: int | None, ) -> None: + if ZOOPLA_FETCHER == "flaresolverr": + _scrape_zoopla_flaresolverr( + outcodes, pc_index, pc_coords, results, errors, max_properties_per_source + ) + return + try: browser, page = _launch_zoopla_with_retries() except Exception as exc: @@ -454,6 +538,12 @@ def _scrape_zoopla( return outcode_timeout = _zoopla_outcode_timeout_seconds() + detail_cap = _zoopla_detail_cap() + detail_page = _open_zoopla_detail_tab(page, detail_cap) + # Spend at most a fraction of each outcode's budget on detail fetches so the + # SIGALRM guard never trips mid-outcode and discards already-collected + # search listings; the rest is left for search pagination and transform. + detail_budget_seconds = max(10.0, outcode_timeout * ZOOPLA_DETAIL_BUDGET_FRACTION) try: for outcode in outcodes: @@ -470,6 +560,9 @@ def _scrape_zoopla( pc_index, pc_coords, max_properties=None, + detail_page=detail_page, + detail_cap=detail_cap, + detail_budget_seconds=detail_budget_seconds, ) added = _store_properties( results, @@ -496,6 +589,8 @@ def _scrape_zoopla( _close_zoopla_browser(browser, f"zoopla {outcode}") try: browser, page = _launch_zoopla_with_retries() + # The old context (and its detail tab) is gone; reopen one. + detail_page = _open_zoopla_detail_tab(page, detail_cap) log.info("Zoopla %s retrying with fresh browser", outcode) except Exception as relaunch_exc: _record_error(errors, "zoopla", outcode, relaunch_exc) @@ -503,6 +598,11 @@ def _scrape_zoopla( time.sleep(DELAY_BETWEEN_OUTCODES) finally: + if detail_page is not None: + try: + detail_page.close() + except Exception: + pass _close_zoopla_browser(browser, "zoopla final") diff --git a/finder/storage.py b/finder/storage.py index 6c6822e..13008eb 100644 --- a/finder/storage.py +++ b/finder/storage.py @@ -126,6 +126,14 @@ def write_parquet(properties: list[dict], path: Path) -> None: "Address per Property Register": [ p["Address per Property Register"] for p in properties ], + # UPRN (when the scraper recovered it) keys an exact listing->EPC + # join; Property number or name is the house identifier for the + # Price-Paid address join. Both are None for sources/listings without + # a detail-page fetch. + "UPRN": [p.get("UPRN") for p in properties], + "Property number or name": [ + p.get("Property number or name") for p in properties + ], "Leasehold/Freehold": [p["Leasehold/Freehold"] for p in properties], "Property type": [p["Property type"] for p in properties], "Property sub-type": [p["Property sub-type"] for p in properties], @@ -149,6 +157,8 @@ def write_parquet(properties: list[dict], path: Path) -> None: "Inferred postcode": pl.Utf8, "Listing raw address": pl.Utf8, "Address per Property Register": pl.Utf8, + "UPRN": pl.Utf8, + "Property number or name": pl.Utf8, "Leasehold/Freehold": pl.Utf8, "Property type": pl.Utf8, "Property sub-type": pl.Utf8, diff --git a/finder/test_onthemarket.py b/finder/test_onthemarket.py new file mode 100644 index 0000000..4e0b3dd --- /dev/null +++ b/finder/test_onthemarket.py @@ -0,0 +1,206 @@ +"""Tests for the OnTheMarket scraper's detail-page postcode recovery. + +`parse_detail_postcode` is pure (takes the detail-page HTML, returns a postcode +or None), so these tests use a trimmed but faithful copy of a real OnTheMarket +detail page's `__NEXT_DATA__` payload. The fixture mirrors the live structure: +the property's own postcode lives in the analytics dataLayer +(`props.initialReduxState.metadata.dataLayer.postcode`) while the agent's office +postcode sits separately under `…property.agent.postcode` — the trap we must not +fall into. +""" + +import json + +import onthemarket +from onthemarket import parse_detail_postcode, transform_property + + +class _StubIndex: + """Minimal stand-in for PostcodeSpatialIndex returning a fixed postcode.""" + + def __init__(self, postcode: str | None): + self._postcode = postcode + + def nearest(self, lat: float, lng: float) -> str | None: + return self._postcode + + +def _detail_html( + *, + property_id: int = 19522441, + datalayer_postcode: str = "SE5 9AA", + agent_postcode: str = "SE5 8RS", +) -> str: + """Build detail-page HTML with a real-shaped __NEXT_DATA__ payload.""" + next_data = { + "props": { + "initialReduxState": { + "metadata": { + "dataLayer": { + "page-type": "details-section", + "property-type": "homes", + # The property's own unit postcode. + "postcode": datalayer_postcode, + "property-id": property_id, + "price": "275,000", + "addressline_2": "Padfield Road", + } + }, + "property": { + "displayAddress": "Padfield Road, London, SE5", + "location": {"lon": -0.100233, "lat": 51.466129}, + # The agent block carries the AGENT'S office postcode — the + # trap. parse_detail_postcode must not return this. + "agent": { + "address": "29 Denmark Hill, Camberwell\nLondon\nSE5 8RS", + "postcode": agent_postcode, + }, + }, + } + } + } + payload = json.dumps(next_data) + return ( + "" + '" + ) + + +# --------------------------------------------------------------------------- +# parse_detail_postcode +# --------------------------------------------------------------------------- + + +def test_parse_returns_property_postcode_not_agent(): + html = _detail_html(datalayer_postcode="SE5 9AA", agent_postcode="SE5 8RS") + assert parse_detail_postcode(html, "19522441") == "SE5 9AA" + + +def test_parse_normalizes_spacing(): + html = _detail_html(datalayer_postcode="se59aa") + assert parse_detail_postcode(html, "19522441") == "SE5 9AA" + + +def test_parse_ignores_mismatched_property_id(): + # dataLayer postcode belongs to property 19522441; asking for a different + # listing id must refuse to return it. + html = _detail_html(property_id=19522441) + assert parse_detail_postcode(html, "99999999") is None + + +def test_parse_accepts_when_no_listing_id_given(): + html = _detail_html(datalayer_postcode="SE5 9AA") + assert parse_detail_postcode(html, None) == "SE5 9AA" + + +def test_parse_handles_missing_postcode(): + html = _detail_html(datalayer_postcode="") + assert parse_detail_postcode(html, "19522441") is None + + +def test_parse_handles_no_next_data(): + assert parse_detail_postcode("no script here", "1") is None + + +def test_parse_handles_empty_html(): + assert parse_detail_postcode("", "1") is None + + +def test_parse_handles_malformed_json(): + html = ( + '' + ) + assert parse_detail_postcode(html, "1") is None + + +def test_parse_handles_missing_datalayer(): + next_data = {"props": {"initialReduxState": {"metadata": {}}}} + html = ( + '" + ) + assert parse_detail_postcode(html, "1") is None + + +# --------------------------------------------------------------------------- +# transform_property — detail postcode wiring + trust rule +# --------------------------------------------------------------------------- + + +_RAW_LISTING = { + "id": "19522441", + "address": "Padfield Road, London, SE5", + "location": {"lon": -0.100233, "lat": 51.466129}, + "bedrooms": 2, + "bathrooms": 1, + "price": "£275,000", + "humanised-property-type": "Apartment", + "features": ["Tenure: Leasehold (99 years remaining)"], + "details-url": "/details/19522441/", +} + + +def test_transform_uses_trusted_detail_postcode(): + # Detail postcode SE5 9AA, coordinate-nearest SE5 1AA: same outcode -> trust + # the (more precise) detail postcode and label it detail_address. + index = _StubIndex("SE5 1AA") + out = transform_property(_RAW_LISTING, index, detail_postcode="SE5 9AA") + assert out is not None + assert out["Postcode"] == "SE5 9AA" + assert out["Postcode source"] == "detail_address" + + +def test_transform_rejects_detail_postcode_on_outcode_mismatch(): + # Detail postcode SW9 6BZ but coordinate-nearest is SE5 1AA: different + # outcode -> reject the detail postcode, fall back to coordinate logic. + index = _StubIndex("SE5 1AA") + out = transform_property(_RAW_LISTING, index, detail_postcode="SW9 6BZ") + assert out is not None + assert out["Postcode"] == "SE5 1AA" + assert out["Postcode source"] == "coordinates" + + +def test_transform_without_detail_postcode_uses_coordinates(): + index = _StubIndex("SE5 1AA") + out = transform_property(_RAW_LISTING, index, detail_postcode=None) + assert out is not None + assert out["Postcode"] == "SE5 1AA" + assert out["Postcode source"] == "coordinates" + # No UPRN / house number is recoverable from OnTheMarket. + assert out["UPRN"] is None + assert out["Property number or name"] is None + + +def test_transform_detail_postcode_via_search_address_outcode(): + # When the card address already carries a full postcode that agrees with the + # coordinates, the existing "address" source still wins absent a detail + # postcode — detail recovery never regresses that path. + raw = dict(_RAW_LISTING, address="Padfield Road, London, SE5 1AA") + index = _StubIndex("SE5 1AA") + out = transform_property(raw, index, detail_postcode=None) + assert out["Postcode"] == "SE5 1AA" + assert out["Postcode source"] == "address" + + +# --------------------------------------------------------------------------- +# _fetch_detail_postcode caching (no real network) +# --------------------------------------------------------------------------- + + +def test_fetch_detail_postcode_is_cached(monkeypatch): + onthemarket._detail_postcode_cache.clear() + onthemarket._detail_postcode_cache["19522441"] = "SE5 9AA" + + def _boom(*args, **kwargs): # pragma: no cover - must never be called + raise AssertionError("network was hit despite a cached value") + + # Any httpx use would explode; the cache hit must short-circuit first. + result = onthemarket._fetch_detail_postcode( + client=type("C", (), {"get": _boom})(), + details_url="/details/19522441/", + listing_id="19522441", + ) + assert result == "SE5 9AA" + onthemarket._detail_postcode_cache.clear() diff --git a/finder/test_rightmove.py b/finder/test_rightmove.py new file mode 100644 index 0000000..2ea382b --- /dev/null +++ b/finder/test_rightmove.py @@ -0,0 +1,113 @@ +"""Tests for the Rightmove detail-page postcode extractor. + +The search API only returns an outcode-level ``displayAddress``; the property's +TRUE full postcode lives on its detail page inside ``window.__PAGE_MODEL`` as +``propertyData.address.{outcode, incode}``. ``parse_detail_postcode`` recovers +it. These tests build a faithful __PAGE_MODEL: a devalue-style flattened object +graph whose ``data`` field is a JSON STRING of a flat array where every integer +inside a container is an index reference into that same array. +""" + +import json + +from rightmove import _extract_page_model_literal, parse_detail_postcode + + +def _page_model_html(flat: list, *, encoding: str = "json") -> str: + """Wrap a flattened object-graph array in a realistic detail-page \n" + "" + ) + + +# A faithful slice of a real listing: root -> propertyData -> address, with a +# decoy nearestStations array (which carries NO postcodes on the live page) to +# prove the parser anchors on the property's own address, not a nearby POI. +_FLAT_SW9 = [ + {"propertyData": 1}, # 0: root + { + "id": "89089584", + "address": 2, + "location": 4, + "nearestStations": 6, + }, # 1: propertyData + { + "displayAddress": "Caldwell Street, Stockwell", + "countryCode": "GB", + "ukCountry": "England", + "outcode": "SW9", + "incode": "0HD", + }, # 2: address + None, # 3: filler + { + "latitude": 51.477238, + "longitude": -0.116819, + "pinType": "ACCURATE_POINT", + }, # 4: location + None, # 5: filler + [7, 8], # 6: nearestStations (references) + {"name": "Oval Station", "distance": 0.36}, # 7: station, no postcode + {"name": "Stockwell Station", "distance": 0.41}, # 8: station, no postcode +] + + +def test_parses_full_postcode_from_outcode_and_incode() -> None: + html = _page_model_html(_FLAT_SW9) + assert parse_detail_postcode(html) == "SW9 0HD" + + +def test_extract_page_model_literal_brace_matches_nested_object() -> None: + # The literal must include the whole nested object, not stop at the first + # closing brace inside the escaped data string. + html = _page_model_html(_FLAT_SW9) + literal = _extract_page_model_literal(html) + assert literal is not None + assert literal.startswith("{") and literal.endswith("}") + # Round-trips back to a dict with the expected top-level keys. + assert set(json.loads(literal)) == {"data", "encoding"} + + +def test_normalises_unspaced_incode() -> None: + flat = [dict(node) if isinstance(node, dict) else node for node in _FLAT_SW9] + flat[2] = {**_FLAT_SW9[2], "outcode": "e20", "incode": "1fh"} + assert parse_detail_postcode(_page_model_html(flat)) == "E20 1FH" + + +def test_returns_none_when_address_missing() -> None: + # The location wrapper can be empty/absent on some listings; the caller then + # keeps the coordinate fallback, so we must return None (not raise). + flat = [ + {"propertyData": 1}, + {"id": "1", "location": 2}, + {"latitude": 51.5, "longitude": -0.1}, + ] + assert parse_detail_postcode(_page_model_html(flat)) is None + + +def test_returns_none_when_incode_blank() -> None: + flat = [dict(node) if isinstance(node, dict) else node for node in _FLAT_SW9] + flat[2] = {**_FLAT_SW9[2], "incode": ""} + assert parse_detail_postcode(_page_model_html(flat)) is None + + +def test_returns_none_for_non_postcode_pair() -> None: + # A structurally-invalid outcode/incode pair is rejected by the validator. + flat = [dict(node) if isinstance(node, dict) else node for node in _FLAT_SW9] + flat[2] = {**_FLAT_SW9[2], "outcode": "NOTAPC", "incode": "ZZ"} + assert parse_detail_postcode(_page_model_html(flat)) is None + + +def test_returns_none_without_page_model() -> None: + assert parse_detail_postcode("") is None + assert parse_detail_postcode("no model") is None + # Malformed JSON in the data field degrades gracefully. + broken = '' + assert parse_detail_postcode(broken) is None diff --git a/finder/test_transform.py b/finder/test_transform.py index c90296b..1da0a7e 100644 --- a/finder/test_transform.py +++ b/finder/test_transform.py @@ -1,13 +1,19 @@ from transform import ( + build_register_address, clean_listing_address, extract_full_postcode, + extract_outcode, + resolve_listing_postcode, transform_property, ) class StubPostcodeIndex: + def __init__(self, postcode: str = "SW1A 9ZZ") -> None: + self._postcode = postcode + def nearest(self, lat: float, lng: float) -> str: - return "SW1A 9ZZ" + return self._postcode def test_extract_full_postcode_normalizes_spacing() -> None: @@ -24,6 +30,46 @@ def test_clean_listing_address_removes_postcode_and_outcode_suffixes() -> None: assert clean_listing_address("Kings Avenue, Bromley") == "Kings Avenue, Bromley" +def test_build_register_address_prepends_house_number_or_name() -> None: + # House number/name prepended, with the trailing outcode/postcode stripped. + assert ( + build_register_address("South Street, Bromley BR1", "12") + == "12, South Street, Bromley" + ) + assert ( + build_register_address("Riverside, Martham NR29", "Martham Mill") + == "Martham Mill, Riverside, Martham" + ) + # No number/name -> identical to the plain cleaned address. + assert build_register_address("Kings Avenue, Bromley", None) == "Kings Avenue, Bromley" + # Already starts with the number/name -> no duplication. + assert ( + build_register_address("12 South Street, Bromley", "12") + == "12 South Street, Bromley" + ) + # Empty/whitespace number/name is ignored. + assert build_register_address("Kings Avenue, Bromley", " ") == "Kings Avenue, Bromley" + + +def test_extract_outcode() -> None: + assert extract_outcode("SW1A 2AA") == "SW1A" + assert extract_outcode("n4 2ha") == "N4" + assert extract_outcode("SW1A2AA") == "SW1A" + assert extract_outcode(None) is None + assert extract_outcode("") is None + + +def test_resolve_listing_postcode() -> None: + # Outcode matches -> trust the more precise extracted postcode. + assert resolve_listing_postcode("SW1A 2AA", "SW1A 9ZZ") == ("SW1A 2AA", "address") + # Outcode mismatch -> fall back to the spatially-correct inferred postcode. + assert resolve_listing_postcode("E14 9SS", "SW1A 9ZZ") == ("SW1A 9ZZ", "coordinates") + # Well-formed but fabricated postcode in a different outcode is rejected. + assert resolve_listing_postcode("ZZ9 9ZZ", "SW1A 9ZZ") == ("SW1A 9ZZ", "coordinates") + # No extracted postcode -> inferred is authoritative. + assert resolve_listing_postcode(None, "SW1A 9ZZ") == ("SW1A 9ZZ", "coordinates") + + def test_rightmove_transform_prefers_postcode_from_display_address() -> None: prop = { "id": "123", @@ -46,3 +92,84 @@ def test_rightmove_transform_prefers_postcode_from_display_address() -> None: assert result["Inferred postcode"] == "SW1A 9ZZ" assert result["Listing raw address"] == "Flat 2, 10 Downing Street, SW1A 2AA" assert result["Address per Property Register"] == "Flat 2, 10 Downing Street" + + +def test_rightmove_transform_rejects_postcode_from_wrong_outcode() -> None: + prop = { + "id": "124", + "location": {"latitude": 51.5, "longitude": -0.1}, + "price": {"amount": 750000, "displayPrices": []}, + "propertySubType": "Terraced", + "bedrooms": 3, + "bathrooms": 1, + "keyFeatures": [], + "propertyUrl": "/properties/124", + # Address postcode is in a different outcode than the coordinate-nearest one. + "displayAddress": "10 Downing Street, E14 9SS", + } + + result = transform_property(prop, "SW1A", StubPostcodeIndex()) + + assert result is not None + # The spatially-correct inferred postcode wins over the mismatching extracted one. + assert result["Postcode"] == "SW1A 9ZZ" + assert result["Postcode source"] == "coordinates" + assert result["Extracted postcode"] == "E14 9SS" + + +def _rightmove_prop() -> dict: + return { + "id": "200", + "location": {"latitude": 51.5, "longitude": -0.1}, + "price": {"amount": 750000, "displayPrices": []}, + "propertySubType": "Terraced", + "bedrooms": 3, + "bathrooms": 1, + "keyFeatures": [], + "propertyUrl": "/properties/200", + # Search API only ever exposes the outcode in the display address. + "displayAddress": "Caldwell Street, Stockwell, SW9", + } + + +def test_rightmove_transform_prefers_detail_postcode() -> None: + # The detail page's true full postcode (same outcode as the location) is + # preferred over the coordinate-nearest guess. + result = transform_property( + _rightmove_prop(), + "SW9", + StubPostcodeIndex("SW9 7AA"), + detail_postcode="SW9 0HD", + ) + + assert result is not None + assert result["Postcode"] == "SW9 0HD" + assert result["Postcode source"] == "detail_address" + # The coordinate inference is still surfaced separately. + assert result["Inferred postcode"] == "SW9 7AA" + + +def test_rightmove_transform_rejects_detail_postcode_from_wrong_outcode() -> None: + # A detail postcode whose outcode disagrees with the location must not + # relocate the listing; the coordinate postcode wins instead. + result = transform_property( + _rightmove_prop(), + "SW9", + StubPostcodeIndex("SW9 7AA"), + detail_postcode="E14 9SS", + ) + + assert result is not None + assert result["Postcode"] == "SW9 7AA" + assert result["Postcode source"] == "coordinates" + + +def test_rightmove_transform_without_detail_keeps_coordinate_logic() -> None: + # No detail postcode -> behaviour is unchanged (coordinate-nearest). + result = transform_property( + _rightmove_prop(), "SW9", StubPostcodeIndex("SW9 7AA") + ) + + assert result is not None + assert result["Postcode"] == "SW9 7AA" + assert result["Postcode source"] == "coordinates" diff --git a/finder/test_zoopla.py b/finder/test_zoopla.py new file mode 100644 index 0000000..228e21b --- /dev/null +++ b/finder/test_zoopla.py @@ -0,0 +1,288 @@ +from zoopla import _detail_cache_key, parse_detail_geo, transform_property + + +def test_detail_cache_key_uses_listing_id() -> None: + assert _detail_cache_key("/for-sale/details/59888978/") == "59888978" + assert _detail_cache_key("https://www.zoopla.co.uk/for-sale/details/59888978/") == "59888978" + # No id in the URL -> fall back to the URL itself as the key. + assert _detail_cache_key("/for-sale/property/br1/") == "/for-sale/property/br1/" + + +class StubPostcodeIndex: + """Spatial index stub whose nearest-lookup returns a fixed postcode.""" + + def __init__(self, postcode: str = "BR1 2AB") -> None: + self._postcode = postcode + + def nearest(self, lat: float, lng: float) -> str: + return self._postcode + + +# London-ish postcodes with coordinates, plus the Norfolk sample used by the +# verified detail-page snippet (well inside the England bounds check). +PC_COORDS = { + "BR1 2AB": (51.40, 0.01), + "SW1A 1AA": (51.50, -0.14), + "NR29 4RG": (52.716014, 1.614495), +} + +# Verified RSC `location` object (listing 59888978), as it appears escaped inside +# a self.__next_f flight chunk in page.content(). +_LOCATION_ESCAPED = ( + '' +) + + +def test_parse_detail_geo_location_object_escaped() -> None: + geo = parse_detail_geo(_LOCATION_ESCAPED, search_outcode="NR29") + assert geo == { + "lat": 52.716014, + "lng": 1.614495, + "postcode": "NR29 4RG", + "outcode": "NR29", + "source": "detail_location", + "uprn": "10023461458", + "number_or_name": "Martham Mill", + # No `address` twin in this snippet, so there is no full street address. + "full_address": None, + } + + +def test_parse_detail_geo_location_object_unescaped() -> None: + html = ( + '"location":{"outcode":"NR29",' + '"coordinates":{"latitude":52.716014,"longitude":1.614495},' + '"uprn":"10023461458","postalCode":"NR29 4RG"}' + ) + geo = parse_detail_geo(html) + assert geo is not None + assert geo["source"] == "detail_location" + assert geo["postcode"] == "NR29 4RG" + + +def test_parse_detail_geo_address_twin() -> None: + html = ( + '"address":{"fullAddress":"Riverside, Martham NR29",' + '"latitude":52.716014,"longitude":1.614495,' + '"outcode":"NR29","postcode":"NR29 4RG","uprn":"10023461458"}' + ) + geo = parse_detail_geo(html) + assert geo is not None + assert geo["source"] == "detail_address_obj" + assert (geo["lat"], geo["lng"], geo["postcode"]) == (52.716014, 1.614495, "NR29 4RG") + assert geo["uprn"] == "10023461458" + assert geo["full_address"] == "Riverside, Martham NR29" + + +def test_parse_detail_geo_merges_location_uprn_with_address_full_address() -> None: + # Real detail pages carry both wrappers: the `location` object holds the + # uprn + house number/name, the `address` twin holds the full street + # address. They share a uprn, so the twin's fullAddress is attached. + html = ( + '"location":{"outcode":"NR29",' + '"coordinates":{"latitude":52.716014,"longitude":1.614495},' + '"uprn":"10023461458","postalCode":"NR29 4RG",' + '"propertyNumberOrName":"Martham Mill"}' + '"address":{"fullAddress":"Riverside, Martham NR29",' + '"latitude":52.716014,"longitude":1.614495,' + '"outcode":"NR29","postcode":"NR29 4RG","uprn":"10023461458"}' + ) + geo = parse_detail_geo(html) + assert geo is not None + assert geo["source"] == "detail_location" + assert geo["uprn"] == "10023461458" + assert geo["number_or_name"] == "Martham Mill" + assert geo["full_address"] == "Riverside, Martham NR29" + + +def test_parse_detail_geo_does_not_borrow_comparable_full_address() -> None: + # The only `address` twin on the page belongs to a different uprn (a + # comparable listing). With a uprn to match on, an unrelated twin is never + # borrowed — full_address stays None rather than grabbing the wrong street. + html = ( + '"location":{"outcode":"NR29",' + '"coordinates":{"latitude":52.716014,"longitude":1.614495},' + '"uprn":"10023461458","postalCode":"NR29 4RG"}' + '"address":{"fullAddress":"Some Comparable, Elsewhere EN2",' + '"latitude":51.65,"longitude":-0.08,"uprn":"99999999"}' + ) + geo = parse_detail_geo(html) + assert geo is not None + assert geo["uprn"] == "10023461458" + assert geo["full_address"] is None + + +def test_parse_detail_geo_ignores_poi_coordinates() -> None: + # A charger POI (its coordinates NOT wrapped in a "location" object) followed + # by the property's own "location" wrapper. Anchoring on the wrapper means + # the POI's coordinates are ignored and the property's are returned. + poi = ( + '"name":"Martham Community Centre","numberOfConnectors":2,' + '"postcode":"NR29 4SN","coordinates":{"latitude":52.699379,"longitude":1.62921}' + ) + prop = ( + '"location":{"outcode":"NR29",' + '"coordinates":{"latitude":52.716014,"longitude":1.614495},' + '"uprn":"10023461458","postalCode":"NR29 4RG"}' + ) + geo = parse_detail_geo(poi + prop) + assert geo is not None + assert geo["source"] == "detail_location" + # The property's coords win, not the community centre's. + assert (geo["lat"], geo["lng"]) == (52.716014, 1.614495) + assert geo["postcode"] == "NR29 4RG" + + +def test_parse_detail_geo_prefers_location_matching_search_outcode() -> None: + # Page embeds two location objects (e.g. a comparable then the property). + # With a search outcode, the one in that outcode is preferred; without one, + # the first (document order = primary listing) is returned. + comparable = ( + '"location":{"outcode":"EN2",' + '"coordinates":{"latitude":51.65,"longitude":-0.08},' + '"postalCode":"EN2 6SN"}' + ) + target = ( + '"location":{"outcode":"NR29",' + '"coordinates":{"latitude":52.716014,"longitude":1.614495},' + '"postalCode":"NR29 4RG"}' + ) + geo = parse_detail_geo(comparable + target, search_outcode="NR29") + assert geo is not None and geo["postcode"] == "NR29 4RG" + geo_first = parse_detail_geo(comparable + target) + assert geo_first is not None and geo_first["postcode"] == "EN2 6SN" + + +def test_parse_detail_geo_rejects_out_of_england() -> None: + html = ( + '"location":{"outcode":"NR29",' + '"coordinates":{"latitude":10.0,"longitude":10.0},' + '"uprn":"1","postalCode":"NR29 4RG"}' + ) + assert parse_detail_geo(html) is None + + +def test_parse_detail_geo_drops_inconsistent_postcode() -> None: + # postalCode outcode (AB12) disagrees with the object's own outcode (NR29): + # keep the coordinates, drop the untrustworthy postcode. + html = ( + '"location":{"outcode":"NR29",' + '"coordinates":{"latitude":52.716014,"longitude":1.614495},' + '"uprn":"1","postalCode":"AB12 3CD"}' + ) + geo = parse_detail_geo(html) + assert geo is not None + assert geo["lat"] == 52.716014 + assert geo["postcode"] is None + + +def test_parse_detail_geo_returns_none_for_garbage() -> None: + assert parse_detail_geo("no data here") is None + assert parse_detail_geo("") is None + # Coordinates that are not inside a property location/address wrapper (e.g. + # only an unwrapped POI) yield nothing — safe degradation to the outcode. + assert parse_detail_geo('"name":"X","coordinates":{"latitude":51.5,"longitude":-0.1}') is None + + +def _raw(**overrides) -> dict: + raw = { + "id": "123", + "url": "/for-sale/details/123/", + "address": "South Street, Bromley BR1", + "price": 500000, + "beds": 2, + "baths": 1, + "property_type": "Flat", + } + raw.update(overrides) + return raw + + +def test_transform_uses_detail_coordinates_with_agreeing_postcode() -> None: + detail = {"lat": 51.401, "lng": 0.011, "postcode": "BR1 3CD", "outcode": "BR1"} + result = transform_property( + _raw(), StubPostcodeIndex("BR1 2AB"), PC_COORDS, search_outcode="BR1", detail=detail + ) + assert result is not None + # Extracted detail postcode agrees with the coordinate-nearest outcode -> trusted. + assert result["Postcode"] == "BR1 3CD" + assert result["Postcode source"] == "detail_address" + assert result["Inferred postcode"] == "BR1 2AB" + assert (result["lat"], result["lon"]) == (51.401, 0.011) + + +def test_transform_uses_nearest_when_detail_postcode_mismatches() -> None: + detail = {"lat": 51.401, "lng": 0.011, "postcode": "E14 9SS", "outcode": "E14"} + result = transform_property( + _raw(), StubPostcodeIndex("BR1 2AB"), PC_COORDS, search_outcode="BR1", detail=detail + ) + assert result is not None + # Mismatching detail postcode is rejected in favour of the spatial value. + assert result["Postcode"] == "BR1 2AB" + assert result["Postcode source"] == "detail_coordinates" + + +def test_transform_geocodes_detail_postcode_without_coordinates() -> None: + detail = {"lat": None, "lng": None, "postcode": "SW1A 1AA", "outcode": "SW1A"} + result = transform_property( + _raw(), StubPostcodeIndex(), PC_COORDS, search_outcode="BR1", detail=detail + ) + assert result is not None + assert result["Postcode"] == "SW1A 1AA" + assert result["Postcode source"] == "detail_address" + assert (result["lat"], result["lon"]) == PC_COORDS["SW1A 1AA"] + + +def test_transform_without_detail_falls_back_to_search_outcode() -> None: + # No detail, address has no recognizable outcode -> coarse search-outcode centroid. + result = transform_property( + _raw(address="A street with no postcode"), + StubPostcodeIndex(), + PC_COORDS, + search_outcode="BR1", + detail=None, + ) + assert result is not None + assert result["Postcode"] == "BR1 2AB" + assert result["Postcode source"] == "search_outcode" + # No detail page -> no UPRN / house number recovered. + assert result["UPRN"] is None + assert result["Property number or name"] is None + + +def test_transform_emits_uprn_and_house_numbered_address_from_detail() -> None: + detail = { + "lat": 51.401, + "lng": 0.011, + "postcode": "BR1 3CD", + "outcode": "BR1", + "uprn": "100023461458", + "number_or_name": "12", + "full_address": "South Street, Bromley BR1", + } + result = transform_property( + _raw(), StubPostcodeIndex("BR1 2AB"), PC_COORDS, search_outcode="BR1", detail=detail + ) + assert result is not None + assert result["UPRN"] == "100023461458" + assert result["Property number or name"] == "12" + # The detail full address replaces the outcode-level card address, and the + # house number is prepended for a near-exact Property Register match. + assert result["Listing raw address"] == "South Street, Bromley BR1" + assert result["Address per Property Register"] == "12, South Street, Bromley" + + +def test_transform_ignores_out_of_england_detail_coords() -> None: + detail = {"lat": 10.0, "lng": 10.0, "postcode": "ZZ9 9ZZ", "outcode": "ZZ9"} + result = transform_property( + _raw(), StubPostcodeIndex("BR1 2AB"), PC_COORDS, search_outcode="BR1", detail=detail + ) + assert result is not None + # Bad detail coords are discarded; falls through to the address outcode (BR1). + assert result["Postcode source"] == "address_outcode" + assert 49 <= result["lat"] <= 56 diff --git a/finder/transform.py b/finder/transform.py index 8c1f357..49986ba 100644 --- a/finder/transform.py +++ b/finder/transform.py @@ -205,6 +205,41 @@ def extract_full_postcode(text: str | None) -> str | None: return normalize_postcode(match.group(1)) +def extract_outcode(postcode: str | None) -> str | None: + """Return the outward code (district) of a UK postcode, e.g. 'SW1A 1AA' → 'SW1A'.""" + if not postcode: + return None + normalized = normalize_postcode(postcode) + outcode = normalized.split(" ", 1)[0] + return outcode or None + + +def resolve_listing_postcode( + extracted_postcode: str | None, inferred_postcode: str +) -> tuple[str, str]: + """Pick the authoritative postcode for a listing, returning (postcode, source). + + The address-extracted postcode is more precise than the coordinate-nearest one, + but it is only trustworthy when it agrees with the location: a stale, mistyped or + well-formed-but-fabricated postcode (e.g. 'ZZ9 9ZZ') would otherwise silently + override the spatially-correct value. Since the spatial index only supports + nearest-lookup, accept the extracted postcode only when its outcode matches the + inferred (coordinate-nearest) postcode's outcode; otherwise fall back to the + inferred one, which is always a real, plausibly-correct postcode. + """ + if extracted_postcode and extract_outcode(extracted_postcode) == extract_outcode( + inferred_postcode + ): + return extracted_postcode, "address" + if extracted_postcode: + log.debug( + "Rejecting extracted postcode %s (outcode mismatch with inferred %s)", + extracted_postcode, + inferred_postcode, + ) + return inferred_postcode, "coordinates" + + def clean_listing_address(address: str | None) -> str: """Remove postcode/outcode suffixes from listing display addresses. @@ -222,10 +257,48 @@ def clean_listing_address(address: str | None) -> str: return cleaned.strip(" ,") +def build_register_address( + raw_address: str | None, number_or_name: str | None = None +) -> str: + """Build a Property Register-style address, prepending the house number/name. + + Listing display addresses are usually street-level ("South Street, Bromley") + because the portals hide the exact unit. When a scraper can recover the + property's own number or name (e.g. Zoopla detail pages expose + ``propertyNumberOrName`` = "12" or "Martham Mill"), prepend it so the address + carries the house identifier that the EPC/Price-Paid register addresses also + use — turning a fuzzy street match into a near-exact one. Falls back to the + plain cleaned address when no number/name is available. + """ + cleaned = clean_listing_address(raw_address) + if not number_or_name: + return cleaned + number_or_name = number_or_name.strip() + if not number_or_name: + return cleaned + # Avoid duplicating a number/name the display address already starts with. + if cleaned.lower().startswith(number_or_name.lower()): + return cleaned + return f"{number_or_name}, {cleaned}" if cleaned else number_or_name + + def transform_property( - prop: dict, outcode: str, pc_index: PostcodeSpatialIndex + prop: dict, + outcode: str, + pc_index: PostcodeSpatialIndex, + detail_postcode: str | None = None, ) -> dict | None: - """Transform a raw Rightmove property dict into our output schema.""" + """Transform a raw Rightmove property dict into our output schema. + + ``detail_postcode`` is the property's TRUE full postcode recovered from its + detail page (see ``rightmove.parse_detail_postcode``); the search API itself + only exposes the outcode-level ``displayAddress``. When supplied and it + agrees with the coordinate-nearest postcode's outcode, it is preferred over + the coordinate guess and recorded with source ``"detail_address"``. A + detail postcode whose outcode disagrees with the location is discarded in + favour of the spatially-correct coordinate postcode, so a stale or wrong + detail value can never silently relocate a listing. + """ loc = prop.get("location") if not loc: return None @@ -268,8 +341,25 @@ def transform_property( return None raw_address = prop.get("displayAddress", "") or "" extracted_postcode = extract_full_postcode(raw_address) - postcode = extracted_postcode or inferred_postcode - postcode_source = "address" if extracted_postcode else "coordinates" + + # Prefer the detail page's true full postcode when it agrees with the + # location; otherwise fall back to the (display-address-or-coordinate) logic. + detail_full = extract_full_postcode(detail_postcode) + if detail_full and extract_outcode(detail_full) == extract_outcode( + inferred_postcode + ): + postcode, postcode_source = detail_full, "detail_address" + else: + if detail_full: + log.debug( + "Rejecting Rightmove detail postcode %s (outcode mismatch with " + "inferred %s)", + detail_full, + inferred_postcode, + ) + postcode, postcode_source = resolve_listing_postcode( + extracted_postcode, inferred_postcode + ) property_url = prop.get("propertyUrl") or "" if not isinstance(property_url, str): @@ -291,6 +381,9 @@ def transform_property( "Inferred postcode": inferred_postcode, "Listing raw address": raw_address, "Address per Property Register": clean_listing_address(raw_address), + # Rightmove's displayAddress is street-level; no UPRN/house number. + "UPRN": None, + "Property number or name": None, "Leasehold/Freehold": extract_tenure(prop.get("tenure")), "Property type": map_property_type(sub_type), "Property sub-type": normalize_sub_type(sub_type), diff --git a/finder/zoopla.py b/finder/zoopla.py index d36bc21..6cffe5f 100644 --- a/finder/zoopla.py +++ b/finder/zoopla.py @@ -32,16 +32,24 @@ import httpx from constants import ( DATA_DIR, DELAY_BETWEEN_PAGES, + GLUETUN_API_KEY, + GLUETUN_CONTROL_URL, + GLUETUN_MAX_ROTATIONS, + GLUETUN_PROXY, MAX_BEDROOMS, PROPERTY_TYPE_MAP, ZOOPLA_BASE, + ZOOPLA_DETAIL_GOTO_TIMEOUT_MS, ) from spatial import PostcodeSpatialIndex from transform import ( - clean_listing_address, + build_register_address, extract_full_postcode, + extract_outcode, + fix_coords, normalize_sub_type, parse_int_value, + resolve_listing_postcode, validate_floor_area, ) @@ -468,27 +476,20 @@ def _challenge_timeout_seconds() -> int: # cookies (bound to the previous IP), then reload and re-check the challenge. -_GLUETUN_API_KEY = "My8AbvnKhfyFdRhpTVfoTfa5DkAMmg8K" - - def _gluetun_base_url() -> str: - return os.environ.get("GLUETUN_URL", "http://gluetun:8000").rstrip("/") + return GLUETUN_CONTROL_URL.rstrip("/") def _gluetun_api_key() -> str | None: - return _GLUETUN_API_KEY + return GLUETUN_API_KEY def _gluetun_max_rotations() -> int: - raw = os.environ.get("GLUETUN_MAX_ROTATIONS", "3") - try: - value = int(raw) - except ValueError as exc: - raise ValueError("GLUETUN_MAX_ROTATIONS must be an integer") from exc - return max(value, 0) + return max(GLUETUN_MAX_ROTATIONS, 0) def _gluetun_client() -> httpx.Client: + # Talks to the control server directly (not through the VPN proxy). headers = {} api_key = _gluetun_api_key() if api_key: @@ -694,10 +695,19 @@ def launch_browser(): profile_dir.mkdir(parents=True, exist_ok=True) _remove_stale_profile_locks(profile_dir) + # Route the browser through the Gluetun VPN proxy when configured. (geoip + # fingerprint alignment is intentionally not enabled: it needs the optional + # camoufox[geoip] extra and would spoof to the VPN exit's country, which + # fights the en-GB locale unless the exit is in the UK.) + proxy_options: dict = {} + if GLUETUN_PROXY: + proxy_options = {"proxy": {"server": GLUETUN_PROXY}} + log.info( - "Launching Camoufox browser for Zoopla (headless=%s, profile=%s)...", + "Launching Camoufox browser for Zoopla (headless=%s, profile=%s, proxy=%s)...", headless_mode, profile_dir, + GLUETUN_PROXY or "direct", ) camoufox = Camoufox( headless=headless_mode, @@ -705,6 +715,7 @@ def launch_browser(): user_data_dir=str(profile_dir), locale=["en-GB", "en"], enable_cache=True, + **proxy_options, ) raw_browser = camoufox.__enter__() browser = _ManagedCamoufoxBrowser(camoufox, raw_browser) @@ -926,13 +937,47 @@ def _paginate( page, total_results: int, max_properties: int | None = None, + fetch_detail=None, + detail_cap: int = 0, + detail_state: dict | None = None, + detail_deadline: float | None = None, ) -> list[dict]: """Extract listings from all pages of search results. Page 1 is already loaded. For subsequent pages, follow Zoopla's rendered next link when present, otherwise advance via the pn=N URL parameter while - the advertised result count says more listings remain.""" + the advertised result count says more listings remain. + + When ``fetch_detail`` is supplied, each listing has its detail page fetched + (up to ``detail_cap`` fresh loads per outcode, counted in the shared + ``detail_state`` dict, and only until ``detail_deadline``) and the parsed + geo stored under ``listing['_detail']`` for ``transform_property``. The + detail page is the only source of the listing's UPRN, full street address + and precise postcode, so it is fetched even when the search card already + pins a full postcode. Cached detail results are always attached but cost + neither a cap slot nor a delay.""" + + def _maybe_fetch(listing: dict) -> None: + if fetch_detail is None or detail_state is None: + return + url = listing.get("url", "") + cached = _detail_cache_key(url) in _detail_cache + if not cached: + # Fresh loads are bounded by the per-outcode cap and the wall-clock + # deadline so detail fetching never starves the SIGALRM budget that + # also guards the search pagination for this outcode. + if detail_state["fetched"] >= detail_cap: + return + if detail_deadline is not None and time.monotonic() >= detail_deadline: + return + listing["_detail"] = fetch_detail(url) + if not cached: + detail_state["fetched"] += 1 + time.sleep(DELAY_BETWEEN_PAGES) + all_listings = _extract_listings(page) + for listing in all_listings: + _maybe_fetch(listing) if max_properties is not None and len(all_listings) >= max_properties: return all_listings[:max_properties] @@ -984,6 +1029,7 @@ def _paginate( if listing["id"] not in seen_ids: seen_ids.add(listing["id"]) all_listings.append(listing) + _maybe_fetch(listing) new_count += 1 if max_properties is not None and len(all_listings) >= max_properties: return all_listings[:max_properties] @@ -1053,6 +1099,214 @@ def _extract_outcode(text: str) -> str | None: return None +# --------------------------------------------------------------------------- +# Detail-page geocoding +# --------------------------------------------------------------------------- +# +# Zoopla search result cards only expose an outcode-level display address (e.g. +# "South Street, Bromley BR1"); the full postcode and precise coordinates exist +# only on each listing's detail page (/for-sale/details/{id}/). The detail page +# is a Next.js App Router route whose React Server Components flight stream +# embeds the property's own location object, e.g. +# "location":{"outcode":"NR29","coordinates":{"latitude":52.716,"longitude":1.614}, +# "uprn":"10023461458","postalCode":"NR29 4RG",...} +# plus a twin "address":{"fullAddress":...,"latitude":...,"longitude":..., +# "outcode":...,"postcode":...,"uprn":...} feeding the map widgets. +# Nearby points of interest (stations, schools, EV chargers) and comparable +# listings carry their own "coordinates" too, but never inside the property's +# own "location" / "address":{"fullAddress" wrapper — so the wrapper, not a +# loose coordinates object, is what we anchor on (see parse_detail_geo). + +# listingId -> parsed detail dict (or None). Failures are cached too, so a +# broken listing is not re-fetched within a run (the same listing reappears +# across overlapping outcode searches). +_detail_cache: dict[str, dict | None] = {} + +_LISTING_ID_RE = re.compile(r"/details/(\d+)/?") + +# The property's own location is carried by a `"location":{...}` wrapper and a +# twin `"address":{"fullAddress":...}` widget object. We anchor on those +# wrappers (and capture their full object body, which contains exactly one +# nested object — `coordinates`) rather than scanning for loose coordinate +# objects: nearby points of interest (stations/schools/EV chargers) and +# comparable/"similar" listings also embed coordinates, but never inside the +# property's own `"location"` / `"address":{"fullAddress"` wrapper, so the +# wrapper is the discriminator. Field order and an optional `uprn` are tolerated. +_DETAIL_LOCATION_RE = re.compile(r'"location":\{((?:[^{}]|\{[^{}]*\})*)\}') +_DETAIL_ADDRESS_RE = re.compile(r'"address":\{"fullAddress":"([^"]*)"((?:[^{}]|\{[^{}]*\})*)\}') +_DETAIL_COORDS_IN_BODY_RE = re.compile( + r'"coordinates":\{"latitude":(-?\d+\.\d+),"longitude":(-?\d+\.\d+)\}' +) +_DETAIL_LATLNG_IN_BODY_RE = re.compile( + r'"latitude":(-?\d+\.\d+),"longitude":(-?\d+\.\d+)' +) +_DETAIL_OUTCODE_IN_BODY_RE = re.compile(r'"outcode":"([A-Z0-9]+)"') +# The location object spells it "postalCode"; the address twin uses "postcode". +_DETAIL_POSTCODE_IN_BODY_RE = re.compile(r'"(?:postalCode|postcode)":"([A-Z0-9 ]+)"') +# The UPRN (Unique Property Reference Number) appears in both the location and +# address objects and is the linchpin for an exact listing->EPC join (EPC open +# data is ~99% UPRN-keyed). propertyNumberOrName carries the house number/name +# (e.g. "12", "Martham Mill") only in the location object. +_DETAIL_UPRN_IN_BODY_RE = re.compile(r'"uprn":"(\d+)"') +_DETAIL_NUMBER_OR_NAME_IN_BODY_RE = re.compile(r'"propertyNumberOrName":"([^"]*)"') + + +def parse_detail_geo(html: str, search_outcode: str | None = None) -> dict | None: + """Extract the property's own coordinates/postcode from a Zoopla detail page. + + Pure and browser-free: the live browser only produces the HTML string + (``page.content()``); this does the parsing so it is unit-testable. + + Returns ``{"lat", "lng", "postcode", "outcode", "source", "uprn", + "number_or_name", "full_address"}`` (every field except the coordinates may + be ``None``) or ``None`` when no property location wrapper is found. The + ``uprn`` enables an exact listing->EPC join; ``number_or_name`` (house + number/name) and ``full_address`` give a register-style address for the + Price Paid join. + Coordinates are bounds-checked to England and a postcode is kept only when + it agrees with its own object's outcode. ``search_outcode``, when given, is + used only as a tie-break to pick the right ``location`` object on pages that + also embed comparable listings. See module docstring for the data model.""" + if not html: + return None + + # RSC flight strings are embedded as escaped JS string literals, so quotes + # and slashes arrive escaped; normalize them so the regexes match. + buf = html.replace('\\"', '"').replace("\\u002F", "/").replace("\\/", "/") + + def in_england(lat: float, lng: float) -> tuple[float, float] | None: + lat, lng = fix_coords(lat, lng) + if 49 <= lat <= 56 and -7 <= lng <= 2: + return lat, lng + return None + + def build(body: str, coords, source: str, full_address: str | None = None) -> dict: + # outcode and postcode are read from the SAME object body as the coords, + # so the postcode is self-consistent; drop it only if it somehow isn't. + outcode_match = _DETAIL_OUTCODE_IN_BODY_RE.search(body) + outcode = outcode_match.group(1) if outcode_match else None + postcode_match = _DETAIL_POSTCODE_IN_BODY_RE.search(body) + postcode = extract_full_postcode(postcode_match.group(1)) if postcode_match else None + if postcode and outcode and extract_outcode(postcode) != outcode.upper(): + postcode = None + uprn_match = _DETAIL_UPRN_IN_BODY_RE.search(body) + number_match = _DETAIL_NUMBER_OR_NAME_IN_BODY_RE.search(body) + number_or_name = number_match.group(1).strip() if number_match else None + return { + "lat": coords[0], + "lng": coords[1], + "postcode": postcode, + "outcode": outcode, + "source": source, + "uprn": uprn_match.group(1) if uprn_match else None, + "number_or_name": number_or_name or None, + "full_address": full_address, + } + + def attach_full_address(result: dict | None) -> dict | None: + # The house-numbered street address lives in the `address` map-widget + # twin, not the `location` wrapper we anchor coordinates on. Pull it from + # the twin that shares this property's uprn; when there is no uprn to + # disambiguate, fall back to the first twin (document order = primary + # listing), but never guess a twin when a uprn exists and none matches — + # that would risk grabbing a comparable listing's address. + if result is None or result.get("full_address"): + return result + target = result.get("uprn") + first = None + for match in _DETAIL_ADDRESS_RE.finditer(buf): + full_address = match.group(1) or None + if full_address is None: + continue + if first is None: + first = full_address + uprn_match = _DETAIL_UPRN_IN_BODY_RE.search(match.group(2)) + if target and uprn_match and uprn_match.group(1) == target: + result["full_address"] = full_address + return result + if target is None: + result["full_address"] = first + return result + + # Strategy 1 — the property's own `location` wrapper (authoritative). Take + # the first match (the primary listing precedes any comparables in the + # flight stream), but prefer one whose outcode matches the searched outcode. + first_location = None + for match in _DETAIL_LOCATION_RE.finditer(buf): + body = match.group(1) + coords_match = _DETAIL_COORDS_IN_BODY_RE.search(body) + if not coords_match: + continue + coords = in_england(float(coords_match.group(1)), float(coords_match.group(2))) + if not coords: + continue + candidate = build(body, coords, "detail_location") + if first_location is None: + first_location = candidate + if ( + search_outcode + and candidate["outcode"] + and candidate["outcode"].upper() == search_outcode.upper() + ): + return attach_full_address(candidate) + if first_location is not None: + return attach_full_address(first_location) + + # Strategy 2 — the `address` map-widget twin (same coordinates, backup). + for match in _DETAIL_ADDRESS_RE.finditer(buf): + full_address = match.group(1) or None + body = match.group(2) + latlng_match = _DETAIL_LATLNG_IN_BODY_RE.search(body) + if not latlng_match: + continue + coords = in_england(float(latlng_match.group(1)), float(latlng_match.group(2))) + if coords: + return build(body, coords, "detail_address_obj", full_address=full_address) + + return None + + +def _detail_cache_key(listing_url: str) -> str: + """Cache key for a listing detail page — its numeric id when present.""" + id_match = _LISTING_ID_RE.search(listing_url) + return id_match.group(1) if id_match else listing_url + + +def _fetch_listing_detail( + detail_page, + listing_url: str, + search_outcode: str | None = None, +) -> dict | None: + """Load a listing detail page and return its parsed geo dict (or None). + + Results (including failures) are cached by listingId. Ordinary navigation + and extraction errors are swallowed so the caller can fall back to + outcode-level resolution, but TurnstileError is allowed to propagate so the + scraper's "Cloudflare ends the run" contract still holds. The goto timeout + is kept short so one slow detail page can't eat the per-outcode budget.""" + cache_key = _detail_cache_key(listing_url) + if cache_key in _detail_cache: + return _detail_cache[cache_key] + + url = listing_url if listing_url.startswith("http") else ZOOPLA_BASE + listing_url + result: dict | None = None + try: + detail_page.goto( + url, wait_until="domcontentloaded", timeout=ZOOPLA_DETAIL_GOTO_TIMEOUT_MS + ) + _ensure_not_challenged(detail_page) + html = detail_page.content() + result = parse_detail_geo(html, search_outcode=search_outcode) + except TurnstileError: + raise + except Exception as exc: + log.debug("Zoopla detail fetch failed %s: %s", url, _exception_detail(exc)) + result = None + + _detail_cache[cache_key] = result + return result + + def _map_property_type(raw_type: str | None) -> str: """Map Zoopla property type text to canonical type.""" if not raw_type: @@ -1109,28 +1363,64 @@ def transform_property( pc_index: PostcodeSpatialIndex, pc_coords: dict[str, tuple[float, float]], search_outcode: str | None = None, + detail: dict | None = None, ) -> dict | None: """Transform a raw Zoopla listing dict into the standard output schema. - Zoopla search cards do not include coordinates, so we resolve lat/lng - from postcodes extracted from the address text.""" + Zoopla search cards only expose an outcode-level address, so precise + location comes from the listing's detail page (see ``parse_detail_geo`` / + ``_fetch_listing_detail``), passed in as ``detail``. When detail-page + coordinates are available we resolve the nearest postcode via the spatial + index — mirroring rightmove/onthemarket — and only fall back to the coarse + outcode centroid when no detail location could be obtained.""" price = parse_int_value(raw.get("price")) or 0 address = raw.get("address", "") or "" - # Resolve postcode and coordinates from address extracted_postcode = extract_full_postcode(address) - postcode = extracted_postcode - postcode_source = "address" if extracted_postcode else None + detail = detail or {} + detail_postcode = extract_full_postcode(detail.get("postcode")) + # Detail-page address fields: the UPRN keys an exact EPC join, and the + # full street address / house number-or-name beat the outcode-level card + # address for the Price-Paid join. All three are absent unless the detail + # page was fetched, so every consumer must tolerate None. + detail_uprn = detail.get("uprn") or None + detail_full_address = detail.get("full_address") or None + detail_number_or_name = detail.get("number_or_name") or None + + postcode = postcode_source = inferred_postcode = None lat = lng = None - if postcode: - coords = pc_coords.get(postcode) - if coords: - lat, lng = coords + # (A) Best: detail-page coordinates -> nearest postcode (authoritative). + detail_lat, detail_lng = detail.get("lat"), detail.get("lng") + if detail_lat is not None and detail_lng is not None: + fixed_lat, fixed_lng = fix_coords(detail_lat, detail_lng) + if 49 <= fixed_lat <= 56 and -7 <= fixed_lng <= 2: + nearest = pc_index.nearest(fixed_lat, fixed_lng) + if nearest: + lat, lng, inferred_postcode = fixed_lat, fixed_lng, nearest + candidate = detail_postcode or extracted_postcode + postcode, resolved_source = resolve_listing_postcode(candidate, nearest) + postcode_source = ( + "detail_address" + if resolved_source == "address" + else "detail_coordinates" + ) + # (B) Detail-page postcode without usable coordinates -> geocode it. + if lat is None and detail_postcode and detail_postcode in pc_coords: + lat, lng = pc_coords[detail_postcode] + postcode = inferred_postcode = detail_postcode + postcode_source = "detail_address" + + # (C) Full postcode in the search-card address -> geocode it. + if lat is None and extracted_postcode and extracted_postcode in pc_coords: + lat, lng = pc_coords[extracted_postcode] + postcode = extracted_postcode + postcode_source = "address" + + # (D) Last resort: coarse outcode-level centroid (loses per-listing precision). if lat is None: - # Try outcode-level fallback from address text addr_outcode = _extract_outcode(address) if addr_outcode: result = _resolve_outcode_coords(addr_outcode, pc_coords) @@ -1138,7 +1428,6 @@ def transform_property( postcode, lat, lng = result postcode_source = "address_outcode" - # Final fallback: use the outcode we know we're searching if lat is None and search_outcode: result = _resolve_outcode_coords(search_outcode, pc_coords) if result: @@ -1188,9 +1477,17 @@ def transform_property( "Postcode": postcode, "Postcode source": postcode_source or "unknown", "Extracted postcode": extracted_postcode, - "Inferred postcode": postcode if postcode_source != "address" else None, - "Listing raw address": address, - "Address per Property Register": clean_listing_address(address), + "Inferred postcode": ( + inferred_postcode + if inferred_postcode is not None + else (postcode if postcode_source != "address" else None) + ), + "Listing raw address": detail_full_address or address, + "Address per Property Register": build_register_address( + detail_full_address or address, detail_number_or_name + ), + "UPRN": detail_uprn, + "Property number or name": detail_number_or_name, "Leasehold/Freehold": raw.get("tenure") or None, "Property type": _map_property_type(raw.get("property_type")), "Property sub-type": normalize_sub_type(raw.get("property_type")), @@ -1215,6 +1512,9 @@ def search_outcode( pc_index: PostcodeSpatialIndex, pc_coords: dict[str, tuple[float, float]], max_properties: int | None = None, + detail_page=None, + detail_cap: int = 0, + detail_budget_seconds: float | None = None, ) -> tuple[list[dict], str | None]: """Search Zoopla for properties in one outcode. @@ -1222,6 +1522,12 @@ def search_outcode( search flow, extracts listings from rendered DOM, and transforms to the standard output schema. + When ``detail_page`` (a second browser tab) and a positive ``detail_cap`` + are supplied, up to ``detail_cap`` listings per outcode have their detail + page fetched for a precise postcode (see ``_fetch_listing_detail``). + ``detail_budget_seconds`` caps the wall-clock time spent fetching details so + the per-outcode timeout that also guards search pagination is never starved. + Returns (properties, search_url). Raises TurnstileError if Cloudflare blocks us mid-session. @@ -1231,12 +1537,25 @@ def search_outcode( total_results = _get_result_count(page) + fetch_detail = None + detail_deadline = None + if detail_page is not None and detail_cap > 0: + fetch_detail = lambda url: _fetch_listing_detail( # noqa: E731 + detail_page, url, search_outcode=outcode + ) + if detail_budget_seconds is not None: + detail_deadline = time.monotonic() + detail_budget_seconds + # Always try extraction even if result count is 0 — the count regex may # not match Zoopla's current text format, but listings may still be in DOM raw_listings = _paginate( page, total_results, max_properties=max_properties, + fetch_detail=fetch_detail, + detail_cap=detail_cap, + detail_state={"fetched": 0}, + detail_deadline=detail_deadline, ) if not raw_listings: if total_results > 0: @@ -1252,7 +1571,11 @@ def search_outcode( for raw in raw_listings: try: transformed = transform_property( - raw, pc_index, pc_coords, search_outcode=outcode + raw, + pc_index, + pc_coords, + search_outcode=outcode, + detail=raw.get("_detail"), ) except Exception as exc: log.warning( diff --git a/finder/zoopla_flaresolverr.py b/finder/zoopla_flaresolverr.py new file mode 100644 index 0000000..f3e6860 --- /dev/null +++ b/finder/zoopla_flaresolverr.py @@ -0,0 +1,164 @@ +"""Zoopla scraping via FlareSolverr (no browser/VNC needed). + +FlareSolverr solves Zoopla's Cloudflare and returns the rendered HTML, which +still contains the React Server Components flight stream — so the existing pure +parsers work unchanged: + - the search page yields the outcode's listing detail URLs, and + - each detail page's flight stream carries the property's location object + (postcode + coordinates) that ``parse_detail_geo`` extracts, plus the + listing fields (price/beds/baths/tenure/floor area) parsed here. + +Verified live (2026-05-30) against Zoopla through the Gluetun VPN: a warm +FlareSolverr session solves the SW9 search + detail pages and the flight data +is present (e.g. detail 73326946 -> SW9 0HD @ 51.477238,-0.116819). + +This is selected by constants.ZOOPLA_FETCHER == "flaresolverr"; the Camoufox +path in zoopla.py remains for ZOOPLA_FETCHER == "camoufox". +""" + +import logging +import re +import time + +from constants import DELAY_BETWEEN_PAGES, ZOOPLA_BASE +from flaresolverr import FlareSolverrError, FlareSolverrSession +from spatial import PostcodeSpatialIndex +from zoopla import _url_with_page, parse_detail_geo, transform_property + +log = logging.getLogger("zoopla") + +# Safety bound on how many search-result pages to walk per outcode. +_MAX_SERP_PAGES = 60 + +_DETAIL_PATH_RE = re.compile(r"/(?:for-sale|new-homes)/details/\d+/") +_LISTING_ID_RE = re.compile(r"/details/(\d+)/") + + +def _int(pattern: str, buf: str) -> int | None: + match = re.search(pattern, buf) + return int(match.group(1)) if match else None + + +def parse_detail_listing(html: str) -> dict: + """Extract the non-location listing fields from a Zoopla detail page. + + Mirrors the fields the Camoufox SERP-card extractor produced, read from the + detail page's flight stream (validated against real Zoopla detail HTML). + All fields are best-effort; missing ones default to None so a listing with + a known location is still emitted.""" + buf = html.replace('\\"', '"').replace("\\/", "/") + + price = _int(r'"internalValue":(\d+)', buf) + if price is None: + price = _int(r'"priceUnformatted":(\d+)', buf) + + tenure_match = re.search(r'"tenure":"([a-zA-Z]+)"', buf) + tenure = tenure_match.group(1).title() if tenure_match else None + + # Address + property type come from the page , e.g. + # "Caldwell Street, Stockwell SW9, 4 bed property for sale, £995,000 - Zoopla" + address = None + property_type = None + title_match = re.search(r'"children":"([^"]*? for sale[^"]*?)"', buf) + if title_match: + title = title_match.group(1) + addr_match = re.match(r"(.+?),\s*\d+\s*bed", title) + if addr_match: + address = addr_match.group(1).strip() + type_match = re.search(r"\d+\s*bed\s+([\w\s-]+?)\s+for sale", title) + if type_match: + property_type = type_match.group(1).strip() + explicit_type = re.search(r'"propertyType":"([^"]+)"', buf) + if explicit_type: + property_type = explicit_type.group(1) + + return { + "price": price, + "beds": _int(r'"numBedrooms":(\d+)', buf), + "baths": _int(r'"numBaths":(\d+)', buf), + "receptions": _int(r'"numLivingRooms":(\d+)', buf), + "floor_area_sqft": _int(r'"sizeSqft":(\d+)', buf), + "tenure": tenure, + "property_type": property_type, + "address": address, + } + + +def _enumerate_detail_paths(fs: FlareSolverrSession, outcode: str, limit: int | None) -> list[str]: + """Walk the outcode's search-result pages and collect listing detail paths.""" + base = f"{ZOOPLA_BASE}/for-sale/property/{outcode.lower()}/?q={outcode}&search_source=home" + seen: list[str] = [] + seen_ids: set[str] = set() + for page_num in range(1, _MAX_SERP_PAGES + 1): + url = base if page_num == 1 else _url_with_page(base, page_num) + html = fs.get(url) + new = 0 + for path in _DETAIL_PATH_RE.findall(html): + id_match = _LISTING_ID_RE.search(path) + listing_id = id_match.group(1) if id_match else path + if listing_id in seen_ids: + continue + seen_ids.add(listing_id) + seen.append(path) + new += 1 + if limit is not None and len(seen) >= limit: + return seen + if new == 0: + break + time.sleep(DELAY_BETWEEN_PAGES) + return seen + + +def search_outcode( + outcode: str, + pc_index: PostcodeSpatialIndex, + pc_coords: dict[str, tuple[float, float]], + fs: FlareSolverrSession, + max_properties: int | None = None, + detail_cap: int = 0, + detail_budget_seconds: float | None = None, +) -> tuple[list[dict], str | None]: + """Scrape one outcode via FlareSolverr. Returns (properties, search_url). + + Every listing's detail page is fetched (that is where the postcode lives), + so the effective listing count is bounded by both ``max_properties`` and + ``detail_cap``; ``detail_budget_seconds`` caps wall-clock time on details.""" + limit = detail_cap if detail_cap and detail_cap > 0 else None + if max_properties is not None: + limit = max_properties if limit is None else min(limit, max_properties) + + base = f"{ZOOPLA_BASE}/for-sale/property/{outcode.lower()}/?q={outcode}&search_source=home" + paths = _enumerate_detail_paths(fs, outcode, limit) + if not paths: + return [], base + + deadline = (time.monotonic() + detail_budget_seconds) if detail_budget_seconds else None + properties: list[dict] = [] + dropped = 0 + for path in paths: + if deadline is not None and time.monotonic() >= deadline: + log.info("Zoopla %s: detail-fetch budget reached after %d", outcode, len(properties)) + break + id_match = _LISTING_ID_RE.search(path) + listing_id = id_match.group(1) if id_match else path + try: + html = fs.get(ZOOPLA_BASE + path) + geo = parse_detail_geo(html, search_outcode=outcode) + raw = {"id": listing_id, "url": path, **parse_detail_listing(html)} + prop = transform_property( + raw, pc_index, pc_coords, search_outcode=outcode, detail=geo + ) + except FlareSolverrError as exc: + log.warning("Zoopla %s detail %s fetch failed: %s", outcode, listing_id, exc) + prop = None + except Exception as exc: # noqa: BLE001 - never let one listing kill the outcode + log.warning("Zoopla %s detail %s transform failed: %s", outcode, listing_id, exc) + prop = None + if prop: + properties.append(prop) + else: + dropped += 1 + time.sleep(DELAY_BETWEEN_PAGES) + + log.info("Zoopla %s: %d listings (%d dropped)", outcode, len(properties), dropped) + return properties, base diff --git a/frontend/src/components/map/Map.tsx b/frontend/src/components/map/Map.tsx index 91a487f..f1b81dc 100644 --- a/frontend/src/components/map/Map.tsx +++ b/frontend/src/components/map/Map.tsx @@ -606,12 +606,13 @@ function OverlayTileLayers({ const showTrees = activeOverlays.has('trees-outside-woodlands'); const showPropertyBorders = activeOverlays.has('property-borders'); - // Restrict the heatmap to the selected crime types. When every type is - // selected we omit the filter entirely so all features contribute. - const crimeFilter = - activeCrimeTypes.size >= CRIME_TYPE_VALUES.length - ? undefined - : ['in', ['get', 'crime_type'], ['literal', Array.from(activeCrimeTypes)]]; + // Restrict the heatmap to the selected crime types. This must always be a + // concrete expression: passing `filter={undefined}` makes react-map-gl call + // map.addLayer({filter: undefined}), which MapLibre rejects at validation + // ("filter: array expected, undefined found"), so the layer is never created + // and the heatmap stays blank until a later setFilter call. An `in` over the + // selected types matches everything when all 14 are selected. + const crimeFilter = ['in', ['get', 'crime_type'], ['literal', Array.from(activeCrimeTypes)]]; return ( <> diff --git a/frontend/src/components/map/MobileDrawer.test.tsx b/frontend/src/components/map/MobileDrawer.test.tsx new file mode 100644 index 0000000..a7a626c --- /dev/null +++ b/frontend/src/components/map/MobileDrawer.test.tsx @@ -0,0 +1,107 @@ +import { cleanup, fireEvent, render, screen } from '@testing-library/react'; +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; + +import MobileDrawer from './MobileDrawer'; + +vi.mock('react-i18next', () => ({ + useTranslation: () => ({ + t: (key: string) => key, + }), +})); + +const originalSetPointerCapture = HTMLElement.prototype.setPointerCapture; + +function renderDrawer(onClose = vi.fn()) { + const view = render( + <MobileDrawer + onClose={onClose} + renderArea={() => <div>Area content</div>} + renderProperties={() => <div>Properties content</div>} + tab="area" + onTabChange={vi.fn()} + /> + ); + const handle = view.container.querySelector('[data-mobile-drawer-drag-handle]'); + const root = view.container.querySelector('[data-tutorial="right-pane"]'); + const panel = view.container.querySelector('[data-tutorial="right-pane"] > div:last-child'); + + if (!(handle instanceof HTMLElement)) throw new Error('Expected drawer drag handle'); + if (!(root instanceof HTMLElement)) throw new Error('Expected drawer root'); + if (!(panel instanceof HTMLElement)) throw new Error('Expected drawer panel'); + + return { ...view, handle, onClose, panel, root }; +} + +describe('MobileDrawer', () => { + beforeEach(() => { + HTMLElement.prototype.setPointerCapture = vi.fn(); + }); + + afterEach(() => { + cleanup(); + Object.defineProperty(HTMLElement.prototype, 'setPointerCapture', { + configurable: true, + value: originalSetPointerCapture, + }); + }); + + it('lowers and stays open when swiped down from the handle', () => { + const { handle, onClose, panel } = renderDrawer(); + + fireEvent.pointerDown(handle, { pointerId: 1, clientY: 120 }); + fireEvent.pointerMove(handle, { pointerId: 1, clientY: 230 }); + fireEvent.pointerUp(handle, { pointerId: 1, clientY: 230 }); + + expect(onClose).not.toHaveBeenCalled(); + expect(panel.style.transform).toBe('translateY(110px)'); + }); + + it('can be raised again after being lowered', () => { + const { handle, onClose, panel } = renderDrawer(); + + fireEvent.pointerDown(handle, { pointerId: 1, clientY: 120 }); + fireEvent.pointerMove(handle, { pointerId: 1, clientY: 230 }); + fireEvent.pointerUp(handle, { pointerId: 1, clientY: 230 }); + + fireEvent.pointerDown(handle, { pointerId: 2, clientY: 230 }); + fireEvent.pointerMove(handle, { pointerId: 2, clientY: 170 }); + fireEvent.pointerUp(handle, { pointerId: 2, clientY: 170 }); + + expect(onClose).not.toHaveBeenCalled(); + expect(panel.style.transform).toBe('translateY(50px)'); + }); + + it('keeps the close control reachable when dragged down far', () => { + const { handle, panel } = renderDrawer(); + + Object.defineProperty(panel, 'offsetHeight', { + configurable: true, + value: 200, + }); + + fireEvent.pointerDown(handle, { pointerId: 1, clientY: 120 }); + fireEvent.pointerMove(handle, { pointerId: 1, clientY: 420 }); + fireEvent.pointerUp(handle, { pointerId: 1, clientY: 420 }); + + expect(panel.style.transform).toBe('translateY(96px)'); + }); + + it('leaves the rest of the mobile map usable while the panel is open', () => { + const { panel, root } = renderDrawer(); + const spacer = root.firstElementChild; + + if (!(spacer instanceof HTMLElement)) throw new Error('Expected drawer spacer'); + + expect(root.className).toContain('pointer-events-none'); + expect(panel.className).toContain('pointer-events-auto'); + expect(spacer.className).not.toContain('bg-black'); + }); + + it('closes from the close button', () => { + const { onClose } = renderDrawer(); + + fireEvent.click(screen.getByLabelText('mobileDrawer.closeDrawer')); + + expect(onClose).toHaveBeenCalledTimes(1); + }); +}); diff --git a/frontend/src/lib/color-opacity.ts b/frontend/src/lib/color-opacity.ts new file mode 100644 index 0000000..bac9ebf --- /dev/null +++ b/frontend/src/lib/color-opacity.ts @@ -0,0 +1,11 @@ +export const DEFAULT_COLOR_OPACITY = 1; +export const MIN_COLOR_OPACITY = 0.1; + +export function normalizeColorOpacity(value: number | null | undefined): number { + if (value == null || !Number.isFinite(value)) return DEFAULT_COLOR_OPACITY; + return Math.min(1, Math.max(MIN_COLOR_OPACITY, value)); +} + +export function colorOpacityToPercent(value: number): number { + return Math.round(normalizeColorOpacity(value) * 100); +} diff --git a/frontend/src/lib/crime-types.ts b/frontend/src/lib/crime-types.ts new file mode 100644 index 0000000..ff1f8d9 --- /dev/null +++ b/frontend/src/lib/crime-types.ts @@ -0,0 +1,35 @@ +// Street-crime categories carried by the `crime_hotspots` vector tiles in the +// `crime_type` feature property. The `value` strings must match the police.uk +// "Crime type" values exactly (see pipeline/transform/crime_hotspot_tiles.py), +// because they are used directly in the MapLibre heatmap `filter` expression. +// `label` is a shorter, human-friendly name for the overlay-selector checkboxes. + +export interface CrimeTypeDef { + value: string; + label: string; +} + +export const CRIME_TYPES: readonly CrimeTypeDef[] = [ + { value: 'Violence and sexual offences', label: 'Violence & sexual offences' }, + { value: 'Anti-social behaviour', label: 'Anti-social behaviour' }, + { value: 'Criminal damage and arson', label: 'Criminal damage & arson' }, + { value: 'Public order', label: 'Public order' }, + { value: 'Shoplifting', label: 'Shoplifting' }, + { value: 'Vehicle crime', label: 'Vehicle crime' }, + { value: 'Burglary', label: 'Burglary' }, + { value: 'Other theft', label: 'Other theft' }, + { value: 'Theft from the person', label: 'Theft from the person' }, + { value: 'Bicycle theft', label: 'Bicycle theft' }, + { value: 'Drugs', label: 'Drugs' }, + { value: 'Robbery', label: 'Robbery' }, + { value: 'Possession of weapons', label: 'Possession of weapons' }, + { value: 'Other crime', label: 'Other crime' }, +] as const; + +export const CRIME_TYPE_VALUES: readonly string[] = CRIME_TYPES.map((c) => c.value); + +const CRIME_TYPE_VALUE_SET = new Set<string>(CRIME_TYPE_VALUES); + +export function isCrimeTypeValue(value: string): boolean { + return CRIME_TYPE_VALUE_SET.has(value); +} diff --git a/pipeline/download/inspire.py b/pipeline/download/inspire.py index c32e531..64981e2 100644 --- a/pipeline/download/inspire.py +++ b/pipeline/download/inspire.py @@ -4,7 +4,10 @@ Downloads GML files for all local authorities from the INSPIRE download page. Each ZIP contains a GML file with title extent polygons for that authority. Source: https://use-land-property-data.service.gov.uk/datasets/inspire/download -License: INSPIRE End User Licence +License: Open Government Licence v3.0 (since 1 July 2020, under the PSGA). + Requires HM Land Registry + Ordnance Survey (AC0000851063) attribution; see + the conditions page at the source URL. Boundaries are indicative "general + boundaries", not the legal extent of title. """ import argparse diff --git a/pipeline/download/satellite_highres.py b/pipeline/download/satellite_highres.py new file mode 100644 index 0000000..06141df --- /dev/null +++ b/pipeline/download/satellite_highres.py @@ -0,0 +1,505 @@ +"""Build a high-resolution England aerial PMTiles archive from EA Vertical Aerial Photography. + +The Environment Agency / Defra Vertical Aerial Photography (VAP) archive is open +(OGL v3.0) RGB orthophotography at 10-50 cm, distributed as 5 km ECW tiles on the +British National Grid. There is no public imagery tile service, so we mirror the +Sentinel-2 ``satellite.pmtiles`` approach: query the Defra survey download API for +an area of interest, pick the best RGB capture per OS tile, download and decode the +ECW rasters, re-tile them into Web-Mercator raster tiles, and bake a single PMTiles +archive that the server stacks *over* the Sentinel-2 base where coverage exists. + +ECW decoding needs a GDAL build that includes the (free, read-only) ERDAS ECW/JP2 +SDK, which is not present in the rasterio wheel. The mosaic + tiling step therefore +runs inside a GDAL-with-ECW Docker image (see ``docker/gdal-ecw/Dockerfile``); the +rest of the pipeline is plain Python plus the ``pmtiles`` CLI. +""" + +from __future__ import annotations + +import argparse +import json +import re +import shutil +import sqlite3 +import subprocess +import tempfile +import urllib.error +import urllib.request +import zipfile +from concurrent.futures import ThreadPoolExecutor, as_completed +from dataclasses import dataclass +from pathlib import Path + +from pipeline.download.tiles import ensure_pmtiles_cli +from pipeline.local_temp import local_tmp_dir + +# Defra Data Services Platform survey download API (reverse-engineered from the +# environment.data.gov.uk/survey front-end; no official API is documented). +SEARCH_URL = ( + "https://environment.data.gov.uk/backend/catalog/api/tiles/collections/survey/search" +) +SURVEY_PAGE_URL = "https://environment.data.gov.uk/survey" +# Static public key baked into the survey page JS. May rotate -- we try to scrape a +# fresh one from the page and only fall back to this literal. +DEFAULT_SUBSCRIPTION_KEY = "dspui" +SUBSCRIPTION_KEY_RE = re.compile(r"subscription-key=([A-Za-z0-9]+)") + +# True-colour RGB product only (skip IRRGB near-infra-red and Night Time variants). +VAP_RGB_PRODUCT = "vertical_aerial_photography_tiles_rgb" + +# Greater London bounding box (lon/lat). The API only returns tiles where coverage +# exists, so a generous bbox is fine -- it does not force blank downloads. +DEFAULT_AOI: dict = { + "type": "Polygon", + "coordinates": [ + [ + [-0.55, 51.25], + [0.30, 51.25], + [0.30, 51.70], + [-0.55, 51.70], + [-0.55, 51.25], + ] + ], +} + +DEFAULT_MIN_ZOOM = 14 +DEFAULT_MAX_ZOOM = 19 +# GDAL image with the ECW driver. The official OSGeo image does not ship ECW, so +# this defaults to the locally-built image from docker/gdal-ecw/Dockerfile. +DEFAULT_GDAL_IMAGE = "perfect-postcode/gdal-ecw:latest" +USER_AGENT = "perfect-postcode-satellite-highres/1.0" +ATTRIBUTION_TEMPLATE = ( + "Environment Agency Vertical Aerial Photography - " + "© Environment Agency copyright and/or database right {year}. " + "All rights reserved. Licensed under the Open Government Licence v3.0." +) + + +@dataclass(frozen=True) +class VapTile: + """One survey download record from the Defra search API.""" + + product_id: str + year: int + resolution_m: float + os_tile_id: str + uri: str + label: str + + +def parse_search_results(payload: dict) -> list[VapTile]: + """Turn a raw search-API JSON payload into typed records.""" + tiles: list[VapTile] = [] + for result in payload.get("results", []): + try: + tiles.append( + VapTile( + product_id=result["product"]["id"], + year=int(result["year"]["id"]), + resolution_m=float(result["resolution"]["id"]), + os_tile_id=result["tile"]["id"], + uri=result["uri"], + label=result.get("label", ""), + ) + ) + except (KeyError, TypeError, ValueError): + # Skip malformed records rather than failing the whole search. + continue + return tiles + + +def select_best_rgb_tiles(tiles: list[VapTile]) -> list[VapTile]: + """Pick one RGB capture per OS tile: finest resolution, then latest year. + + Pure function -- the unit test exercises this against a real-shaped payload. + """ + best: dict[str, VapTile] = {} + for tile in tiles: + if tile.product_id != VAP_RGB_PRODUCT: + continue + current = best.get(tile.os_tile_id) + if current is None or _is_better(tile, current): + best[tile.os_tile_id] = tile + return [best[key] for key in sorted(best)] + + +def _is_better(candidate: VapTile, incumbent: VapTile) -> bool: + """Finer resolution wins; ties broken by the most recent survey year.""" + if candidate.resolution_m != incumbent.resolution_m: + return candidate.resolution_m < incumbent.resolution_m + return candidate.year > incumbent.year + + +def _http_get(url: str, timeout: float) -> bytes: + req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT}) + with urllib.request.urlopen(req, timeout=timeout) as response: + return response.read() + + +def resolve_subscription_key(explicit: str | None, timeout: float = 30.0) -> str: + """Use an explicit key, else scrape the survey page JS, else the known default.""" + if explicit: + return explicit + try: + page = _http_get(SURVEY_PAGE_URL, timeout).decode("utf-8", "ignore") + match = SUBSCRIPTION_KEY_RE.search(page) + if match: + return match.group(1) + # The key usually lives in a referenced JS chunk; scan the largest one. + for chunk in re.findall(r'src="(/_next/static/[^"]+\.js)"', page): + js = _http_get(f"https://environment.data.gov.uk{chunk}", timeout) + match = SUBSCRIPTION_KEY_RE.search(js.decode("utf-8", "ignore")) + if match: + return match.group(1) + except (urllib.error.URLError, TimeoutError, ConnectionError) as err: + print(f"Could not scrape subscription key ({err}); using default", flush=True) + return DEFAULT_SUBSCRIPTION_KEY + + +def search_vap_tiles(aoi: dict, timeout: float = 60.0) -> list[VapTile]: + """POST the area-of-interest polygon and return the RGB tiles to download.""" + body = json.dumps(aoi).encode("utf-8") + req = urllib.request.Request( + SEARCH_URL, + data=body, + headers={ + "Content-Type": "application/geo+json", + "Referer": SURVEY_PAGE_URL, + "User-Agent": USER_AGENT, + }, + method="POST", + ) + with urllib.request.urlopen(req, timeout=timeout) as response: + payload = json.load(response) + selected = select_best_rgb_tiles(parse_search_results(payload)) + print( + f"Search returned {payload.get('count', 0)} records; " + f"selected {len(selected)} RGB tile(s)", + flush=True, + ) + return selected + + +def _download_and_extract( + tile: VapTile, ecw_dir: Path, key: str, timeout: float, retries: int +) -> list[Path]: + """Download one survey zip and extract its ECW raster(s).""" + url = f"{tile.uri}?subscription-key={key}" + zip_path = ecw_dir / f"{tile.os_tile_id}.zip" + last_error: Exception | None = None + for attempt in range(retries + 1): + try: + with urllib.request.urlopen( + urllib.request.Request(url, headers={"User-Agent": USER_AGENT}), + timeout=timeout, + ) as response, zip_path.open("wb") as out: + shutil.copyfileobj(response, out, length=1 << 20) + break + except (urllib.error.URLError, TimeoutError, ConnectionError) as err: + last_error = err + if attempt == retries: + raise RuntimeError(f"Failed to download {url}: {err}") from err + extracted: list[Path] = [] + with zipfile.ZipFile(zip_path) as archive: + for member in archive.infolist(): + if member.is_dir() or not member.filename.lower().endswith(".ecw"): + continue + target = ecw_dir / f"{tile.os_tile_id}_{Path(member.filename).name}" + with archive.open(member) as src, target.open("wb") as dst: + shutil.copyfileobj(src, dst, length=1 << 20) + extracted.append(target) + zip_path.unlink(missing_ok=True) + if not extracted: + print(f" {tile.os_tile_id}: no ECW in archive (skipped)", flush=True) + return extracted + + +def download_tiles( + tiles: list[VapTile], + ecw_dir: Path, + key: str, + max_workers: int, + timeout: float, + retries: int, +) -> list[Path]: + """Download every selected tile concurrently; return all extracted ECW paths.""" + ecw_dir.mkdir(parents=True, exist_ok=True) + ecw_paths: list[Path] = [] + with ThreadPoolExecutor(max_workers=max_workers) as executor: + futures = { + executor.submit( + _download_and_extract, tile, ecw_dir, key, timeout, retries + ): tile + for tile in tiles + } + done = 0 + for future in as_completed(futures): + tile = futures[future] + ecw_paths.extend(future.result()) + done += 1 + print( + f"Downloaded {done}/{len(tiles)} tiles " + f"(latest: {tile.os_tile_id} {tile.resolution_m}m {tile.year})", + flush=True, + ) + return ecw_paths + + +def _build_tiles_with_gdal( + work_dir: Path, + gdal_image: str, + min_zoom: int, + max_zoom: int, + jobs: int, + webp_quality: int, +) -> Path: + """Mosaic the ECW rasters and emit XYZ WebP tiles inside the GDAL-with-ECW image. + + Returns the host path of the generated ``xyz`` directory. We use lossy WebP with + an alpha channel: ~6x smaller than lossless PNG for photographic imagery while + keeping transparency, so coverage gaps stay see-through and the Sentinel-2 base + shows through them. + """ + xyz_dir = work_dir / "xyz" + # EA "RGB" ECWs are 4-band RGBA (band 4 is a constant-255 validity/alpha mask), + # so we build a plain 4-band VRT (no -addalpha, which would make a 5th band and + # exceed PNG's 4-band limit). We then: + # * force EPSG:27700 -- the pixels are already British National Grid, and the + # EPSG code lets PROJ apply the OSTN15 datum shift (grid ships in the image) + # for metre-accurate reprojection to Web Mercator; + # * label band 4 as alpha so gdal2tiles writes transparent PNGs. Inter-block + # gaps the VRT fills with 0 then read as alpha=0 (transparent), letting the + # Sentinel-2 base show through wherever VAP coverage is missing. + script = ( + "set -euo pipefail; " + "cd /work; " + "gdalbuildvrt -resolution highest mosaic.vrt ecw/*.ecw; " + "gdal_edit.py -a_srs EPSG:27700 " + "-colorinterp_1 red -colorinterp_2 green -colorinterp_3 blue " + "-colorinterp_4 alpha mosaic.vrt; " + f"gdal2tiles.py --xyz --zoom={min_zoom}-{max_zoom} " + f"--processes={jobs} --resampling=average --webviewer=none " + f"--tiledriver=WEBP --webp-quality={webp_quality} " + "mosaic.vrt xyz" + ) + subprocess.run( + [ + "docker", + "run", + "--rm", + "-v", + f"{work_dir.resolve()}:/work", + gdal_image, + "bash", + "-c", + script, + ], + check=True, + ) + if not xyz_dir.exists(): + raise RuntimeError("gdal2tiles produced no output directory") + return xyz_dir + + +def _pack_xyz_to_mbtiles( + xyz_dir: Path, + mbtiles_path: Path, + bounds: tuple[float, float, float, float], + min_zoom: int, + max_zoom: int, + attribution: str, +) -> int: + """Pack a gdal2tiles XYZ WebP directory into an MBTiles SQLite file (TMS rows).""" + if mbtiles_path.exists(): + mbtiles_path.unlink() + conn = sqlite3.connect(mbtiles_path) + try: + conn.execute("PRAGMA journal_mode = WAL") + conn.execute("PRAGMA synchronous = NORMAL") + conn.execute("CREATE TABLE metadata (name TEXT, value TEXT)") + conn.execute( + "CREATE TABLE tiles (zoom_level INTEGER, tile_column INTEGER, " + "tile_row INTEGER, tile_data BLOB)" + ) + conn.execute( + "CREATE UNIQUE INDEX tile_index ON tiles " + "(zoom_level, tile_column, tile_row)" + ) + conn.executemany( + "INSERT INTO metadata (name, value) VALUES (?, ?)", + [ + ("name", "EA Vertical Aerial Photography"), + ("type", "overlay"), + ("version", "1"), + ("description", "Environment Agency high-resolution aerial imagery"), + ("format", "webp"), + ("attribution", attribution), + ("bounds", ",".join(f"{value:.6f}" for value in bounds)), + ("minzoom", str(min_zoom)), + ("maxzoom", str(max_zoom)), + ], + ) + inserted = 0 + for zoom_dir in sorted(xyz_dir.iterdir()): + if not zoom_dir.is_dir() or not zoom_dir.name.isdigit(): + continue + zoom = int(zoom_dir.name) + for col_dir in zoom_dir.iterdir(): + if not col_dir.is_dir() or not col_dir.name.isdigit(): + continue + col = int(col_dir.name) + for tile_file in col_dir.glob("*.webp"): + if not tile_file.stem.isdigit(): + continue + row = int(tile_file.stem) + tms_row = (1 << zoom) - 1 - row + conn.execute( + "INSERT OR REPLACE INTO tiles VALUES (?, ?, ?, ?)", + (zoom, col, tms_row, tile_file.read_bytes()), + ) + inserted += 1 + if inserted % 5000 == 0: + conn.commit() + print(f" packed {inserted:,} tiles", flush=True) + conn.commit() + finally: + conn.close() + return inserted + + +def build_satellite_highres_tiles( + output_path: Path, + pmtiles_bin: Path, + pmtiles_version: str, + aoi: dict, + min_zoom: int, + max_zoom: int, + gdal_image: str, + subscription_key: str | None, + max_workers: int, + timeout: float, + retries: int, + jobs: int, + webp_quality: int, +) -> None: + if min_zoom > max_zoom: + raise ValueError("--min-zoom must be <= --max-zoom") + + output_path.parent.mkdir(parents=True, exist_ok=True) + ensure_pmtiles_cli(pmtiles_bin, pmtiles_version) + + tiles = search_vap_tiles(aoi) + if not tiles: + raise RuntimeError("No RGB Vertical Aerial Photography tiles for the AOI") + key = resolve_subscription_key(subscription_key) + attribution = ATTRIBUTION_TEMPLATE.format(year=max(tile.year for tile in tiles)) + + with tempfile.TemporaryDirectory(dir=local_tmp_dir()) as tmp: + work_dir = Path(tmp) + ecw_dir = work_dir / "ecw" + ecw_paths = download_tiles( + tiles, ecw_dir, key, max_workers, timeout, retries + ) + if not ecw_paths: + raise RuntimeError("No ECW rasters were extracted from the downloads") + + xyz_dir = _build_tiles_with_gdal( + work_dir, gdal_image, min_zoom, max_zoom, jobs, webp_quality + ) + + mbtiles_path = work_dir / "satellite_highres.mbtiles" + bounds = _aoi_bounds(aoi) + inserted = _pack_xyz_to_mbtiles( + xyz_dir, mbtiles_path, bounds, min_zoom, max_zoom, attribution + ) + if inserted == 0: + raise RuntimeError("Tiling produced no tiles to pack") + print(f"Packed {inserted:,} tiles into MBTiles", flush=True) + + subprocess.run( + [str(pmtiles_bin), "convert", str(mbtiles_path), str(output_path), "--force"], + check=True, + ) + + size_mb = output_path.stat().st_size / (1024 * 1024) + print(f"Wrote {output_path} ({size_mb:.1f} MB) -- {attribution}", flush=True) + + +def _aoi_bounds(aoi: dict) -> tuple[float, float, float, float]: + coords = [point for ring in aoi["coordinates"] for point in ring] + lons = [point[0] for point in coords] + lats = [point[1] for point in coords] + return min(lons), min(lats), max(lons), max(lats) + + +def _load_aoi(path: Path | None) -> dict: + if path is None: + return DEFAULT_AOI + data = json.loads(path.read_text()) + if data.get("type") == "FeatureCollection": + return data["features"][0]["geometry"] + if data.get("type") == "Feature": + return data["geometry"] + return data + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path, required=True) + parser.add_argument("--pmtiles-bin", type=Path, default=Path("property-data/pmtiles")) + parser.add_argument("--pmtiles-version", default="1.22.3") + parser.add_argument( + "--aoi-geojson", + type=Path, + default=None, + help="GeoJSON Polygon/Feature/FeatureCollection for the area of interest " + "(default: Greater London)", + ) + parser.add_argument("--min-zoom", type=int, default=DEFAULT_MIN_ZOOM) + parser.add_argument("--max-zoom", type=int, default=DEFAULT_MAX_ZOOM) + parser.add_argument( + "--gdal-image", + default=DEFAULT_GDAL_IMAGE, + help="Docker image with a GDAL that has the ECW driver", + ) + parser.add_argument( + "--subscription-key", + default=None, + help="Override the Defra survey API key (default: scrape, then 'dspui')", + ) + parser.add_argument("--max-workers", type=int, default=4) + parser.add_argument("--timeout", type=float, default=600.0) + parser.add_argument("--retries", type=int, default=3) + parser.add_argument( + "--jobs", + type=int, + default=8, + help="Parallel processes for gdal2tiles", + ) + parser.add_argument( + "--webp-quality", + type=int, + default=85, + help="WebP tile quality (1-100); lower is smaller", + ) + args = parser.parse_args() + + build_satellite_highres_tiles( + output_path=args.output, + pmtiles_bin=args.pmtiles_bin, + pmtiles_version=args.pmtiles_version, + aoi=_load_aoi(args.aoi_geojson), + min_zoom=args.min_zoom, + max_zoom=args.max_zoom, + gdal_image=args.gdal_image, + subscription_key=args.subscription_key, + max_workers=max(1, args.max_workers), + timeout=args.timeout, + retries=max(0, args.retries), + jobs=max(1, args.jobs), + webp_quality=args.webp_quality, + ) + + +if __name__ == "__main__": + main() diff --git a/pipeline/download/test_satellite_highres.py b/pipeline/download/test_satellite_highres.py new file mode 100644 index 0000000..dc84fa3 --- /dev/null +++ b/pipeline/download/test_satellite_highres.py @@ -0,0 +1,97 @@ +from pipeline.download import satellite_highres +from pipeline.download.satellite_highres import ( + VapTile, + parse_search_results, + select_best_rgb_tiles, +) + + +def _result(product: str, year: str, resolution: str, tile: str) -> dict: + """One search-API record in the real response shape.""" + return { + "product": {"id": product, "label": product}, + "year": {"id": year, "label": year}, + "resolution": {"id": resolution, "label": f"{resolution}m"}, + "tile": {"id": tile, "label": tile}, + "label": f"{product}-{year}-{resolution}m-{tile}", + "uri": ( + "https://environment.data.gov.uk/tiles/collections/survey/" + f"{product}/{year}/{resolution}/{tile}" + ), + } + + +# Mirrors a real Greater-London response: RGB at 0.4m (2008) and 0.1m (2011), +# plus Night Time and LIDAR products that must be ignored. +SAMPLE_PAYLOAD = { + "count": 6, + "results": [ + _result("vertical_aerial_photography_tiles_rgb", "2008", "0.4", "TQ2575"), + _result("vertical_aerial_photography_tiles_night_time", "2012", "0.2", "TQ2575"), + _result("lidar_composite_dtm", "2022", "1", "TQ2575"), + # TQ3080 has two RGB captures: a finer-but-older and a coarser-but-newer. + _result("vertical_aerial_photography_tiles_rgb", "2008", "0.1", "TQ3080"), + _result("vertical_aerial_photography_tiles_rgb", "2011", "0.25", "TQ3080"), + _result("vertical_aerial_photography_tiles_irrgb", "2012", "0.5", "TQ3080"), + ], +} + + +def test_parse_search_results_skips_malformed_records() -> None: + payload = { + "results": [ + _result("vertical_aerial_photography_tiles_rgb", "2008", "0.4", "TQ2575"), + {"product": {"id": "broken"}}, # missing year/resolution/tile/uri + ] + } + tiles = parse_search_results(payload) + assert len(tiles) == 1 + assert tiles[0] == VapTile( + product_id="vertical_aerial_photography_tiles_rgb", + year=2008, + resolution_m=0.4, + os_tile_id="TQ2575", + uri="https://environment.data.gov.uk/tiles/collections/survey/" + "vertical_aerial_photography_tiles_rgb/2008/0.4/TQ2575", + label="vertical_aerial_photography_tiles_rgb-2008-0.4m-TQ2575", + ) + + +def test_select_best_rgb_filters_non_rgb_products() -> None: + selected = select_best_rgb_tiles(parse_search_results(SAMPLE_PAYLOAD)) + assert {tile.product_id for tile in selected} == { + satellite_highres.VAP_RGB_PRODUCT + } + + +def test_select_best_rgb_one_tile_per_os_square() -> None: + selected = select_best_rgb_tiles(parse_search_results(SAMPLE_PAYLOAD)) + assert sorted(tile.os_tile_id for tile in selected) == ["TQ2575", "TQ3080"] + + +def test_select_best_rgb_prefers_finest_resolution_then_latest_year() -> None: + selected = { + tile.os_tile_id: tile + for tile in select_best_rgb_tiles(parse_search_results(SAMPLE_PAYLOAD)) + } + # TQ2575: only one RGB capture. + assert selected["TQ2575"].resolution_m == 0.4 + # TQ3080: finest resolution (0.1m) wins even though it is the older survey. + assert selected["TQ3080"].resolution_m == 0.1 + assert selected["TQ3080"].year == 2008 + + +def test_select_best_rgb_breaks_resolution_ties_by_year() -> None: + tiles = [ + VapTile(satellite_highres.VAP_RGB_PRODUCT, 2009, 0.25, "TQ0101", "u", "a"), + VapTile(satellite_highres.VAP_RGB_PRODUCT, 2018, 0.25, "TQ0101", "u", "b"), + VapTile(satellite_highres.VAP_RGB_PRODUCT, 2015, 0.25, "TQ0101", "u", "c"), + ] + selected = select_best_rgb_tiles(tiles) + assert len(selected) == 1 + assert selected[0].year == 2018 + + +def test_select_best_rgb_empty_when_no_rgb() -> None: + payload = {"results": [_result("lidar_composite_dtm", "2022", "1", "TQ2575")]} + assert select_best_rgb_tiles(parse_search_results(payload)) == [] diff --git a/pipeline/test_validate_outputs.py b/pipeline/test_validate_outputs.py index e61b9f9..4b7d4ce 100644 --- a/pipeline/test_validate_outputs.py +++ b/pipeline/test_validate_outputs.py @@ -1,12 +1,25 @@ from __future__ import annotations import zipfile +import json import polars as pl from pipeline.validate_outputs import main +def write_boundary(path, postcodes): + units = path / "units" + units.mkdir(parents=True) + features = [ + {"type": "Feature", "properties": {"postcodes": postcode}, "geometry": None} + for postcode in postcodes + ] + (units / "AA1.geojson").write_text( + json.dumps({"type": "FeatureCollection", "features": features}) + ) + + def test_validates_parquet_file_and_zip(tmp_path, monkeypatch): parquet_path = tmp_path / "data.parquet" file_path = tmp_path / "plain.txt" @@ -59,3 +72,42 @@ def test_rejects_missing_and_empty_outputs(tmp_path, monkeypatch, capsys): assert "empty file" in stderr assert "missing" in stderr assert "no files matched" in stderr + + +def test_validates_postcode_boundary_matches(tmp_path, monkeypatch): + postcodes_path = tmp_path / "postcodes.parquet" + boundaries_path = tmp_path / "postcode_boundaries" + pl.DataFrame({"postcode": ["AA1 1AA", "AA1 1AB"]}).write_parquet(postcodes_path) + write_boundary(boundaries_path, ["AA1 1AA", "AA1 1AB"]) + + monkeypatch.setattr( + "sys.argv", + [ + "validate_outputs", + "--postcode-boundary-match", + f"{postcodes_path}::{boundaries_path}", + ], + ) + + assert main() == 0 + + +def test_rejects_postcode_boundary_mismatch(tmp_path, monkeypatch, capsys): + postcodes_path = tmp_path / "postcodes.parquet" + boundaries_path = tmp_path / "postcode_boundaries" + pl.DataFrame({"postcode": ["AA1 1AA", "AA1 1AB"]}).write_parquet(postcodes_path) + write_boundary(boundaries_path, ["AA1 1AA", "AA1 1AC"]) + + monkeypatch.setattr( + "sys.argv", + [ + "validate_outputs", + "--postcode-boundary-match", + f"{postcodes_path}::{boundaries_path}", + ], + ) + + assert main() == 1 + stderr = capsys.readouterr().err + assert "missing boundaries" in stderr + assert "boundary postcodes are absent" in stderr diff --git a/pipeline/transform/crime_spatial.py b/pipeline/transform/crime_spatial.py new file mode 100644 index 0000000..c72a6b5 --- /dev/null +++ b/pipeline/transform/crime_spatial.py @@ -0,0 +1,358 @@ +"""Aggregate police.uk street crime to postcodes by 50m spatial proximity. + +Instead of attributing each incident to its published LSOA code, this transform +counts the anonymised incident *points* that fall within 50m of each postcode's +boundary polygon (the polygon buffered outward by 50m). A point inside several +overlapping buffers counts for each postcode -- the same multiplicity the +tree-density filter uses for features near more than one postcode. + +The metric is a raw annualised count ("incidents/year within 50m"); there is no +per-capita denominator. Outputs mirror the old LSOA transform's shape but are +keyed on ``postcode`` instead of ``LSOA code``: + +* ``crime_by_postcode.parquet`` -- ``postcode`` + ``"{type} (avg/yr)"`` columns. +* ``crime_by_postcode_by_year.parquet`` -- ``postcode`` + ``"{type} (by year)"`` + nested ``list[struct{year, count}]`` columns, with Serious/Minor rollups. + +Caveat: police.uk coordinates are snapped to a fixed set of anonymous "map +points", not true locations, and a share of rows have no coordinate at all +(dropped here). Spatial totals are therefore lower than, and fuzzier than, the +old LSOA-tagged counts -- by design, not a regression. +""" + +from __future__ import annotations + +import argparse +import re +from pathlib import Path + +import numpy as np +import polars as pl +import shapely +from pyproj import Transformer + +from pipeline.transform.crime import ( + MINOR_CRIME_TYPES, + SERIOUS_CRIME_TYPES, + find_street_crime_csvs, +) +from pipeline.transform.postcode_boundaries.loader import load_postcode_polygons + +# Serious types first so column order is stable and self-documenting. +ALL_CRIME_TYPES: tuple[str, ...] = SERIOUS_CRIME_TYPES + MINOR_CRIME_TYPES + +DEFAULT_BUFFER_M = 50.0 +MONTH_DIR_RE = re.compile(r"^\d{4}-\d{2}$") + +# Generous GB bounds; points outside fall in no English postcode anyway, but +# filtering first keeps the WGS84->BNG transform out of its undefined region. +LON_BOUNDS = (-9.5, 2.5) +LAT_BOUNDS = (49.0, 61.5) + +# Read CSVs in chunks of files to bound peak memory while keeping the STRtree +# query vectorised over a useful number of points. +_CSV_BATCH = 64 + + +def _month_calendar(csvs: list[Path]) -> tuple[list[int], dict[int, int], int]: + """Derive annualisation denominators from the monthly directory names. + + Each police.uk file lives under ``{crime_dir}/{YYYY-MM}/...`` and holds that + month's incidents, so the set of month directories is the set of observed + months. Returns the sorted distinct years, months-observed-per-year, and the + total month count (the avg/yr denominator). + """ + months = sorted( + {path.parent.name for path in csvs if MONTH_DIR_RE.fullmatch(path.parent.name)} + ) + if not months: + raise ValueError("No valid YYYY-MM month directories found among crime CSVs") + + months_in_year: dict[int, int] = {} + for month in months: + year = int(month[:4]) + months_in_year[year] = months_in_year.get(year, 0) + 1 + + years = sorted(months_in_year) + return years, months_in_year, len(months) + + +def _build_tree( + polygons: np.ndarray, buffer_m: float +) -> tuple[np.ndarray, shapely.STRtree]: + """Buffer postcode polygons outward by ``buffer_m`` and index them. + + Buffer index == postcode index. Geometries that fail to buffer are replaced + with an empty polygon so the index stays aligned; they simply never match. + """ + buffers = shapely.buffer(polygons, buffer_m, quad_segs=8) + broken = shapely.is_missing(buffers) | ~shapely.is_valid(buffers) + if broken.any(): + print(f" {int(broken.sum()):,} postcode buffers unusable; left empty") + buffers[broken] = shapely.from_wkt("POLYGON EMPTY") + return buffers, shapely.STRtree(buffers) + + +def _accumulate_counts( + csvs: list[Path], + tree: shapely.STRtree, + type_to_idx: dict[str, int], + year_to_idx: dict[int, int], + transformer: Transformer, + counts: np.ndarray, +) -> None: + """Stream the crime CSVs, counting points-in-buffer per (postcode, type, year).""" + schema = { + "Longitude": pl.Float64, + "Latitude": pl.Float64, + "Month": pl.Utf8, + "Crime type": pl.Utf8, + } + known_types = list(type_to_idx) + total_points = 0 + total_matches = 0 + total_dropped = 0 + + for start in range(0, len(csvs), _CSV_BATCH): + batch = csvs[start : start + _CSV_BATCH] + frame = ( + pl.scan_csv( + batch, + schema_overrides=schema, + ignore_errors=True, + ) + .select("Longitude", "Latitude", "Month", "Crime type") + .with_columns(pl.col("Month").str.slice(0, 4).cast(pl.Int32).alias("year")) + .filter( + pl.col("Longitude").is_not_null() + & pl.col("Latitude").is_not_null() + & pl.col("Longitude").is_between(*LON_BOUNDS) + & pl.col("Latitude").is_between(*LAT_BOUNDS) + & pl.col("Crime type").is_in(known_types) + & pl.col("year").is_in(list(year_to_idx)) + ) + .with_columns( + pl.col("Crime type") + .replace_strict(type_to_idx, return_dtype=pl.Int32) + .alias("tidx"), + pl.col("year") + .replace_strict(year_to_idx, return_dtype=pl.Int32) + .alias("yidx"), + ) + .select("Longitude", "Latitude", "tidx", "yidx") + .collect(engine="streaming") + ) + + rows_in = frame.height + if rows_in == 0: + continue + + lon = frame["Longitude"].to_numpy() + lat = frame["Latitude"].to_numpy() + tidx = frame["tidx"].to_numpy() + yidx = frame["yidx"].to_numpy() + + x, y = transformer.transform(lon, lat) + finite = np.isfinite(x) & np.isfinite(y) + total_dropped += int((~finite).sum()) + if not finite.any(): + continue + x, y, tidx, yidx = x[finite], y[finite], tidx[finite], yidx[finite] + total_points += x.size + + points = shapely.points(x, y) + point_index, postcode_index = tree.query(points, predicate="intersects") + if point_index.size: + np.add.at( + counts, + (postcode_index, tidx[point_index], yidx[point_index]), + 1, + ) + total_matches += point_index.size + + print( + f" files {start + len(batch):,}/{len(csvs):,}: " + f"{total_points:,} located points, {total_matches:,} postcode matches" + ) + + if total_dropped: + print(f"Dropped {total_dropped:,} points outside the BNG transform domain") + + +def _rollup_long( + long: pl.DataFrame, types: tuple[str, ...], rollup_name: str +) -> pl.DataFrame: + """Sum per-year annualised counts across ``types`` into a single rollup.""" + return ( + long.filter(pl.col("Crime type").is_in(list(types))) + .group_by("postcode", "year") + .agg(pl.col("count").sum().round(1).alias("count")) + .with_columns(pl.lit(rollup_name).alias("Crime type")) + .select("postcode", "Crime type", "year", "count") + ) + + +def _write_avg_yr( + postcodes: np.ndarray, + counts: np.ndarray, + valid_month_count: int, + output_path: Path, +) -> None: + """Write ``postcode`` + ``"{type} (avg/yr)"`` annualised totals.""" + totals = counts.sum(axis=2) # (n_postcodes, n_types) + avg = np.round(totals / valid_month_count * 12.0, 1).astype(np.float32) + + data: dict[str, np.ndarray] = {"postcode": postcodes} + for type_idx, name in enumerate(ALL_CRIME_TYPES): + data[f"{name} (avg/yr)"] = avg[:, type_idx] + + output_path.parent.mkdir(parents=True, exist_ok=True) + pl.DataFrame(data).write_parquet(output_path, compression="zstd") + print(f"Wrote postcode crime averages: {output_path}") + + +def _write_by_year( + postcodes: np.ndarray, + counts: np.ndarray, + years: list[int], + months_in_year: dict[int, int], + output_path: Path, +) -> None: + """Write nested ``"{type} (by year)"`` series plus Serious/Minor rollups.""" + months = np.array([months_in_year[year] for year in years], dtype=np.float64) + annual = np.round(counts.astype(np.float64) * 12.0 / months[None, None, :], 1) + + pc_i, ty_i, yr_i = np.nonzero(counts) + if pc_i.size == 0: + raise ValueError("No crime points matched any postcode buffer") + + type_names = np.array(ALL_CRIME_TYPES, dtype=object) + year_values = np.array(years, dtype=np.int32) + long = pl.DataFrame( + { + "postcode": postcodes[pc_i], + "Crime type": type_names[ty_i], + "year": year_values[yr_i], + "count": annual[pc_i, ty_i, yr_i].astype(np.float32), + } + ) + + serious = _rollup_long(long, SERIOUS_CRIME_TYPES, "Serious crime") + minor = _rollup_long(long, MINOR_CRIME_TYPES, "Minor crime") + combined = pl.concat([long, serious, minor]) + + by_type = ( + combined.sort("year") + .group_by("postcode", "Crime type") + .agg(pl.struct("year", "count").alias("series")) + ) + wide = by_type.pivot(on="Crime type", index="postcode", values="series") + type_cols = [c for c in wide.columns if c != "postcode"] + wide = wide.rename({col: f"{col} (by year)" for col in type_cols}) + + output_path.parent.mkdir(parents=True, exist_ok=True) + wide.write_parquet(output_path, compression="zstd") + print(f"Wrote postcode crime by-year series: {output_path} {wide.shape}") + + +def transform_crime_spatial( + crime_dir: Path, + boundaries_dir: Path, + output_path: Path, + by_year_output_path: Path, + buffer_m: float = DEFAULT_BUFFER_M, + max_postcodes: int | None = None, + max_files: int | None = None, +) -> None: + csvs, ignored_csv_count = find_street_crime_csvs(crime_dir) + if not csvs: + raise FileNotFoundError(f"No street crime CSV files found in {crime_dir}") + if max_files is not None: + csvs = csvs[:max_files] + + years, months_in_year, valid_month_count = _month_calendar(csvs) + print( + f"Found {len(csvs):,} street crime CSVs across {valid_month_count} months " + f"({years[0]}-{years[-1]})" + + (f" (ignored {ignored_csv_count} non-street CSVs)" if ignored_csv_count else "") + ) + + postcodes, polygons = load_postcode_polygons(boundaries_dir, max_postcodes) + print(f"Buffering {len(postcodes):,} postcode polygons by {buffer_m:g}m...") + _buffers, tree = _build_tree(polygons, buffer_m) + + type_to_idx = {name: idx for idx, name in enumerate(ALL_CRIME_TYPES)} + year_to_idx = {year: idx for idx, year in enumerate(years)} + counts = np.zeros((len(postcodes), len(ALL_CRIME_TYPES), len(years)), dtype=np.int32) + + transformer = Transformer.from_crs("EPSG:4326", "EPSG:27700", always_xy=True) + _accumulate_counts(csvs, tree, type_to_idx, year_to_idx, transformer, counts) + + _write_avg_yr(postcodes, counts, valid_month_count, output_path) + _write_by_year(postcodes, counts, years, months_in_year, by_year_output_path) + + +def main() -> None: + parser = argparse.ArgumentParser( + description="Count police.uk crime points within 50m of each postcode boundary" + ) + parser.add_argument( + "--input", + type=Path, + default=Path("property-data/crime"), + help="Directory containing police.uk street crime CSVs", + ) + parser.add_argument( + "--boundaries", + type=Path, + default=Path("property-data/postcode_boundaries/units"), + help="Directory of per-district postcode boundary GeoJSONs", + ) + parser.add_argument( + "--output", + type=Path, + required=True, + help="Output parquet: postcode + '{type} (avg/yr)' columns", + ) + parser.add_argument( + "--output-by-year", + type=Path, + required=True, + help="Output parquet: postcode + nested '{type} (by year)' columns", + ) + parser.add_argument( + "--buffer-m", + type=float, + default=DEFAULT_BUFFER_M, + help="Outward buffer (metres) added to each postcode boundary", + ) + parser.add_argument( + "--max-postcodes", + type=int, + default=None, + help="Testing only: process the first N postcodes", + ) + parser.add_argument( + "--max-files", + type=int, + default=None, + help="Testing only: process the first N monthly CSV files", + ) + args = parser.parse_args() + + if args.buffer_m <= 0: + raise SystemExit("--buffer-m must be greater than zero") + + transform_crime_spatial( + crime_dir=args.input, + boundaries_dir=args.boundaries, + output_path=args.output, + by_year_output_path=args.output_by_year, + buffer_m=args.buffer_m, + max_postcodes=args.max_postcodes, + max_files=args.max_files, + ) + + +if __name__ == "__main__": + main() diff --git a/pipeline/transform/join_epc_pp.py b/pipeline/transform/join_epc_pp.py index 7ceccce..ebc0c35 100644 --- a/pipeline/transform/join_epc_pp.py +++ b/pipeline/transform/join_epc_pp.py @@ -26,6 +26,7 @@ MIN_PRICE = 50_000 EPC_SOURCE_COLUMNS = [ "address", "postcode", + "uprn", "current_energy_rating", "potential_energy_rating", "property_type", @@ -57,6 +58,8 @@ def _select_epc_columns(raw: pl.LazyFrame) -> pl.LazyFrame: raw.select( _clean_string("address").alias("epc_address"), _clean_string("postcode").str.to_uppercase().alias("epc_postcode"), + # UPRN keys an exact listing->EPC join downstream (~99% populated). + _clean_string("uprn").alias("uprn"), _clean_string("current_energy_rating") .str.to_uppercase() .alias("current_energy_rating"), diff --git a/pipeline/transform/merge.py b/pipeline/transform/merge.py index 5dc21b0..2001140 100644 --- a/pipeline/transform/merge.py +++ b/pipeline/transform/merge.py @@ -48,7 +48,7 @@ _AREA_COLUMNS = [ "lon", # Runtime provenance for deciding whether missing coordinates are skippable. "ctry25cd", - # Keyed lookup for postcode-level side tables (e.g. crime time series). + # Join key for LSOA-level side tables (e.g. median age). "lsoa21", # Deprivation "Income Score", @@ -81,8 +81,6 @@ _AREA_COLUMNS = [ "Other crime (avg/yr)", "Serious crime (avg/yr)", "Minor crime (avg/yr)", - "Serious crime per 1k residents (avg/yr)", - "Minor crime per 1k residents (avg/yr)", # Amenities "Number of restaurants within 2km", "Number of grocery shops and supermarkets within 2km", @@ -742,16 +740,13 @@ _PROPERTY_TYPE_VALUES = [ "Other", ] _EPC_RATING_VALUES = ["A", "B", "C", "D", "E", "F", "G"] -_PROPERTY_MATCH_MIN_SCORE_WITH_NUMBERS = 82.0 -_PROPERTY_MATCH_MIN_SCORE_WITHOUT_NUMBERS = 96.0 -_PROPERTY_MATCH_MIN_ADDRESS_SCORE_WITH_NUMBERS = 82 -_PROPERTY_MATCH_MIN_ADDRESS_SCORE_WITHOUT_NUMBERS = 96 -_PROPERTY_MATCH_MIN_MARGIN = 4.0 -_DIRECT_EPC_MATCH_MIN_SCORE_WITH_NUMBERS = 82.0 -_DIRECT_EPC_MATCH_MIN_SCORE_WITHOUT_NUMBERS = 96.0 -_DIRECT_EPC_MATCH_MIN_MARGIN = 4.0 -_DIRECT_EPC_NEARBY_RADIUS_M = 500.0 -_DIRECT_EPC_NEAREST_POSTCODES = 40 +# Listings are matched to EPC certificates and Price-Paid properties first by +# UPRN (exact) and otherwise by fuzzy street-address similarity within the same +# postcode. A house number in the listing address is the strong disambiguator, +# so a numbered listing may match on a lower street-similarity score than a +# number-less one (which must match the street almost exactly to be trusted). +_LISTING_MATCH_MIN_SCORE_WITH_NUMBERS = 82 +_LISTING_MATCH_MIN_SCORE_WITHOUT_NUMBERS = 90 _DIRECT_EPC_COLUMNS: tuple[tuple[str, pl.DataType], ...] = ( ("_direct_epc_address", pl.Utf8), ("_direct_current_energy_rating", pl.Utf8), @@ -764,7 +759,7 @@ _DIRECT_EPC_COLUMNS: tuple[tuple[str, pl.DataType], ...] = ( ("_direct_was_council_house", pl.Utf8), ("_direct_epc_match_status", pl.Utf8), ("_direct_epc_match_score", pl.Float32), - ("_direct_epc_match_margin", pl.Float32), + ("_direct_epc_match_method", pl.Utf8), ) _DIRECT_EPC_RAW_COLUMN_MAP = { "epc_address": "_direct_epc_address", @@ -840,46 +835,6 @@ def _construction_year_expr(column: str = "construction_age_band") -> pl.Expr: ) -def _ratio_bonus( - left: float | int | None, right: float | int | None, pct: float, cap: float -) -> float: - if left is None or right is None: - return 0.0 - try: - left_f = float(left) - right_f = float(right) - except (TypeError, ValueError): - return 0.0 - if left_f <= 0 or right_f <= 0: - return 0.0 - rel = abs(left_f - right_f) / max(left_f, right_f) - if rel > pct: - return 0.0 - return cap * (1.0 - rel / pct) - - -def _rooms_bonus(left: int | None, right: int | None) -> float: - if left is None or right is None: - return 0.0 - try: - diff = abs(int(left) - int(right)) - except (TypeError, ValueError): - return 0.0 - if diff == 0: - return 4.0 - if diff == 1: - return 2.0 - return 0.0 - - -def _enum_bonus( - left: str | None, right: str | None, *, exact: float, mismatch: float -) -> float: - if not left or not right: - return 0.0 - return exact if left == right else mismatch - - def _address_score(query: str, candidate: str | None) -> int: if not candidate: return 0 @@ -893,6 +848,85 @@ def _has_number(address: str | None) -> bool: return bool(address and _NUMBER_RE.search(address)) +def _normalize_uprn(value: object) -> str | None: + """Canonical UPRN string (digits only) or None. + + UPRNs arrive as strings or ints from the scraper / EPC register; normalise + so a listing UPRN and an EPC/property UPRN compare equal regardless of dtype + or stray whitespace. A float (e.g. a NaN-bearing column read as Float) is + rejected unless it is an exact integer, so "123.0"/"1.5e11" can never be + silently mangled into a bogus all-digits key. + """ + if value is None: + return None + if isinstance(value, float): + if not value.is_integer(): + return None + value = int(value) + digits = re.sub(r"\D", "", str(value)) + return digits or None + + +def _best_listing_match( + listing_uprn: str | None, + query: str | None, + uprn_index: dict[str, dict], + bucket_candidates: list[dict], + addressed_fields: list[str], +) -> tuple[dict, float, str, str | None] | None: + """Pick the best candidate for a listing. + + Matching is, in order: (1) an exact UPRN equality against the global + ``uprn_index`` (postcode-independent, so it is robust even when the + listing's postcode is slightly off); (2) failing that, the highest + fuzzy street-address similarity within the listing's own postcode bucket. + No property-attribute heuristics are used — a house number in the listing + address gates the fuzzy match (`_numbers_compatible`) and lowers the score + threshold; a number-less address must match the street almost exactly. + + ``addressed_fields`` names the candidate columns to fuzzy-match against (a + candidate may carry both a register and an EPC address). Returns + ``(candidate, score, method, matched_field)`` or None. ``method`` is + "uprn" or "address"; ``matched_field`` is the winning address column (or + None for a UPRN match). + """ + if listing_uprn: + hit = uprn_index.get(listing_uprn) + if hit is not None: + return hit, 100.0, "uprn", None + + if not query: + return None + + listing_has_numbers = _has_number(query) + best: dict | None = None + best_score = 0 + best_field: str | None = None + for candidate in bucket_candidates: + for field in addressed_fields: + address = candidate.get(field) + if not address: + continue + if listing_has_numbers and not _numbers_compatible(query, address): + continue + score = _address_score(query, address) + if score > best_score: + best_score = score + best = candidate + best_field = field + + if best is None: + return None + threshold = ( + _LISTING_MATCH_MIN_SCORE_WITH_NUMBERS + if listing_has_numbers + else _LISTING_MATCH_MIN_SCORE_WITHOUT_NUMBERS + ) + if best_score < threshold: + return None + return best, float(best_score), "address", best_field + + def _load_listings_for_merge( listings_path: Path, arcgis_path: Path ) -> pl.DataFrame: @@ -908,6 +942,20 @@ def _load_listings_for_merge( raw = pl.scan_parquet(listings_path).with_row_index("_listing_idx") postcode_mapping = build_postcode_mapping(arcgis_path).lazy() + # UPRN is only present on scraped listings that carry it (Zoopla detail + # pages); tolerate its absence so older parquets and test fixtures still + # load. Digits-only so it compares equal to the EPC register's UPRN. + if "UPRN" in raw.collect_schema().names(): + uprn_digits = pl.col("UPRN").cast(pl.Utf8).str.replace_all(r"\D", "") + listing_uprn_expr = ( + pl.when(uprn_digits.str.len_chars() > 0) + .then(uprn_digits) + .otherwise(None) + .alias("_listing_uprn") + ) + else: + listing_uprn_expr = pl.lit(None, dtype=pl.Utf8).alias("_listing_uprn") + # Listings parquets occasionally carry Float NaNs (e.g. floor area). Polars # treats NaN as distinct from null and the downstream `latest_price / # total_floor_area` cast to Int32 explodes on a NaN, so we normalise floats @@ -936,12 +984,14 @@ def _load_listings_for_merge( "postcode" ), pl.col("Address per Property Register").alias("pp_address"), + listing_uprn_expr, *overlay, ) .select( "_listing_idx", "postcode", "pp_address", + "_listing_uprn", *[dst for _src, dst, _dt in _LISTING_OVERLAY_SOURCES], ) .collect(engine="streaming") @@ -972,7 +1022,6 @@ def _empty_direct_epc_matches() -> pl.DataFrame: def _load_direct_epc_candidates( epc_path: Path, - arcgis_path: Path, listing_outcodes: list[str], temp_dir: Path, ) -> pl.DataFrame: @@ -982,8 +1031,7 @@ def _load_direct_epc_candidates( "_direct_epc_match_postcode": pl.Utf8, "_direct_epc_outcode": pl.Utf8, "_direct_epc_canonical_property_type": pl.Utf8, - "_direct_epc_east": pl.Float64, - "_direct_epc_north": pl.Float64, + "_direct_epc_uprn": pl.Utf8, **{column: dtype for column, dtype in _DIRECT_EPC_COLUMNS if column.startswith("_direct_")}, } if not listing_outcodes: @@ -1016,12 +1064,6 @@ def _load_direct_epc_candidates( .with_columns(pl.lit("Yes").alias("_direct_was_council_house")) ) - arcgis = pl.scan_parquet(arcgis_path).select( - normalize_postcode_key(pl.col("pcds")).alias("_direct_epc_match_postcode"), - pl.col("east1m").alias("_direct_epc_east"), - pl.col("north1m").alias("_direct_epc_north"), - ) - return ( epc_base.sort("inspection_date", descending=True) .group_by("_direct_epc_match_address", "_direct_epc_match_postcode") @@ -1031,7 +1073,6 @@ def _load_direct_epc_candidates( on=["_direct_epc_match_address", "_direct_epc_match_postcode"], how="left", ) - .join(arcgis, on="_direct_epc_match_postcode", how="left") .with_columns( _canonical_epc_property_type_expr().alias( "_direct_epc_canonical_property_type" @@ -1046,6 +1087,7 @@ def _load_direct_epc_candidates( .otherwise(None) .alias("_direct_potential_energy_rating"), pl.col("epc_address").alias("_direct_epc_address"), + pl.col("uprn").alias("_direct_epc_uprn"), pl.col("total_floor_area").alias("_direct_total_floor_area"), pl.col("number_habitable_rooms").alias( "_direct_number_habitable_rooms" @@ -1066,8 +1108,7 @@ def _load_direct_epc_candidates( "_direct_epc_match_postcode", "_direct_epc_outcode", "_direct_epc_canonical_property_type", - "_direct_epc_east", - "_direct_epc_north", + "_direct_epc_uprn", "_direct_epc_address", "_direct_current_energy_rating", "_direct_potential_energy_rating", @@ -1083,7 +1124,14 @@ def _load_direct_epc_candidates( def _listing_match_frame(listings: pl.DataFrame) -> pl.DataFrame: - match = listings.with_columns( + """Add the normalised address/postcode/outcode keys used to match listings. + + Listings are matched to EPC certificates and properties by UPRN and by + fuzzy street address within their (now accurate, detail-page-sourced) + postcode — never by coordinate proximity — so no projected easting/northing + is computed here. `_listing_uprn` flows through from the loaded listings. + """ + return listings.with_columns( normalize_address_key(pl.col("pp_address")).alias("_listing_match_address"), normalize_postcode_key(pl.col("postcode")).alias("_listing_match_postcode"), ).with_columns( @@ -1092,21 +1140,6 @@ def _listing_match_frame(listings: pl.DataFrame) -> pl.DataFrame: .alias("_listing_outcode") ) - if match.is_empty(): - return match.with_columns( - pl.Series("_listing_east", [], dtype=pl.Float64), - pl.Series("_listing_north", [], dtype=pl.Float64), - ) - - transformer = Transformer.from_crs("EPSG:4326", "EPSG:27700", always_xy=True) - east, north = transformer.transform( - match["_actual_lon"].to_numpy(), match["_actual_lat"].to_numpy() - ) - return match.with_columns( - pl.Series("_listing_east", east, dtype=pl.Float64), - pl.Series("_listing_north", north, dtype=pl.Float64), - ) - def _optional_lazy_col( schema: pl.Schema, column: str, dtype: pl.DataType @@ -1122,8 +1155,7 @@ def _listing_property_match_schema() -> dict[str, pl.DataType]: "_matched_postcode": pl.Utf8, "_matched_pp_address": pl.Utf8, "_property_match_score": pl.Float32, - "_property_match_address_score": pl.Int32, - "_property_match_margin": pl.Float32, + "_property_match_method": pl.Utf8, "_property_match_field": pl.Utf8, } @@ -1139,11 +1171,8 @@ def _property_match_candidate_frame(wide: pl.LazyFrame) -> pl.DataFrame: pl.col("postcode").cast(pl.Utf8).alias("postcode"), pl.col("pp_address").cast(pl.Utf8).alias("pp_address"), _optional_lazy_col(schema, "epc_address", pl.Utf8), - _optional_lazy_col(schema, "pp_property_type", pl.Utf8), - _optional_lazy_col(schema, "duration", pl.Utf8), - _optional_lazy_col(schema, "total_floor_area", pl.Float64), - _optional_lazy_col(schema, "number_habitable_rooms", pl.Int16), - _optional_lazy_col(schema, "latest_price", pl.Int64), + # UPRN keys the exact match; present once epc_pp is rebuilt with it. + _optional_lazy_col(schema, "uprn", pl.Utf8), ) .with_row_index("_property_row") .with_columns( @@ -1167,110 +1196,52 @@ def _property_match_candidate_frame(wide: pl.LazyFrame) -> pl.DataFrame: ) -def _property_candidates_by_postcode( - candidates: pl.DataFrame, -) -> dict[str, list[dict]]: +def _index_candidates( + candidates: pl.DataFrame, postcode_key: str, uprn_key: str +) -> tuple[dict[str, list[dict]], dict[str, dict]]: + """Index candidate rows for matching, in a single pass over the frame. + + Returns ``(postcode_buckets, uprn_index)``. The postcode buckets drive the + fuzzy street-address match; the UPRN index drives the exact match and is + postcode-independent, so it still resolves when a listing's postcode is + slightly off. + """ buckets: dict[str, list[dict]] = {} + uprn_index: dict[str, dict] = {} for row in candidates.iter_rows(named=True): - postcode = row.get("_property_match_postcode") + postcode = row.get(postcode_key) if postcode: buckets.setdefault(postcode, []).append(row) - return buckets + uprn = _normalize_uprn(row.get(uprn_key)) + if uprn and uprn not in uprn_index: + uprn_index[uprn] = row + return buckets, uprn_index def _best_listing_property_candidate( - listing: dict, candidates: list[dict] + listing: dict, uprn_index: dict[str, dict], candidates: list[dict] ) -> dict | None: - query = listing.get("_listing_match_address") - if not query: - return None - - listing_has_numbers = _has_number(query) - scored: list[tuple[float, int, dict, str]] = [] - for candidate in candidates: - register_address = candidate.get("_property_match_address") - epc_address = candidate.get("_property_epc_match_address") - register_numbers_compatible = bool( - register_address and _numbers_compatible(query, register_address) - ) - epc_numbers_compatible = bool( - epc_address and _numbers_compatible(query, epc_address) - ) - if not (register_numbers_compatible or epc_numbers_compatible): - continue - - register_score = _address_score(query, register_address) - epc_score = _address_score(query, epc_address) - base_score = max(register_score, epc_score) - if base_score == 0: - continue - - score = float(base_score) - score += _enum_bonus( - listing.get("_actual_property_type"), - candidate.get("pp_property_type"), - exact=7.0, - mismatch=-8.0, - ) - score += _enum_bonus( - listing.get("_actual_leasehold_freehold"), - candidate.get("duration"), - exact=3.0, - mismatch=-3.0, - ) - score += _ratio_bonus( - listing.get("_actual_total_floor_area"), - candidate.get("total_floor_area"), - pct=0.15, - cap=8.0, - ) - score += _rooms_bonus( - listing.get("_actual_number_habitable_rooms"), - candidate.get("number_habitable_rooms"), - ) - score += _ratio_bonus( - listing.get("_actual_asking_price"), - candidate.get("latest_price"), - pct=0.25, - cap=3.0, - ) - matched_field = ( - "pp_address" if register_score >= epc_score else "epc_address" - ) - scored.append((score, base_score, candidate, matched_field)) - - if not scored: - return None - scored.sort(key=lambda item: item[0], reverse=True) - top = scored[0] - runner_up = scored[1][0] if len(scored) > 1 else None - margin = top[0] - runner_up if runner_up is not None else top[0] - score_threshold = ( - _PROPERTY_MATCH_MIN_SCORE_WITH_NUMBERS - if listing_has_numbers - else _PROPERTY_MATCH_MIN_SCORE_WITHOUT_NUMBERS + result = _best_listing_match( + listing.get("_listing_uprn"), + listing.get("_listing_match_address"), + uprn_index, + candidates, + ["_property_match_address", "_property_epc_match_address"], ) - address_threshold = ( - _PROPERTY_MATCH_MIN_ADDRESS_SCORE_WITH_NUMBERS - if listing_has_numbers - else _PROPERTY_MATCH_MIN_ADDRESS_SCORE_WITHOUT_NUMBERS - ) - if ( - top[0] < score_threshold - or top[1] < address_threshold - or margin < _PROPERTY_MATCH_MIN_MARGIN - ): + if result is None: return None - - candidate = top[2] + candidate, score, method, field = result + matched_field = { + "_property_match_address": "pp_address", + "_property_epc_match_address": "epc_address", + }.get(field, method) return { "_listing_idx": listing["_listing_idx"], "_matched_postcode": candidate.get("postcode"), "_matched_pp_address": candidate.get("pp_address"), - "_property_match_score": round(top[0], 1), - "_property_match_address_score": top[1], - "_property_match_margin": round(margin, 1), - "_property_match_field": top[3], + "_property_match_score": round(score, 1), + "_property_match_method": method, + "_property_match_field": matched_field, } @@ -1280,23 +1251,32 @@ def _match_listing_properties( if listing_matches.is_empty() or property_candidates.is_empty(): return _empty_listing_property_matches() - buckets = _property_candidates_by_postcode(property_candidates) + buckets, uprn_index = _index_candidates( + property_candidates, "_property_match_postcode", "uprn" + ) best_matches = [] for listing in listing_matches.iter_rows(named=True): postcode = listing.get("_listing_match_postcode") - if not postcode: - continue - match = _best_listing_property_candidate(listing, buckets.get(postcode, [])) + bucket = buckets.get(postcode, []) if postcode else [] + match = _best_listing_property_candidate(listing, uprn_index, bucket) if match is not None: best_matches.append(match) if not best_matches: return _empty_listing_property_matches() + # When two listings claim the same property, keep the most authoritative + # match: an exact UPRN match always wins over a fuzzy address match (both can + # score 100, so method must break the tie before score and listing index). matches = pl.DataFrame(best_matches, schema=_listing_property_match_schema()) return ( matches.sort( - ["_property_match_score", "_listing_idx"], descending=[True, False] + [ + pl.col("_property_match_method") == "uprn", + "_property_match_score", + "_listing_idx", + ], + descending=[True, True, False], ) .unique( ["_matched_postcode", "_matched_pp_address"], @@ -1307,133 +1287,19 @@ def _match_listing_properties( ) -def _epc_candidates_by_postcode(candidates: pl.DataFrame) -> dict[str, list[dict]]: - buckets: dict[str, list[dict]] = {} - for row in candidates.iter_rows(named=True): - postcode = row.get("_direct_epc_match_postcode") - if postcode: - buckets.setdefault(postcode, []).append(row) - return buckets - - -def _epc_postcode_tree( - candidates: pl.DataFrame, -) -> tuple[cKDTree | None, list[str]]: - postcode_points = ( - candidates.select( - "_direct_epc_match_postcode", - "_direct_epc_east", - "_direct_epc_north", - ) - .drop_nulls() - .filter( - pl.col("_direct_epc_east").is_finite() - & pl.col("_direct_epc_north").is_finite() - ) - .unique("_direct_epc_match_postcode") +def _best_direct_epc_candidate( + listing: dict, uprn_index: dict[str, dict], candidates: list[dict] +) -> dict | None: + result = _best_listing_match( + listing.get("_listing_uprn"), + listing.get("_listing_match_address"), + uprn_index, + candidates, + ["_direct_epc_match_address"], ) - if postcode_points.is_empty(): - return None, [] - coords = np.column_stack( - [ - postcode_points["_direct_epc_east"].to_numpy(), - postcode_points["_direct_epc_north"].to_numpy(), - ] - ) - return cKDTree(coords), postcode_points["_direct_epc_match_postcode"].to_list() - - -def _candidate_postcodes_for_listing( - listing: dict, - postcode_tree: cKDTree | None, - postcode_values: list[str], -) -> list[str]: - postcodes: list[str] = [] - exact = listing.get("_listing_match_postcode") - if exact: - postcodes.append(exact) - - if postcode_tree is None: - return postcodes - - east = listing.get("_listing_east") - north = listing.get("_listing_north") - try: - east_f = float(east) - north_f = float(north) - except (TypeError, ValueError): - return postcodes - if not np.isfinite(east_f) or not np.isfinite(north_f): - return postcodes - - k = min(_DIRECT_EPC_NEAREST_POSTCODES, len(postcode_values)) - distances, indices = postcode_tree.query( - [east_f, north_f], - k=k, - distance_upper_bound=_DIRECT_EPC_NEARBY_RADIUS_M, - ) - distances = np.atleast_1d(distances) - indices = np.atleast_1d(indices) - seen = set(postcodes) - for distance, idx in zip(distances, indices, strict=False): - if not np.isfinite(distance) or idx >= len(postcode_values): - continue - postcode = postcode_values[int(idx)] - if postcode not in seen: - postcodes.append(postcode) - seen.add(postcode) - return postcodes - - -def _best_direct_epc_candidate(listing: dict, candidates: list[dict]) -> dict | None: - query = listing.get("_listing_match_address") - if not query: + if result is None: return None - - listing_has_numbers = _has_number(query) - scored: list[tuple[float, int, dict]] = [] - for candidate in candidates: - address = candidate.get("_direct_epc_match_address") - if listing_has_numbers and not _numbers_compatible(query, address or ""): - continue - base_score = _address_score(query, address) - if base_score == 0: - continue - - score = float(base_score) - score += _enum_bonus( - listing.get("_actual_property_type"), - candidate.get("_direct_epc_canonical_property_type"), - exact=6.0, - mismatch=-6.0, - ) - score += _ratio_bonus( - listing.get("_actual_total_floor_area"), - candidate.get("_direct_total_floor_area"), - pct=0.12, - cap=8.0, - ) - score += _rooms_bonus( - listing.get("_actual_number_habitable_rooms"), - candidate.get("_direct_number_habitable_rooms"), - ) - scored.append((score, base_score, candidate)) - - if not scored: - return None - scored.sort(key=lambda item: item[0], reverse=True) - top = scored[0] - runner_up = scored[1][0] if len(scored) > 1 else None - margin = top[0] - runner_up if runner_up is not None else top[0] - threshold = ( - _DIRECT_EPC_MATCH_MIN_SCORE_WITH_NUMBERS - if listing_has_numbers - else _DIRECT_EPC_MATCH_MIN_SCORE_WITHOUT_NUMBERS - ) - if top[0] < threshold or margin < _DIRECT_EPC_MATCH_MIN_MARGIN: - return None - - candidate = top[2] + candidate, score, method, _field = result return { "_listing_idx": listing["_listing_idx"], "_direct_epc_address": candidate.get("_direct_epc_address"), @@ -1452,8 +1318,8 @@ def _best_direct_epc_candidate(listing: dict, candidates: list[dict]) -> dict | ), "_direct_was_council_house": candidate.get("_direct_was_council_house"), "_direct_epc_match_status": "matched", - "_direct_epc_match_score": round(top[0], 1), - "_direct_epc_match_margin": round(margin, 1), + "_direct_epc_match_score": round(score, 1), + "_direct_epc_match_method": method, } @@ -1463,25 +1329,14 @@ def _match_direct_epc( if listing_matches.is_empty() or epc_candidates.is_empty(): return _empty_direct_epc_matches() - buckets = _epc_candidates_by_postcode(epc_candidates) - postcode_tree, postcode_values = _epc_postcode_tree(epc_candidates) - + buckets, uprn_index = _index_candidates( + epc_candidates, "_direct_epc_match_postcode", "_direct_epc_uprn" + ) matches = [] for listing in listing_matches.iter_rows(named=True): - candidate_postcodes = _candidate_postcodes_for_listing( - listing, postcode_tree, postcode_values - ) - candidate_rows: list[dict] = [] - seen_rows: set[int] = set() - for postcode in candidate_postcodes: - for candidate in buckets.get(postcode, []): - row = candidate.get("_direct_epc_row") - if row in seen_rows: - continue - candidate_rows.append(candidate) - if row is not None: - seen_rows.add(row) - match = _best_direct_epc_candidate(listing, candidate_rows) + postcode = listing.get("_listing_match_postcode") + bucket = buckets.get(postcode, []) if postcode else [] + match = _best_direct_epc_candidate(listing, uprn_index, bucket) if match is not None: matches.append(match) @@ -1493,7 +1348,6 @@ def _match_direct_epc( def _enrich_listings_with_direct_epc( listings: pl.DataFrame, epc_path: Path | None, - arcgis_path: Path, ) -> pl.DataFrame: if epc_path is None: return _ensure_direct_epc_columns(listings) @@ -1513,7 +1367,7 @@ def _enrich_listings_with_direct_epc( prefix="direct_listing_epc_", dir=local_tmp_dir() ) as tmpdir: epc_candidates = _load_direct_epc_candidates( - epc_path, arcgis_path, listing_outcodes, Path(tmpdir) + epc_path, listing_outcodes, Path(tmpdir) ) print(f"Direct listing EPC candidates: {epc_candidates.height}") direct_matches = _match_direct_epc(listing_matches, epc_candidates) @@ -1604,7 +1458,7 @@ def _integrate_listings( """ listings = _load_listings_for_merge(listings_path, arcgis_path) print(f"Listings loaded: {listings.height}") - listings = _enrich_listings_with_direct_epc(listings, epc_path, arcgis_path) + listings = _enrich_listings_with_direct_epc(listings, epc_path) overlay_columns = [dst for _src, dst, _dt in _LISTING_OVERLAY_SOURCES] listing_attachment_columns = [ @@ -1660,6 +1514,14 @@ def _finalize_listings(df: pl.DataFrame) -> pl.DataFrame: """Project the post-rename wide frame down to enriched-listing rows.""" df = df.filter(pl.col(_LISTING_FLAG_COLUMN).is_not_null()) + # A matched listing's overlay attaches to every wide row sharing its + # (postcode, pp_address). The terminated-postcode remap can collapse several + # distinct wide rows onto one such key, which would otherwise emit one duplicate + # listing per collapsed row. Each listing matches exactly one (postcode, + # pp_address) and each seed row carries a unique URL, so keeping a single row per + # listing URL collapses only that fan-out and never merges distinct listings. + df = df.unique(subset=[_LISTING_FLAG_COLUMN], keep="first", maintain_order=True) + df = df.with_columns( pl.col("_actual_listing_url").alias("Listing URL"), pl.col("_actual_listing_date").alias("Listing date"), @@ -1750,7 +1612,6 @@ def _build( broadband_path: Path, conservation_areas_path: Path, rental_prices_path: Path, - lsoa_population_path: Path, median_age_path: Path, election_results_path: Path, tree_density_postcodes_path: Path | None = None, @@ -1881,8 +1742,10 @@ def _build( how="left", ) + # Crime is counted spatially per postcode (incidents within 50m of the + # postcode boundary), so it joins on postcode rather than LSOA. crime = pl.scan_parquet(crime_path) - wide = wide.join(crime, left_on="lsoa21", right_on="LSOA code", how="left") + wide = wide.join(crime, on="postcode", how="left") wide = wide.with_columns( pl.sum_horizontal( @@ -1905,17 +1768,6 @@ def _build( ).alias("minor_crime_avg_yr"), ) - lsoa_pop = pl.scan_parquet(lsoa_population_path) - wide = wide.join(lsoa_pop, on="lsoa21", how="left") - wide = wide.with_columns( - pl.when(pl.col("population") > 0) - .then((pl.col("serious_crime_avg_yr") / pl.col("population") * 1000).round(1)) - .alias("serious_crime_per_1k"), - pl.when(pl.col("population") > 0) - .then((pl.col("minor_crime_avg_yr") / pl.col("population") * 1000).round(1)) - .alias("minor_crime_per_1k"), - ).drop("population") - median_age = pl.scan_parquet(median_age_path) wide = wide.join(median_age, on="lsoa21", how="left") @@ -2082,8 +1934,6 @@ def _build( "max_download_speed": "Max available download speed (Mbps)", "serious_crime_avg_yr": "Serious crime (avg/yr)", "minor_crime_avg_yr": "Minor crime (avg/yr)", - "serious_crime_per_1k": "Serious crime per 1k residents (avg/yr)", - "minor_crime_per_1k": "Minor crime per 1k residents (avg/yr)", "mean_monthly_rent": "Estimated monthly rent", "floor_height": "Interior height (m)", "was_council_house": "Former council house", @@ -2189,12 +2039,6 @@ def main(): required=True, help="ONS rental prices by LA and bedroom count parquet file", ) - parser.add_argument( - "--lsoa-population", - type=Path, - required=True, - help="Census 2021 population by LSOA parquet file", - ) parser.add_argument( "--median-age", type=Path, @@ -2279,7 +2123,6 @@ def main(): broadband_path=args.broadband, conservation_areas_path=args.conservation_areas, rental_prices_path=args.rental_prices, - lsoa_population_path=args.lsoa_population, median_age_path=args.median_age, election_results_path=args.election_results, tree_density_postcodes_path=args.tree_density_postcodes, diff --git a/pipeline/transform/noise_overlay_tiles.py b/pipeline/transform/noise_overlay_tiles.py index 6ca8a40..b242fad 100644 --- a/pipeline/transform/noise_overlay_tiles.py +++ b/pipeline/transform/noise_overlay_tiles.py @@ -376,7 +376,7 @@ def main() -> None: "--pmtiles-bin", type=Path, default=Path("property-data/pmtiles") ) parser.add_argument("--pmtiles-version", default="1.22.3") - parser.add_argument("--min-zoom", type=int, default=13) + parser.add_argument("--min-zoom", type=int, default=12) parser.add_argument("--max-zoom", type=int, default=14) parser.add_argument("--tile-size", type=int, default=256) args = parser.parse_args() diff --git a/pipeline/transform/postcode_boundaries/__main__.py b/pipeline/transform/postcode_boundaries/__main__.py index 9e2450c..70a70dd 100644 --- a/pipeline/transform/postcode_boundaries/__main__.py +++ b/pipeline/transform/postcode_boundaries/__main__.py @@ -22,6 +22,12 @@ def main() -> None: description="Generate postcode boundary polygons from OA + INSPIRE + UPRN data" ) parser.add_argument("--uprn", type=Path, required=True, help="UPRN lookup parquet") + parser.add_argument( + "--arcgis", + type=Path, + default=None, + help="Optional ArcGIS postcode parquet used to remap terminated postcodes", + ) parser.add_argument( "--oa-boundaries", type=Path, required=True, help="OA boundaries GeoPackage" ) @@ -46,7 +52,7 @@ def main() -> None: print("=" * 60) oa_geoms = load_oa_boundaries(args.oa_boundaries) - uprn_df, uprn_offsets = load_uprns(args.uprn) + uprn_df, uprn_offsets = load_uprns(args.uprn, args.arcgis) # Phase 2: Parse/load INSPIRE print() diff --git a/pipeline/transform/postcode_boundaries/loader.py b/pipeline/transform/postcode_boundaries/loader.py new file mode 100644 index 0000000..c495fac --- /dev/null +++ b/pipeline/transform/postcode_boundaries/loader.py @@ -0,0 +1,105 @@ +"""Load per-district postcode boundary GeoJSONs as EPSG:27700 polygons. + +The postcode-boundary pipeline (:mod:`output`) writes one WGS84 GeoJSON per +postcode district under ``units/{district}.geojson``, each feature carrying a +``postcodes`` (full unit string, e.g. "AL1 1AG") property. Spatial transforms +that test points against postcode geometry want those polygons back in British +National Grid (EPSG:27700) so buffers/distances are in metres. + +:func:`load_postcode_polygons` reads the files, reprojects WGS84→27700, repairs +invalid rings, and returns parallel ``(postcodes, polygons)`` arrays sorted by +postcode so callers can use the array index as a stable postcode id -- the same +"buffer index == postcode index" convention used by ``tree_density``. +""" + +from __future__ import annotations + +import json +from pathlib import Path + +import numpy as np +import shapely +from pyproj import Transformer + + +def _read_district( + path: Path, transformer: Transformer +) -> tuple[np.ndarray, np.ndarray]: + """Return (postcodes, polygons_27700) for one district GeoJSON.""" + with path.open() as file: + collection = json.load(file) + + features = collection.get("features", []) + if not features: + return np.empty(0, dtype=object), np.empty(0, dtype=object) + + postcodes = np.array( + [feature["properties"]["postcodes"] for feature in features], dtype=object + ) + geom_json = np.array( + [json.dumps(feature["geometry"]) for feature in features], dtype=object + ) + geoms = shapely.from_geojson(geom_json) + + # Reproject every vertex in a single pyproj call, then rebuild the polygons. + coords = shapely.get_coordinates(geoms) + if coords.size: + x, y = transformer.transform(coords[:, 0], coords[:, 1]) + geoms = shapely.set_coordinates(geoms, np.column_stack([x, y])) + + invalid = ~shapely.is_valid(geoms) + if invalid.any(): + geoms[invalid] = shapely.make_valid(geoms[invalid]) + + return postcodes, geoms + + +def load_postcode_polygons( + units_dir: Path, max_postcodes: int | None = None +) -> tuple[np.ndarray, np.ndarray]: + """Load all postcode polygons under ``units_dir`` reprojected to EPSG:27700. + + Returns ``(postcodes, polygons)`` parallel object arrays sorted by postcode. + ``max_postcodes`` (testing) keeps only the lexicographically-first N + postcodes, reading just enough district files to reach the cap. + """ + units_dir = Path(units_dir) + files = sorted(units_dir.glob("*.geojson")) + if not files: + raise FileNotFoundError(f"No postcode-boundary GeoJSONs found in {units_dir}") + + transformer = Transformer.from_crs("EPSG:4326", "EPSG:27700", always_xy=True) + postcode_chunks: list[np.ndarray] = [] + geom_chunks: list[np.ndarray] = [] + total = 0 + for path in files: + postcodes, geoms = _read_district(path, transformer) + if len(postcodes) == 0: + continue + postcode_chunks.append(postcodes) + geom_chunks.append(geoms) + total += len(postcodes) + if max_postcodes is not None and total >= max_postcodes: + break + + if not postcode_chunks: + raise ValueError(f"No postcode features found in {units_dir}") + + postcodes = np.concatenate(postcode_chunks) + geoms = np.concatenate(geom_chunks) + + # Stable postcode order makes "index == postcode id" deterministic; dedupe + # defensively (a postcode lives in exactly one district file). + order = np.argsort(postcodes, kind="stable") + postcodes = postcodes[order] + geoms = geoms[order] + _, first = np.unique(postcodes, return_index=True) + postcodes = postcodes[first] + geoms = geoms[first] + + if max_postcodes is not None and len(postcodes) > max_postcodes: + postcodes = postcodes[:max_postcodes] + geoms = geoms[:max_postcodes] + + print(f"Loaded {len(postcodes):,} postcode polygons from {units_dir}") + return postcodes, geoms diff --git a/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py b/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py index 99df1ce..7d83b80 100644 --- a/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py +++ b/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py @@ -121,6 +121,50 @@ class TestWhitespacePostcodes: loaded_df, _ = load_uprns(path) assert len(loaded_df) == 0 + def test_non_english_oas_excluded(self, tmp_path): + df = pl.DataFrame( + { + "GRIDGB1E": [500010, 300010], + "GRIDGB1N": [180010, 220010], + "PCDS": ["AA1 1AA", "CF1 1AA"], + "OA21CD": ["E00000001", "W00000001"], + } + ) + path = tmp_path / "uprn.parquet" + df.write_parquet(path) + + loaded_df, offsets = load_uprns(path) + + assert set(offsets) == {"E00000001"} + assert loaded_df["PCDS"].to_list() == ["AA1 1AA"] + + def test_terminated_postcodes_are_remapped(self, tmp_path): + uprns = pl.DataFrame( + { + "GRIDGB1E": [500010], + "GRIDGB1N": [180010], + "PCDS": ["aa1 1aa"], + "OA21CD": ["E00000001"], + } + ) + uprn_path = tmp_path / "uprn.parquet" + uprns.write_parquet(uprn_path) + arcgis = pl.DataFrame( + { + "pcds": ["AA1 1AA", "AA1 1AB"], + "east1m": [500010, 500030], + "north1m": [180010, 180020], + "doterm": ["2020-01-01", None], + "ctry25cd": ["E92000001", "E92000001"], + } + ) + arcgis_path = tmp_path / "arcgis.parquet" + arcgis.write_parquet(arcgis_path) + + loaded_df, _offsets = load_uprns(uprn_path, arcgis_path) + + assert loaded_df["PCDS"].to_list() == ["AA1 1AB"] + # --------------------------------------------------------------------------- # Bug 3: Voronoi deduplication is first-seen-wins diff --git a/pipeline/transform/postcode_boundaries/uprn.py b/pipeline/transform/postcode_boundaries/uprn.py index a1f4bdc..d4c7557 100644 --- a/pipeline/transform/postcode_boundaries/uprn.py +++ b/pipeline/transform/postcode_boundaries/uprn.py @@ -4,11 +4,18 @@ import numpy as np import polars as pl from pipeline.local_temp import local_tmp_dir +from pipeline.utils.postcode_mapping import build_postcode_mapping from .memory import release_memory -def load_uprns(uprn_path: Path) -> tuple[pl.DataFrame, dict[str, tuple[int, int]]]: +def _canonical_postcode_expr(name: str) -> pl.Expr: + return pl.col(name).str.strip_chars().str.to_uppercase() + + +def load_uprns( + uprn_path: Path, arcgis_path: Path | None = None +) -> tuple[pl.DataFrame, dict[str, tuple[int, int]]]: """Load UPRNs as a sorted polars DataFrame with OA offset lookup. Returns (df, offsets) where offsets[oa_code] = (start_row, end_row). @@ -17,29 +24,46 @@ def load_uprns(uprn_path: Path) -> tuple[pl.DataFrame, dict[str, tuple[int, int] import tempfile print("Loading UPRN lookup...") + mapping = None + if arcgis_path is not None: + mapping = ( + build_postcode_mapping(arcgis_path) + .with_columns( + _canonical_postcode_expr("old_postcode").alias("old_postcode"), + _canonical_postcode_expr("new_postcode").alias("new_postcode"), + ) + .unique("old_postcode") + ) # Sort via streaming sink to avoid polars doubling memory during in-memory sort with tempfile.NamedTemporaryFile( suffix=".parquet", delete=False, dir=local_tmp_dir() ) as tmp: tmp_path = Path(tmp.name) - ( + uprns = ( pl.scan_parquet(uprn_path) .select("GRIDGB1E", "GRIDGB1N", "PCDS", "OA21CD") - .filter(~pl.col("OA21CD").str.starts_with("S")) + .filter(pl.col("OA21CD").str.starts_with("E")) .filter(pl.col("GRIDGB1E").is_not_null() & pl.col("GRIDGB1N").is_not_null()) - .with_columns(pl.col("PCDS").str.strip_chars()) + .with_columns(_canonical_postcode_expr("PCDS").alias("PCDS")) .filter(pl.col("PCDS").is_not_null() & (pl.col("PCDS") != "")) - .sort("OA21CD") - .sink_parquet(tmp_path) ) + + if mapping is not None and mapping.height > 0: + uprns = ( + uprns.join(mapping.lazy(), left_on="PCDS", right_on="old_postcode", how="left") + .with_columns(pl.coalesce("new_postcode", "PCDS").alias("PCDS")) + .select("GRIDGB1E", "GRIDGB1N", "PCDS", "OA21CD") + ) + + uprns.sort("OA21CD").sink_parquet(tmp_path) release_memory() # Read the sorted data — only one copy in memory (~2GB) df = pl.read_parquet(tmp_path) tmp_path.unlink() n = len(df) - print(f" Loaded {n:,} UPRNs (England & Wales)") + print(f" Loaded {n:,} UPRNs (England)") # Compute OA group offsets using polars (avoids 37M Python string creation) boundary_df = ( diff --git a/pipeline/transform/property_border_tiles.py b/pipeline/transform/property_border_tiles.py new file mode 100644 index 0000000..3ed764d --- /dev/null +++ b/pipeline/transform/property_border_tiles.py @@ -0,0 +1,138 @@ +"""Build PMTiles polygon tiles for the INSPIRE property-border overlay. + +Reads the HM Land Registry INSPIRE Index Polygons (per-local-authority GML ZIPs +in EPSG:27700), reprojects each parcel to WGS84, and tiles the outlines with +tippecanoe. The dashboard serves the resulting archive through +``/api/overlays/property-borders`` and renders it as thin outlines only at the +postcode zoom level. + +The same ZIPs are already downloaded for postcode-boundary generation; this +target re-uses :func:`parse_inspire_zip` to stay self-contained and is wired to +the ``$(INSPIRE_STAMP)`` make dependency rather than the boundary cache. + +Data: HM Land Registry INSPIRE Index Polygons, Open Government Licence v3.0. +Boundaries are indicative "general boundaries", not the legal extent of title. +""" + +from __future__ import annotations + +import argparse +import shutil +import subprocess +import tempfile +from pathlib import Path + +import numpy as np +import shapely +from pyproj import Transformer +from shapely.geometry import Polygon +from tqdm import tqdm + +from pipeline.local_temp import local_tmp_dir +from pipeline.transform.postcode_boundaries.inspire import parse_inspire_zip + + +def _require_tippecanoe() -> str: + executable = shutil.which("tippecanoe") + if executable is None: + raise RuntimeError( + "tippecanoe is required to build property border PMTiles. " + "Install tippecanoe and rerun this target." + ) + return executable + + +def _write_property_geojsonseq(inspire_dir: Path, output_path: Path) -> int: + """Stream INSPIRE parcels to a WGS84 GeoJSONSeq file, one feature per line. + + Features carry no properties — the overlay only draws outlines, so dropping + attributes keeps the tiles as small as possible. Reprojection and GeoJSON + encoding are vectorised per ZIP (one local authority) to bound memory while + staying in shapely's C path. + """ + to_wgs84 = Transformer.from_crs("EPSG:27700", "EPSG:4326", always_xy=True) + zip_files = sorted(inspire_dir.glob("*.zip")) + if not zip_files: + raise RuntimeError(f"No INSPIRE ZIP files found in {inspire_dir}") + + feature_count = 0 + with output_path.open("w") as file: + for zip_path in tqdm(zip_files, desc="INSPIRE ZIPs", unit="file"): + rings = parse_inspire_zip(zip_path) # list of Nx2 (easting, northing) + if not rings: + continue + + geoms = np.array([Polygon(coords) for coords in rings], dtype=object) + # interleaved=False → transform(x, y) called once with full arrays. + geoms = shapely.transform(geoms, to_wgs84.transform, interleaved=False) + + for geometry_json in shapely.to_geojson(geoms): + file.write('{"type":"Feature","properties":{},"geometry":') + file.write(geometry_json) + file.write("}\n") + feature_count += 1 + + return feature_count + + +def build_property_border_tiles( + inspire_dir: Path, + output_path: Path, + min_zoom: int, + max_zoom: int, +) -> None: + tippecanoe = _require_tippecanoe() + output_path.parent.mkdir(parents=True, exist_ok=True) + + with tempfile.TemporaryDirectory(dir=local_tmp_dir()) as tmp: + ndjson_path = Path(tmp) / "property_borders.geojsonseq" + feature_count = _write_property_geojsonseq(inspire_dir, ndjson_path) + print(f"Writing {feature_count:,} INSPIRE parcel polygons") + + subprocess.run( + [ + tippecanoe, + "--force", + "--output", + str(output_path), + "--layer", + "property_borders", + "--minimum-zoom", + str(min_zoom), + "--maximum-zoom", + str(max_zoom), + # Borders are only meaningful at street level; thin the densest + # tiles at low zoom but keep full geometry at max zoom. + "--drop-smallest-as-needed", + "--simplify-only-low-zooms", + "--extend-zooms-if-still-dropping", + "--temporary-directory", + tmp, + str(ndjson_path), + ], + check=True, + ) + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "--inspire", type=Path, required=True, help="INSPIRE ZIP directory" + ) + parser.add_argument( + "--output", type=Path, required=True, help="Output .pmtiles path" + ) + parser.add_argument("--min-zoom", type=int, default=12) + parser.add_argument("--max-zoom", type=int, default=16) + args = parser.parse_args() + + build_property_border_tiles( + inspire_dir=args.inspire, + output_path=args.output, + min_zoom=args.min_zoom, + max_zoom=args.max_zoom, + ) + + +if __name__ == "__main__": + main() diff --git a/pipeline/transform/test_crime_spatial.py b/pipeline/transform/test_crime_spatial.py new file mode 100644 index 0000000..b180008 --- /dev/null +++ b/pipeline/transform/test_crime_spatial.py @@ -0,0 +1,147 @@ +import json + +import polars as pl +from pyproj import Transformer + +from pipeline.transform.crime_spatial import transform_crime_spatial + +_TO_WGS84 = Transformer.from_crs("EPSG:27700", "EPSG:4326", always_xy=True) + +_CSV_HEADER = ( + "Crime ID,Month,Reported by,Falls within,Longitude,Latitude,Location," + "LSOA code,LSOA name,Crime type,Last outcome category,Context" +) + + +def _bng_to_wgs84(x: float, y: float) -> tuple[float, float]: + lon, lat = _TO_WGS84.transform(x, y) + return lon, lat + + +def _square_feature(postcode: str, x0: float, y0: float, x1: float, y1: float) -> dict: + ring = [(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)] + coords = [list(_bng_to_wgs84(x, y)) for x, y in ring] + return { + "type": "Feature", + "properties": {"postcodes": postcode, "mapit_code": postcode.replace(" ", "")}, + "geometry": {"type": "Polygon", "coordinates": [coords]}, + } + + +def _write_boundaries(units_dir, features_by_district: dict[str, list[dict]]) -> None: + units_dir.mkdir(parents=True) + for district, features in features_by_district.items(): + collection = {"type": "FeatureCollection", "features": features} + (units_dir / f"{district}.geojson").write_text(json.dumps(collection)) + + +def _crime_row(month: str, x, y, crime_type: str) -> str: + if x is None or y is None: + lon, lat = "", "" + else: + lon, lat = _bng_to_wgs84(x, y) + return f",{month},F,F,{lon},{lat},On or near X,E01000001,L,{crime_type},U," + + +def _write_month(crime_dir, month: str, rows: list[str]) -> None: + month_dir = crime_dir / month + month_dir.mkdir(parents=True) + body = "\n".join([_CSV_HEADER, *rows]) + "\n" + (month_dir / f"{month}-test-force-street.csv").write_text(body) + + +def test_buffer_overlap_counts_for_each_postcode(tmp_path): + units = tmp_path / "units" + # A and B sit 70m apart; their +50m buffers overlap in x in [1030, 1060]. + _write_boundaries( + units, + { + "AB1": [ + _square_feature("AB1 1AA", 1000, 1000, 1010, 1010), + _square_feature("AB1 1AB", 1080, 1000, 1090, 1010), + _square_feature("AB1 1AC", 5000, 5000, 5010, 5010), + ] + }, + ) + + crime = tmp_path / "crime" + _write_month( + crime, + "2024-01", + [ + # In the overlap: 35m east of A, 35m west of B -> counts for both. + _crime_row("2024-01", 1045, 1005, "Burglary"), + # 49m east of C's edge -> inside C's buffer. + _crime_row("2024-01", 5059, 5005, "Robbery"), + # 51m east of C's edge -> outside every buffer. + _crime_row("2024-01", 5061, 5005, "Robbery"), + # No coordinate -> dropped entirely. + _crime_row("2024-01", None, None, "Anti-social behaviour"), + ], + ) + + output = tmp_path / "crime_by_postcode.parquet" + by_year = tmp_path / "crime_by_postcode_by_year.parquet" + transform_crime_spatial(crime, units, output, by_year) + + rows = { + r["postcode"]: r + for r in pl.read_parquet(output).to_dicts() + } + # Single month -> annualised x12. + assert rows["AB1 1AA"]["Burglary (avg/yr)"] == 12.0 + assert rows["AB1 1AB"]["Burglary (avg/yr)"] == 12.0 + assert rows["AB1 1AA"]["Robbery (avg/yr)"] == 0.0 + # Only the 49m robbery counts for C; the 51m one and the blank row do not. + assert rows["AB1 1AC"]["Robbery (avg/yr)"] == 12.0 + assert rows["AB1 1AC"]["Burglary (avg/yr)"] == 0.0 + # Anti-social behaviour had no coordinate -> nobody gets it. + assert all(r["Anti-social behaviour (avg/yr)"] == 0.0 for r in rows.values()) + + +def test_by_year_annualises_and_rolls_up(tmp_path): + units = tmp_path / "units" + _write_boundaries( + units, {"AB1": [_square_feature("AB1 1AA", 1000, 1000, 1010, 1010)]} + ) + + crime = tmp_path / "crime" + # Point at the centre of AB1 1AA, well inside its buffer. + _write_month( + crime, + "2023-01", + [ + _crime_row("2023-01", 1005, 1005, "Burglary"), + _crime_row("2023-01", 1005, 1005, "Robbery"), + ], + ) + _write_month(crime, "2024-01", [_crime_row("2024-01", 1005, 1005, "Burglary")]) + _write_month( + crime, + "2024-02", + [ + _crime_row("2024-02", 1005, 1005, "Burglary"), + _crime_row("2024-02", 1005, 1005, "Anti-social behaviour"), + ], + ) + + output = tmp_path / "crime_by_postcode.parquet" + by_year = tmp_path / "crime_by_postcode_by_year.parquet" + transform_crime_spatial(crime, units, output, by_year) + + by_year_df = pl.read_parquet(by_year) + assert by_year_df.height == 1 + cols = set(by_year_df.columns) + assert {"Burglary (by year)", "Serious crime (by year)", "Minor crime (by year)"} <= cols + + row = by_year_df.row(0, named=True) + burglary = sorted(row["Burglary (by year)"], key=lambda r: r["year"]) + # 2023: 1 burglary in 1 month -> 12/yr; 2024: 2 in 2 months -> 12/yr. + assert burglary == [ + {"year": 2023, "count": 12.0}, + {"year": 2024, "count": 12.0}, + ] + serious = {p["year"]: p["count"] for p in row["Serious crime (by year)"]} + # 2023 serious = Burglary(12) + Robbery(12) = 24; 2024 = Burglary(12). + assert serious[2023] == 24.0 + assert serious[2024] == 12.0 diff --git a/pipeline/transform/test_join_epc_pp.py b/pipeline/transform/test_join_epc_pp.py index f4a52b3..67c0752 100644 --- a/pipeline/transform/test_join_epc_pp.py +++ b/pipeline/transform/test_join_epc_pp.py @@ -24,6 +24,7 @@ def _row(**overrides: str) -> dict[str, str]: row = { "address": "1 Example Street", "postcode": " aa1 1aa ", + "uprn": "100012345678", "current_energy_rating": "c", "potential_energy_rating": "b", "property_type": "House", @@ -52,6 +53,7 @@ def test_scan_epc_certificates_supports_legacy_uppercase_csv(tmp_path: Path): { "epc_address": "1 Example Street", "epc_postcode": "AA1 1AA", + "uprn": "100012345678", "current_energy_rating": "C", "potential_energy_rating": "B", "epc_property_type": "House", diff --git a/pipeline/transform/test_merge.py b/pipeline/transform/test_merge.py index 2597730..702c425 100644 --- a/pipeline/transform/test_merge.py +++ b/pipeline/transform/test_merge.py @@ -15,6 +15,8 @@ from pipeline.transform.merge import ( _finalize_listings, _integrate_listings, _match_direct_epc, + _match_listing_properties, + _normalize_uprn, _is_dynamic_poi_metric_column, _less_deprived_percentile_expr, _load_conservation_area_geometries, @@ -68,6 +70,15 @@ def test_conservation_area_feature_is_area_level() -> None: assert CONSERVATION_AREA_FEATURE in _AREA_COLUMNS +def test_crime_columns_are_spatial_counts_not_per_capita() -> None: + # Crime is now a raw spatial count per postcode; the per-1k-residents + # variants were dropped along with the LSOA population denominator. + assert "Serious crime (avg/yr)" in _AREA_COLUMNS + assert "Minor crime (avg/yr)" in _AREA_COLUMNS + assert "Serious crime per 1k residents (avg/yr)" not in _AREA_COLUMNS + assert "Minor crime per 1k residents (avg/yr)" not in _AREA_COLUMNS + + def test_listed_building_feature_is_property_level() -> None: assert LISTED_BUILDING_FEATURE not in _AREA_COLUMNS @@ -471,71 +482,166 @@ def test_build_unmatched_listing_seed_rows_uses_direct_epc_fallbacks( assert seed["was_council_house"].to_list() == ["No"] -def test_match_direct_epc_considers_nearby_postcodes() -> None: - listing_matches = pl.DataFrame( - { - "_listing_idx": [0], - "_listing_match_address": ["1 EXAMPLE ROAD"], - "_listing_match_postcode": ["AA11AA"], - "_listing_east": [1000.0], - "_listing_north": [1000.0], - "_actual_property_type": ["Terraced"], - "_actual_total_floor_area": [100.0], - "_actual_number_habitable_rooms": [4], - }, - schema={ - "_listing_idx": pl.UInt32, - "_listing_match_address": pl.Utf8, - "_listing_match_postcode": pl.Utf8, - "_listing_east": pl.Float64, - "_listing_north": pl.Float64, - "_actual_property_type": pl.Utf8, - "_actual_total_floor_area": pl.Float64, - "_actual_number_habitable_rooms": pl.Int16, - }, - ) - epc_candidates = pl.DataFrame( - { - "_direct_epc_row": [0], - "_direct_epc_match_address": ["1 EXAMPLE ROAD"], - "_direct_epc_match_postcode": ["BB11BB"], - "_direct_epc_east": [1020.0], - "_direct_epc_north": [1010.0], - "_direct_epc_canonical_property_type": ["Terraced"], - "_direct_epc_address": ["1, Example Road"], - "_direct_current_energy_rating": ["C"], - "_direct_potential_energy_rating": ["B"], - "_direct_total_floor_area": [101.0], - "_direct_number_habitable_rooms": [4], - "_direct_floor_height": [2.5], - "_direct_construction_age_band": [1930], - "_direct_is_construction_date_approximate": [1], - "_direct_was_council_house": ["No"], - }, - schema={ - "_direct_epc_row": pl.UInt32, - "_direct_epc_match_address": pl.Utf8, - "_direct_epc_match_postcode": pl.Utf8, - "_direct_epc_east": pl.Float64, - "_direct_epc_north": pl.Float64, - "_direct_epc_canonical_property_type": pl.Utf8, - "_direct_epc_address": pl.Utf8, - "_direct_current_energy_rating": pl.Utf8, - "_direct_potential_energy_rating": pl.Utf8, - "_direct_total_floor_area": pl.Float64, - "_direct_number_habitable_rooms": pl.Int16, - "_direct_floor_height": pl.Float64, - "_direct_construction_age_band": pl.UInt16, - "_direct_is_construction_date_approximate": pl.UInt8, - "_direct_was_council_house": pl.Utf8, - }, +_DIRECT_EPC_CANDIDATE_SCHEMA = { + "_direct_epc_row": pl.UInt32, + "_direct_epc_match_address": pl.Utf8, + "_direct_epc_match_postcode": pl.Utf8, + "_direct_epc_outcode": pl.Utf8, + "_direct_epc_canonical_property_type": pl.Utf8, + "_direct_epc_uprn": pl.Utf8, + "_direct_epc_address": pl.Utf8, + "_direct_current_energy_rating": pl.Utf8, + "_direct_potential_energy_rating": pl.Utf8, + "_direct_total_floor_area": pl.Float64, + "_direct_number_habitable_rooms": pl.Int16, + "_direct_floor_height": pl.Float64, + "_direct_construction_age_band": pl.UInt16, + "_direct_is_construction_date_approximate": pl.UInt8, + "_direct_was_council_house": pl.Utf8, +} + +_LISTING_MATCH_SCHEMA = { + "_listing_idx": pl.UInt32, + "_listing_match_address": pl.Utf8, + "_listing_match_postcode": pl.Utf8, + "_listing_uprn": pl.Utf8, +} + + +def _direct_epc_candidates(rows: list[dict]) -> pl.DataFrame: + base = { + "_direct_epc_row": 0, + "_direct_epc_match_address": "1 EXAMPLE ROAD", + "_direct_epc_match_postcode": "AA11AA", + "_direct_epc_outcode": "AA1", + "_direct_epc_canonical_property_type": "Terraced", + "_direct_epc_uprn": None, + "_direct_epc_address": "1, Example Road", + "_direct_current_energy_rating": "C", + "_direct_potential_energy_rating": "B", + "_direct_total_floor_area": 101.0, + "_direct_number_habitable_rooms": 4, + "_direct_floor_height": 2.5, + "_direct_construction_age_band": 1930, + "_direct_is_construction_date_approximate": 1, + "_direct_was_council_house": "No", + } + return pl.DataFrame( + [{**base, **row} for row in rows], schema=_DIRECT_EPC_CANDIDATE_SCHEMA ) - matches = _match_direct_epc(listing_matches, epc_candidates) + +def _listing_matches(rows: list[dict]) -> pl.DataFrame: + base = { + "_listing_idx": 0, + "_listing_match_address": "1 EXAMPLE ROAD", + "_listing_match_postcode": "AA11AA", + "_listing_uprn": None, + } + return pl.DataFrame([{**base, **row} for row in rows], schema=_LISTING_MATCH_SCHEMA) + + +def test_match_direct_epc_matches_by_uprn_across_postcodes() -> None: + # UPRN is matched globally (not within a postcode bucket), so a listing + # whose detail-page postcode is slightly off still resolves to the right + # EPC certificate by its UPRN. + matches = _match_direct_epc( + _listing_matches( + [{"_listing_uprn": "100000000001", "_listing_match_postcode": "ZZ99ZZ"}] + ), + _direct_epc_candidates( + [{"_direct_epc_uprn": "100000000001", "_direct_epc_match_postcode": "AA11AA"}] + ), + ) assert matches.height == 1 - assert matches["_listing_idx"].to_list() == [0] assert matches["_direct_epc_address"].to_list() == ["1, Example Road"] + assert matches["_direct_epc_match_method"].to_list() == ["uprn"] + + +def test_match_direct_epc_matches_by_address_in_same_postcode() -> None: + matches = _match_direct_epc( + _listing_matches([{"_listing_match_address": "1 EXAMPLE ROAD"}]), + _direct_epc_candidates([{"_direct_epc_match_address": "1 EXAMPLE ROAD"}]), + ) + + assert matches.height == 1 + assert matches["_direct_epc_address"].to_list() == ["1, Example Road"] + assert matches["_direct_epc_match_method"].to_list() == ["address"] + + +def test_normalize_uprn_handles_types_and_floats() -> None: + assert _normalize_uprn(None) is None + assert _normalize_uprn("") is None + assert _normalize_uprn(" 100012345678 ") == "100012345678" + assert _normalize_uprn(100012345678) == "100012345678" + # An integral float normalises to its digits, NOT "1230". + assert _normalize_uprn(123.0) == "123" + # Non-integral / NaN floats are rejected rather than mangled. + assert _normalize_uprn(1.5) is None + assert _normalize_uprn(float("nan")) is None + + +def _property_candidates(rows: list[dict]) -> pl.DataFrame: + base = { + "postcode": "AA1 1AA", + "pp_address": "1 Example Road", + "_property_match_postcode": "AA11AA", + "_property_match_address": "1 EXAMPLE ROAD", + "_property_epc_match_address": "1 EXAMPLE ROAD", + "uprn": None, + } + return pl.DataFrame( + [{**base, **row} for row in rows], + schema={ + "postcode": pl.Utf8, + "pp_address": pl.Utf8, + "_property_match_postcode": pl.Utf8, + "_property_match_address": pl.Utf8, + "_property_epc_match_address": pl.Utf8, + "uprn": pl.Utf8, + }, + ) + + +def test_match_listing_properties_uprn_wins_dedup_tie() -> None: + # Two listings claim the same property: one by UPRN, one by exact address + # (both score 100). The UPRN match must win even though it has the higher + # _listing_idx (which would otherwise break the tie the wrong way). + listings = _listing_matches( + [ + { + "_listing_idx": 5, + "_listing_uprn": "100000000001", + "_listing_match_address": "SOMETHING ELSE", + }, + { + "_listing_idx": 1, + "_listing_uprn": None, + "_listing_match_address": "1 EXAMPLE ROAD", + }, + ] + ) + matches = _match_listing_properties( + listings, _property_candidates([{"uprn": "100000000001"}]) + ) + + assert matches.height == 1 + assert matches["_listing_idx"].to_list() == [5] + assert matches["_property_match_method"].to_list() == ["uprn"] + + +def test_match_direct_epc_does_not_match_other_postcode_without_uprn() -> None: + # Matching is by postcode/UPRN/street — never by coordinate proximity — so a + # same-street EPC in a different postcode with no shared UPRN is skipped. + matches = _match_direct_epc( + _listing_matches([{"_listing_match_postcode": "AA11AA"}]), + _direct_epc_candidates( + [{"_direct_epc_match_postcode": "BB22BB", "_direct_epc_uprn": None}] + ), + ) + + assert matches.height == 0 def test_integrate_listings_attaches_overlay_by_matched_property_key(tmp_path) -> None: @@ -588,11 +694,72 @@ def test_integrate_listings_attaches_overlay_by_matched_property_key(tmp_path) - assert other["_actual_listing_url"].to_list() == [None] -def test_integrate_listings_rejects_low_confidence_no_number_match(tmp_path) -> None: +def test_integrate_listings_matches_by_uprn_over_address(tmp_path) -> None: + # The listing's address deliberately does not match the property's, but the + # shared UPRN drives an exact match anyway (UPRN beats fuzzy street). listings_path = tmp_path / "listings.parquet" arcgis_path = tmp_path / "arcgis.parquet" _sample_listings_frame().with_columns( - pl.lit("Rose Cottage High Street").alias("Address per Property Register"), + pl.lit("Totally Different Road").alias("Address per Property Register"), + pl.lit("100000000009").alias("UPRN"), + ).write_parquet(listings_path) + _stub_arcgis(arcgis_path) + wide = pl.DataFrame( + { + "postcode": ["SW1A 1AA"], + "pp_address": ["1 Example Road"], + "uprn": ["100000000009"], + "pp_property_type": ["Terraced"], + "duration": ["Freehold"], + "total_floor_area": [90.0], + "number_habitable_rooms": [4], + "latest_price": [600_000], + "epc_address": ["1 Example Road"], + "current_energy_rating": ["C"], + "potential_energy_rating": ["B"], + "floor_height": [2.4], + "construction_age_band": [1930], + "is_construction_date_approximate": [1], + "was_council_house": ["No"], + }, + schema={ + "postcode": pl.Utf8, + "pp_address": pl.Utf8, + "uprn": pl.Utf8, + "pp_property_type": pl.Utf8, + "duration": pl.Utf8, + "total_floor_area": pl.Float64, + "number_habitable_rooms": pl.Int16, + "latest_price": pl.Int64, + "epc_address": pl.Utf8, + "current_energy_rating": pl.Utf8, + "potential_energy_rating": pl.Utf8, + "floor_height": pl.Float64, + "construction_age_band": pl.UInt16, + "is_construction_date_approximate": pl.UInt8, + "was_council_house": pl.Utf8, + }, + ) + + integrated = _integrate_listings( + wide.lazy(), listings_path, arcgis_path, epc_path=None + ).collect() + + matched = integrated.filter(pl.col("pp_address") == "1 Example Road") + # The listing overlay attached to the UPRN-matched property row. + assert matched["_actual_listing_url"].to_list() == ["https://example.test/abc"] + # No spurious seed row for the listing's (non-matching) address. + assert "Totally Different Road" not in integrated["pp_address"].to_list() + + +def test_integrate_listings_seeds_listing_with_unmatched_street(tmp_path) -> None: + # A number-less listing whose street is not the property's street (and which + # shares no UPRN) must not be force-matched onto it; it becomes its own seed + # row instead of stamping the wrong property's overlay. + listings_path = tmp_path / "listings.parquet" + arcgis_path = tmp_path / "arcgis.parquet" + _sample_listings_frame().with_columns( + pl.lit("Juniper Crescent").alias("Address per Property Register"), ).write_parquet(listings_path) _stub_arcgis(arcgis_path) wide = pl.DataFrame( @@ -635,7 +802,7 @@ def test_integrate_listings_rejects_low_confidence_no_number_match(tmp_path) -> ).collect() existing = integrated.filter(pl.col("pp_address") == "Old Cottage High Street") - seed = integrated.filter(pl.col("pp_address") == "Rose Cottage High Street") + seed = integrated.filter(pl.col("pp_address") == "Juniper Crescent") assert existing["_actual_listing_url"].to_list() == [None] assert seed["_actual_listing_url"].to_list() == ["https://example.test/abc"] @@ -731,3 +898,77 @@ def test_finalize_listings_promotes_overlay_columns_and_filters_to_listing_rows( # Overlay scaffolding is dropped. for src, dst, _dt in _LISTING_OVERLAY_SOURCES: assert dst not in finalized.columns, src + + +def test_finalize_listings_dedupes_fanned_out_listing_rows() -> None: + # The terminated-postcode remap can collapse two distinct wide rows onto the same + # (postcode, pp_address), so a single matched listing attaches to both. Finalize + # must emit one row per listing URL, not one per collapsed wide row. + df = pl.DataFrame( + { + "Postcode": ["SW1A 1AA", "SW1A 1AA"], + "Address per Property Register": ["1 Example Road", "1 Example Road"], + "Address per EPC": ["1 Example Road", "1 Example Road"], + "Date of last transaction": [1990.0, 1995.0], + "lat": [51.5, 51.5], + "lon": [-0.1, -0.1], + "Total floor area (sqm)": [100.0, 95.0], + "Number of bedrooms & living rooms": [3, 3], + "Property type": ["Terraced", "Terraced"], + "Leasehold/Freehold": ["Leasehold", "Leasehold"], + "Last known price": [500_000, 480_000], + "Street tree density percentile": [42.0, 42.0], + # Same listing URL on both collapsed rows — the fan-out to fix. + "_actual_listing_url": ["url0", "url0"], + "_actual_asking_price": [600_000, 600_000], + "_actual_asking_price_per_sqm": [5_000, 5_000], + "_actual_listing_date": [None, None], + "_actual_listing_status": ["For sale", "For sale"], + "_actual_listing_features": [["Garden"], ["Garden"]], + "_actual_bedrooms": [3, 3], + "_actual_bathrooms": [1, 1], + "_actual_price_qualifier": ["", ""], + "_actual_property_sub_type": ["Mid-Terrace", "Mid-Terrace"], + "_actual_lat": [51.51, 51.51], + "_actual_lon": [-0.11, -0.11], + "_actual_total_floor_area": [110.0, 110.0], + "_actual_number_habitable_rooms": [4, 4], + "_actual_property_type": ["Terraced", "Terraced"], + "_actual_leasehold_freehold": ["Freehold", "Freehold"], + }, + schema={ + "Postcode": pl.Utf8, + "Address per Property Register": pl.Utf8, + "Address per EPC": pl.Utf8, + "Date of last transaction": pl.Float64, + "lat": pl.Float64, + "lon": pl.Float64, + "Total floor area (sqm)": pl.Float64, + "Number of bedrooms & living rooms": pl.Int16, + "Property type": pl.Utf8, + "Leasehold/Freehold": pl.Utf8, + "Last known price": pl.Int64, + "Street tree density percentile": pl.Float32, + "_actual_listing_url": pl.Utf8, + "_actual_asking_price": pl.Int64, + "_actual_asking_price_per_sqm": pl.Int32, + "_actual_listing_date": pl.Datetime("us"), + "_actual_listing_status": pl.Utf8, + "_actual_listing_features": pl.List(pl.Utf8), + "_actual_bedrooms": pl.Int32, + "_actual_bathrooms": pl.Int32, + "_actual_price_qualifier": pl.Utf8, + "_actual_property_sub_type": pl.Utf8, + "_actual_lat": pl.Float64, + "_actual_lon": pl.Float64, + "_actual_total_floor_area": pl.Float64, + "_actual_number_habitable_rooms": pl.Int16, + "_actual_property_type": pl.Utf8, + "_actual_leasehold_freehold": pl.Utf8, + }, + ) + + finalized = _finalize_listings(df) + + assert finalized.height == 1 + assert finalized["Listing URL"].to_list() == ["url0"] diff --git a/pipeline/transform/test_tree_density.py b/pipeline/transform/test_tree_density.py index a6e1b06..f4dd48f 100644 --- a/pipeline/transform/test_tree_density.py +++ b/pipeline/transform/test_tree_density.py @@ -1,19 +1,83 @@ +import math from pathlib import Path +import numpy as np import polars as pl import pytest +import shapely from pipeline.transform.tree_density import ( STREET_TREE_COVERAGE_COL, STREET_TREE_DENSITY_COL, + _add_nfi_batch, _coverage_percentile_expr, _metric_columns, + _postcode_buffers, _postcode_density_percentile_col, _with_postcode_density_percentiles, _write_street_rollups, ) +def test_nfi_accumulation_adds_only_clipped_overlap_area() -> None: + radius_m = 50 + points = pl.DataFrame({"postcode": ["A", "B"], "x": [0.0, 1000.0], "y": [0.0, 0.0]}) + circles, tree = _postcode_buffers(points, radius_m) + buffer_area = math.pi * radius_m * radius_m + + # A large woodland square centred on postcode A fully covers A's circle. + canopy_area = np.zeros(2) + feature_count = np.zeros(2, dtype=np.uint32) + big = shapely.box(-500, -500, 500, 500) # 1,000,000 sqm parcel + _add_nfi_batch( + np.array([big], dtype=object), + np.array(["Woodland"], dtype=object), + circles, + tree, + canopy_area, + feature_count, + radius_m, + ) + # Only the clipped circle area is added (the 32-gon buffer approximates the + # circle to ~1%), NOT the full 1,000,000 sqm polygon. + assert canopy_area[0] == pytest.approx(buffer_area, rel=1e-2) + assert canopy_area[0] <= buffer_area # never exceeds the buffer area + assert canopy_area[1] == 0.0 # postcode B is 1km away, no overlap + assert feature_count.tolist() == [1, 0] + + # A large parcel that only slivers into B's circle must add only the sliver, + # not its full area -- the failure mode the old centroid path could not avoid. + canopy_area = np.zeros(2) + feature_count = np.zeros(2, dtype=np.uint32) + sliver = shapely.box(1040, -500, 2000, 500) # left edge 10m inside B's circle + _add_nfi_batch( + np.array([sliver], dtype=object), + np.array(["Woodland"], dtype=object), + circles, + tree, + canopy_area, + feature_count, + radius_m, + ) + assert canopy_area[0] == 0.0 + assert 0.0 < canopy_area[1] < buffer_area # tiny segment, far below 1M sqm + + # Non-woodland categories contribute nothing. + canopy_area = np.zeros(2) + feature_count = np.zeros(2, dtype=np.uint32) + _add_nfi_batch( + np.array([big], dtype=object), + np.array(["Non woodland"], dtype=object), + circles, + tree, + canopy_area, + feature_count, + radius_m, + ) + assert canopy_area.tolist() == [0.0, 0.0] + assert feature_count.tolist() == [0, 0] + + def test_coverage_percentile_expr_ranks_higher_coverage_higher() -> None: df = pl.DataFrame({"coverage": [0.0, 5.0, 10.0, None]}) diff --git a/pipeline/transform/tree_density.py b/pipeline/transform/tree_density.py index 146e7d2..06a16a7 100644 --- a/pipeline/transform/tree_density.py +++ b/pipeline/transform/tree_density.py @@ -1,10 +1,16 @@ -"""Derive street-scale tree density metrics from Forest Research TOW data. +"""Derive street-scale tree density metrics from Forest Research TOW + NFI data. The Forest Research Trees Outside Woodland release is an Esri File Geodatabase inside property-data/FR_TOW_V1_ALL.zip. This transformer computes a compact postcode-level metric from the tree polygons, then optionally rolls that up to Price Paid street names so the dashboard can answer "what is this address's street like?" without loading the full geodatabase at runtime. + +TOW only covers trees *outside* woodland, so the National Forest Inventory (NFI) +woodland layer is optionally unioned in. TOW canopy is accumulated by centroid +proximity (tiny crowns), while large NFI woodland parcels are accumulated by +true buffer-clipped intersection area so they cannot saturate a postcode from +mere centroid proximity. """ from __future__ import annotations @@ -22,7 +28,6 @@ import shapely from scipy.spatial import cKDTree -DEFAULT_TOW_TYPES = ("Lone Tree", "Group of Trees") TOW_GDB_NAME = "FR_TOW_V1_ALL.gdb" STREET_TREE_DENSITY_COL = "Street tree density percentile" STREET_TREE_COVERAGE_COL = "Street tree coverage (%)" @@ -32,6 +37,14 @@ POSTCODE_AREA_COL = "Tree canopy area within {radius}m (sqm)" POSTCODE_COUNT_COL = "Tree features within {radius}m" POSTCODE_HEIGHT_COL = "Mean TOW height within {radius}m (m)" +# National Forest Inventory (NFI) woodland — the geometric complement of TOW. +# NFI ships as a zipped shapefile of woodland parcels (>=0.5 ha) in EPSG:27700. +# Field names are from the NFI Woodland England 2022 release; re-check on bumps. +NFI_CATEGORY_COL = "CATEGORY" +NFI_WOODLAND_VALUE = "Woodland" +NFI_TYPE_COL = "IFT_IOA" +NFI_AREA_HA_COL = "Area_ha" + def _safe_extract_zip(zip_path: Path, extract_dir: Path, force: bool) -> Path: """Extract the TOW zip and return the extracted .gdb path.""" @@ -83,12 +96,60 @@ def _tow_dataset_path( return str(_safe_extract_zip(zip_path, extract_dir, force_extract)) -def _where_for_tow_types(tow_types: tuple[str, ...] | None) -> str | None: - if not tow_types: - return None - escaped = [tow_type.replace("'", "''") for tow_type in tow_types] - values = ", ".join(f"'{tow_type}'" for tow_type in escaped) - return f"Woodland_Type IN ({values})" +def _safe_extract_zip_dir(zip_path: Path, extract_dir: Path, force: bool) -> Path: + """Extract an arbitrary zip into extract_dir and return the directory.""" + if extract_dir.exists() and not force: + print(f"Using existing extraction directory: {extract_dir}") + return extract_dir + if extract_dir.exists(): + shutil.rmtree(extract_dir) + + tmp_dir = extract_dir.with_name(f".{extract_dir.name}.tmp") + if tmp_dir.exists(): + shutil.rmtree(tmp_dir) + tmp_dir.mkdir(parents=True) + + root = tmp_dir.resolve() + print(f"Extracting {zip_path} to {extract_dir}...") + with zipfile.ZipFile(zip_path) as archive: + for member in archive.infolist(): + target = (tmp_dir / member.filename).resolve() + if root != target and root not in target.parents: + raise ValueError(f"Unsafe path in zip archive: {member.filename}") + if member.is_dir(): + target.mkdir(parents=True, exist_ok=True) + continue + target.parent.mkdir(parents=True, exist_ok=True) + with archive.open(member) as source, target.open("wb") as dest: + shutil.copyfileobj(source, dest, length=1024 * 1024) + + tmp_dir.rename(extract_dir) + print(f"Extracted archive: {extract_dir}") + return extract_dir + + +def _nfi_dataset_path( + zip_path: Path, extract_dir: Path, force_extract: bool, use_vsizip: bool +) -> str: + """Resolve the NFI woodland shapefile path, extracting the zip if needed.""" + if use_vsizip: + return f"/vsizip/{zip_path.resolve()}" + extracted = _safe_extract_zip_dir(zip_path, extract_dir, force_extract) + shapefiles = sorted(extracted.rglob("*.shp")) + if not shapefiles: + raise FileNotFoundError(f"No .shp found inside {zip_path}") + return str(shapefiles[0]) + + +def _geometry_column(metadata: dict, column_names: list[str]) -> str: + """Resolve the geometry column name from pyogrio Arrow metadata.""" + geometry_name = metadata.get("geometry_name") + if geometry_name: + return str(geometry_name) + for name in ("wkb_geometry", "geometry", "geom"): + if name in column_names: + return name + return column_names[-1] def _postcode_points(arcgis_path: Path, max_postcodes: int | None) -> pl.DataFrame: @@ -172,26 +233,20 @@ def _accumulate_tree_metrics( dataset_path: str, points: pl.DataFrame, radius_m: int, - tow_types: tuple[str, ...] | None, batch_size: int, layer_names: tuple[str, ...] | None, max_features_per_layer: int | None, workers: int, -) -> pl.DataFrame: + canopy_area: np.ndarray, + feature_count: np.ndarray, + height_weighted_sum: np.ndarray, + height_weight: np.ndarray, +) -> None: xy = points.select("x", "y").to_numpy() tree = cKDTree(xy) - n_points = points.height - canopy_area = np.zeros(n_points, dtype=np.float64) - feature_count = np.zeros(n_points, dtype=np.uint32) - height_weighted_sum = np.zeros(n_points, dtype=np.float64) - height_weight = np.zeros(n_points, dtype=np.float64) - - where = _where_for_tow_types(tow_types) layers = _layers(dataset_path, layer_names) print(f"Processing {len(layers)} TOW layer(s): {', '.join(layers)}") - if where: - print(f"TOW type filter: {where}") columns = ["Woodland_Type", "TOW_Area_M", "MEANHT"] total_features_seen = 0 @@ -206,7 +261,6 @@ def _accumulate_tree_metrics( dataset_path, layer=layer, columns=columns, - where=where, batch_size=batch_size, use_pyarrow=True, ) as (_meta, reader): @@ -297,6 +351,132 @@ def _accumulate_tree_metrics( f"{total_features_used:,} features with usable centroids" ) + +def _postcode_buffers( + points: pl.DataFrame, radius_m: int +) -> tuple[np.ndarray, shapely.STRtree]: + """Build a radius-r circle for every postcode plus an STRtree over them. + + Circle index == postcode index, matching the order used by the cKDTree path. + """ + xy = points.select("x", "y").to_numpy() + circles = shapely.buffer(shapely.points(xy), radius_m, quad_segs=8) + return circles, shapely.STRtree(circles) + + +def _add_nfi_batch( + geoms: np.ndarray, + category: np.ndarray, + circles: np.ndarray, + tree: shapely.STRtree, + canopy_area: np.ndarray, + feature_count: np.ndarray, + radius_m: int, +) -> None: + """Add NFI woodland into the shared arrays by true buffer-clipped area. + + Unlike the TOW centroid path, this clips each woodland polygon to each + nearby postcode circle and adds only area(polygon ∩ circle); a large parcel + therefore cannot saturate a postcode from mere centroid proximity, and a + buffer-filling parcel whose centroid is outside the radius is not missed. + """ + keep = (category == NFI_WOODLAND_VALUE) & ~shapely.is_missing(geoms) + geoms = geoms[keep] + if geoms.size: + geoms = geoms[~shapely.is_empty(geoms)] + if geoms.size == 0: + return + + # dwithin(polygon, point, r) is true iff the radius-r circle around the + # point intersects the polygon -- exactly the candidate set we want. + nfi_index, postcode_index = tree.query( + geoms, predicate="dwithin", distance=radius_m + ) + if nfi_index.size == 0: + return + + clipped_area = shapely.area( + shapely.intersection(geoms[nfi_index], circles[postcode_index]) + ) + positive = clipped_area > 0 + postcode_index = postcode_index[positive] + clipped_area = clipped_area[positive] + + np.add.at(canopy_area, postcode_index, clipped_area) + np.add.at(feature_count, postcode_index, 1) + + +def _accumulate_nfi_metrics( + dataset_path: str, + circles: np.ndarray, + tree: shapely.STRtree, + canopy_area: np.ndarray, + feature_count: np.ndarray, + radius_m: int, + batch_size: int, + max_nfi_features: int | None, +) -> None: + layers = _layers(dataset_path, None) + print(f"Processing {len(layers)} NFI layer(s): {', '.join(layers)}") + + # Density only needs the woodland flag + geometry; area is clipped from the + # postcode buffer, not read from the file. + columns = [NFI_CATEGORY_COL] + features_seen = 0 + + for layer in layers: + with pyogrio.open_arrow( + dataset_path, + layer=layer, + columns=columns, + batch_size=batch_size, + use_pyarrow=True, + ) as (meta, reader): + for batch_index, batch in enumerate(reader, start=1): + if max_nfi_features is not None: + remaining = max_nfi_features - features_seen + if remaining <= 0: + break + if batch.num_rows > remaining: + batch = batch.slice(0, remaining) + + features_seen += batch.num_rows + names = batch.schema.names + geometry_column = _geometry_column(meta, names) + category = np.asarray( + batch.column(names.index(NFI_CATEGORY_COL)).to_numpy( + zero_copy_only=False + ), + dtype=object, + ) + geometry = np.asarray( + batch.column(names.index(geometry_column)).to_numpy( + zero_copy_only=False + ), + dtype=object, + ) + _add_nfi_batch( + shapely.from_wkb(geometry), + category, + circles, + tree, + canopy_area, + feature_count, + radius_m, + ) + if batch_index == 1 or batch_index % 25 == 0: + print(f" NFI batch {batch_index:,}: {features_seen:,} rows read") + + +def _finalize_metrics( + points: pl.DataFrame, + canopy_area: np.ndarray, + feature_count: np.ndarray, + height_weighted_sum: np.ndarray, + height_weight: np.ndarray, + radius_m: int, +) -> pl.DataFrame: + n_points = points.height density_col, area_col, count_col, height_col = _metric_columns(radius_m) buffer_area = math.pi * radius_m * radius_m density_pct = np.minimum(canopy_area / buffer_area * 100.0, 100.0) @@ -518,6 +698,18 @@ def main() -> None: action="store_true", help="Read the geodatabase directly from the zip instead of extracting it", ) + parser.add_argument( + "--nfi-zip", + type=Path, + default=Path("property-data/NFI_WOODLAND_ENGLAND.zip"), + help="Optional NFI woodland shapefile zip to union with TOW (skipped if absent)", + ) + parser.add_argument( + "--nfi-extract-dir", + type=Path, + default=Path("property-data/nfi_woodland_england"), + help="Directory where the NFI zip is extracted", + ) parser.add_argument( "--arcgis", type=Path, @@ -554,11 +746,6 @@ def main() -> None: default=50, help="Radius around each postcode centroid used as the street-scale buffer", ) - parser.add_argument( - "--tow-types", - default=",".join(DEFAULT_TOW_TYPES), - help='Comma-separated Woodland_Type values to include, or "all"', - ) parser.add_argument( "--layers", default=None, @@ -588,6 +775,12 @@ def main() -> None: default=None, help="Testing only: process at most N TOW features per layer", ) + parser.add_argument( + "--max-nfi-features", + type=int, + default=None, + help="Testing only: process at most N NFI woodland features", + ) args = parser.parse_args() if (args.output_streets or args.output_addresses) and args.price_paid is None: @@ -600,18 +793,53 @@ def main() -> None: args.tow_zip, args.extract_dir, args.force_extract, args.use_vsizip ) points = _postcode_points(args.arcgis, args.max_postcodes) - tow_types = _parse_csv_arg(args.tow_types) layer_names = _parse_csv_arg(args.layers) - postcode_metrics = _accumulate_tree_metrics( + n_points = points.height + canopy_area = np.zeros(n_points, dtype=np.float64) + feature_count = np.zeros(n_points, dtype=np.uint32) + height_weighted_sum = np.zeros(n_points, dtype=np.float64) + height_weight = np.zeros(n_points, dtype=np.float64) + + _accumulate_tree_metrics( dataset_path=dataset_path, points=points, radius_m=args.radius_m, - tow_types=tow_types, batch_size=args.batch_size, layer_names=layer_names, max_features_per_layer=args.max_features_per_layer, workers=args.workers, + canopy_area=canopy_area, + feature_count=feature_count, + height_weighted_sum=height_weighted_sum, + height_weight=height_weight, + ) + + if args.nfi_zip is not None and args.nfi_zip.exists(): + nfi_path = _nfi_dataset_path( + args.nfi_zip, args.nfi_extract_dir, args.force_extract, args.use_vsizip + ) + circles, nfi_tree = _postcode_buffers(points, args.radius_m) + _accumulate_nfi_metrics( + dataset_path=nfi_path, + circles=circles, + tree=nfi_tree, + canopy_area=canopy_area, + feature_count=feature_count, + radius_m=args.radius_m, + batch_size=args.batch_size, + max_nfi_features=args.max_nfi_features, + ) + elif args.nfi_zip is not None: + print(f"NFI zip not found, skipping woodland union: {args.nfi_zip}") + + postcode_metrics = _finalize_metrics( + points, + canopy_area, + feature_count, + height_weighted_sum, + height_weight, + args.radius_m, ) postcode_metrics = _with_postcode_density_percentiles( postcode_metrics, args.radius_m diff --git a/pipeline/transform/tree_overlay_tiles.py b/pipeline/transform/tree_overlay_tiles.py index 56ef6ee..b301066 100644 --- a/pipeline/transform/tree_overlay_tiles.py +++ b/pipeline/transform/tree_overlay_tiles.py @@ -1,4 +1,4 @@ -"""Build PMTiles polygon tiles for the Trees Outside Woodland overlay.""" +"""Build PMTiles polygon tiles for the Trees Outside Woodland + NFI overlay.""" from __future__ import annotations @@ -16,10 +16,14 @@ from pyproj import Transformer from pipeline.local_temp import local_tmp_dir from pipeline.transform.tree_density import ( - DEFAULT_TOW_TYPES, + NFI_AREA_HA_COL, + NFI_CATEGORY_COL, + NFI_TYPE_COL, + NFI_WOODLAND_VALUE, + _geometry_column, _layers, + _nfi_dataset_path, _tow_dataset_path, - _where_for_tow_types, ) @@ -55,17 +59,13 @@ def _number_or_none(value) -> float | int | None: def _write_tree_geojsonseq( dataset_path: str, output_path: Path, - tow_types: tuple[str, ...], batch_size: int, layer_names: tuple[str, ...] | None, max_features_per_layer: int | None, ) -> int: to_wgs84 = Transformer.from_crs("EPSG:27700", "EPSG:4326", always_xy=True) - where = _where_for_tow_types(tow_types) layers = _layers(dataset_path, layer_names) print(f"Processing {len(layers)} TOW layer(s): {', '.join(layers)}") - if where: - print(f"TOW type filter: {where}") columns = [ "TOW_ID", @@ -88,7 +88,6 @@ def _write_tree_geojsonseq( dataset_path, layer=layer, columns=columns, - where=where, batch_size=batch_size, use_pyarrow=True, ) as (_meta, reader): @@ -136,6 +135,7 @@ def _write_tree_geojsonseq( for idx, geometry_json in zip(valid_indexes, geometries_json): properties = { + "source": "tow", "tow_id": str(tow_id[idx]) if tow_id is not None else "", "woodland_type": ( str(woodland_type[idx]) @@ -176,11 +176,105 @@ def _write_tree_geojsonseq( return feature_count +def _append_nfi_geojsonseq( + dataset_path: str, + output_path: Path, + batch_size: int, + max_nfi_features: int | None, +) -> int: + """Append NFI woodland polygons to the same GeoJSONSeq as the TOW features.""" + to_wgs84 = Transformer.from_crs("EPSG:27700", "EPSG:4326", always_xy=True) + layers = _layers(dataset_path, None) + print(f"Processing {len(layers)} NFI layer(s): {', '.join(layers)}") + + columns = [NFI_CATEGORY_COL, NFI_TYPE_COL, NFI_AREA_HA_COL] + feature_count = 0 + features_seen = 0 + + with output_path.open("a") as file: + for layer in layers: + with pyogrio.open_arrow( + dataset_path, + layer=layer, + columns=columns, + batch_size=batch_size, + use_pyarrow=True, + ) as (meta, reader): + for batch in reader: + if max_nfi_features is not None: + remaining = max_nfi_features - features_seen + if remaining <= 0: + break + if batch.num_rows > remaining: + batch = batch.slice(0, remaining) + + features_seen += batch.num_rows + names = batch.schema.names + geometry_column = _geometry_column(meta, names) + category = np.asarray( + batch.column(names.index(NFI_CATEGORY_COL)).to_numpy( + zero_copy_only=False + ), + dtype=object, + ) + geometry = np.asarray( + batch.column(names.index(geometry_column)).to_numpy( + zero_copy_only=False + ), + dtype=object, + ) + valid = category == NFI_WOODLAND_VALUE + if not valid.any(): + continue + + woodland_type = _column_or_none(batch, names, NFI_TYPE_COL) + area_ha = _column_or_none(batch, names, NFI_AREA_HA_COL) + + geometries = shapely.from_wkb(geometry[valid]) + geometries = shapely.transform( + geometries, + to_wgs84.transform, + interleaved=False, + ) + geometries_json = shapely.to_geojson(geometries) + valid_indexes = np.flatnonzero(valid) + + for idx, geometry_json in zip(valid_indexes, geometries_json): + area_sqm = ( + _number_or_none(area_ha[idx] * 10000.0) + if area_ha is not None + else None + ) + properties = { + "source": "nfi", + "tow_id": "", + "woodland_type": ( + str(woodland_type[idx]) + if woodland_type is not None + else "" + ), + "area_sqm": area_sqm, + "mean_height_m": None, + "min_height_m": None, + "max_height_m": None, + "lidar_year": None, + "source_layer": layer, + } + feature = { + "type": "Feature", + "geometry": json.loads(geometry_json), + "properties": properties, + } + file.write(json.dumps(feature, separators=(",", ":")) + "\n") + feature_count += 1 + + return feature_count + + def build_tree_overlay_tiles( tow_zip: Path, output_path: Path, extract_dir: Path, - tow_types: tuple[str, ...], batch_size: int, layer_names: tuple[str, ...] | None, max_features_per_layer: int | None, @@ -188,6 +282,9 @@ def build_tree_overlay_tiles( max_zoom: int, force_extract: bool, use_vsizip: bool, + nfi_zip: Path | None = None, + nfi_extract_dir: Path = Path("property-data/nfi_woodland_england"), + max_nfi_features: int | None = None, ) -> None: tippecanoe = _require_tippecanoe() dataset_path = _tow_dataset_path(tow_zip, extract_dir, force_extract, use_vsizip) @@ -198,13 +295,26 @@ def build_tree_overlay_tiles( feature_count = _write_tree_geojsonseq( dataset_path, ndjson_path, - tow_types, batch_size, layer_names, max_features_per_layer, ) print(f"Writing {feature_count:,} TOW polygon features") + if nfi_zip is not None and nfi_zip.exists(): + nfi_path = _nfi_dataset_path( + nfi_zip, nfi_extract_dir, force_extract, use_vsizip + ) + nfi_count = _append_nfi_geojsonseq( + nfi_path, + ndjson_path, + batch_size, + max_nfi_features, + ) + print(f"Writing {nfi_count:,} NFI woodland polygon features") + elif nfi_zip is not None: + print(f"NFI zip not found, skipping woodland union: {nfi_zip}") + subprocess.run( [ tippecanoe, @@ -237,26 +347,32 @@ def main() -> None: default=Path("property-data/fr_tow_v1_all"), help="Directory used to extract the FileGDB", ) - parser.add_argument( - "--tow-type", - action="append", - dest="tow_types", - help="Woodland_Type to include; repeatable. Defaults to TOW outside-woodland classes.", - ) parser.add_argument("--batch-size", type=int, default=50_000) parser.add_argument("--layer", action="append", dest="layers") parser.add_argument("--max-features-per-layer", type=int) - parser.add_argument("--min-zoom", type=int, default=15) + parser.add_argument("--min-zoom", type=int, default=12) parser.add_argument("--max-zoom", type=int, default=17) parser.add_argument("--force-extract", action="store_true") parser.add_argument("--use-vsizip", action="store_true") + parser.add_argument( + "--nfi-zip", + type=Path, + default=None, + help="Optional NFI woodland shapefile zip to union into the overlay", + ) + parser.add_argument( + "--nfi-extract-dir", + type=Path, + default=Path("property-data/nfi_woodland_england"), + help="Directory used to extract the NFI zip", + ) + parser.add_argument("--max-nfi-features", type=int) args = parser.parse_args() build_tree_overlay_tiles( tow_zip=args.tow_zip, output_path=args.output, extract_dir=args.extract_dir, - tow_types=tuple(args.tow_types or DEFAULT_TOW_TYPES), batch_size=args.batch_size, layer_names=tuple(args.layers) if args.layers else None, max_features_per_layer=args.max_features_per_layer, @@ -264,6 +380,9 @@ def main() -> None: max_zoom=args.max_zoom, force_extract=args.force_extract, use_vsizip=args.use_vsizip, + nfi_zip=args.nfi_zip, + nfi_extract_dir=args.nfi_extract_dir, + max_nfi_features=args.max_nfi_features, ) diff --git a/pipeline/validate_outputs.py b/pipeline/validate_outputs.py index 031a24d..69ed76e 100644 --- a/pipeline/validate_outputs.py +++ b/pipeline/validate_outputs.py @@ -3,6 +3,7 @@ from __future__ import annotations import argparse +import json import sys import zipfile from pathlib import Path @@ -76,6 +77,24 @@ def _split_glob(spec: str) -> tuple[Path, str]: return Path(base), pattern +def _split_pair(spec: str, label: str) -> tuple[Path, Path]: + if "::" not in spec: + raise argparse.ArgumentTypeError( + f"{spec!r} must use LEFT::RIGHT for {label}" + ) + left, right = spec.split("::", 1) + if not left or not right: + raise argparse.ArgumentTypeError(f"{spec!r} must include both paths") + return Path(left), Path(right) + + +def _canonical_postcode(value: object) -> str: + compact = "".join(str(value).split()).upper() + if len(compact) >= 5: + return f"{compact[:-3]} {compact[-3:]}" + return compact + + def _matched_files(spec: str) -> tuple[Path, str, list[Path]]: base, pattern = _split_glob(spec) if not base.exists(): @@ -105,6 +124,79 @@ def _failures_for_zip_glob(spec: str) -> list[str]: return failures +def _postcode_column(columns: list[str]) -> str | None: + for name in ("postcode", "Postcode", "pcds", "PCDS"): + if name in columns: + return name + return None + + +def _parquet_postcodes(path: Path) -> set[str]: + schema = pl.scan_parquet(path).collect_schema() + column = _postcode_column(schema.names()) + if column is None: + raise ValueError(f"{path}: missing postcode column") + values = ( + pl.scan_parquet(path) + .select(pl.col(column).drop_nulls().unique()) + .collect() + .get_column(column) + .to_list() + ) + return {_canonical_postcode(value) for value in values if _canonical_postcode(value)} + + +def _boundary_postcodes(path: Path) -> set[str]: + units_dir = path / "units" if (path / "units").is_dir() else path + postcodes: set[str] = set() + for geojson_path in sorted(units_dir.glob("*.geojson")): + with geojson_path.open("r", encoding="utf-8") as handle: + data = json.load(handle) + for feature in data.get("features", []): + properties = feature.get("properties") or {} + value = properties.get("postcodes") + if value is not None: + postcode = _canonical_postcode(value) + if postcode: + postcodes.add(postcode) + return postcodes + + +def _sample(values: set[str]) -> str: + return ", ".join(sorted(values)[:10]) + + +def _failures_for_postcode_boundary_match(spec: str) -> list[str]: + parquet_path, boundaries_path = _split_pair(spec, "postcode boundary matching") + failures = _failures_for_parquet(parquet_path) + _failures_for_dir(boundaries_path) + if failures: + return failures + + try: + parquet_postcodes = _parquet_postcodes(parquet_path) + boundary_postcodes = _boundary_postcodes(boundaries_path) + except Exception as exc: + return [f"{parquet_path} / {boundaries_path}: postcode match check failed: {exc}"] + + failures = [] + if not boundary_postcodes: + failures.append(f"{boundaries_path}: no boundary postcodes found") + + missing_boundaries = parquet_postcodes - boundary_postcodes + orphan_boundaries = boundary_postcodes - parquet_postcodes + if missing_boundaries: + failures.append( + f"{boundaries_path}: {len(missing_boundaries):,} postcodes from {parquet_path} " + f"are missing boundaries; sample: {_sample(missing_boundaries)}" + ) + if orphan_boundaries: + failures.append( + f"{boundaries_path}: {len(orphan_boundaries):,} boundary postcodes are absent from " + f"{parquet_path}; sample: {_sample(orphan_boundaries)}" + ) + return failures + + def main() -> int: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--file", action="append", default=[], type=Path) @@ -123,6 +215,12 @@ def main() -> int: default=[], help="Require at least one readable zip matching BASE::PATTERN", ) + parser.add_argument( + "--postcode-boundary-match", + action="append", + default=[], + help="Require postcode parquet keys to exactly match boundary GeoJSON postcodes: PARQUET::DIR", + ) args = parser.parse_args() failures: list[str] = [] @@ -138,6 +236,8 @@ def main() -> int: failures.extend(_failures_for_glob(spec)) for spec in args.zip_glob: failures.extend(_failures_for_zip_glob(spec)) + for spec in args.postcode_boundary_match: + failures.extend(_failures_for_postcode_boundary_match(spec)) if failures: print("Output validation failed:", file=sys.stderr) From e8345cbdc1e2880eae6f19576a2c8059b6111833 Mon Sep 17 00:00:00 2001 From: Andras Schmelczer <andras@schmelczer.dev> Date: Sun, 31 May 2026 20:20:41 +0100 Subject: [PATCH 2/9] improve --- Makefile.data | 12 +- frontend/src/App.tsx | 28 +- .../src/components/account/AccountPage.tsx | 29 +- .../components/map/LocationSearch.test.tsx | 92 ++- .../src/components/map/LocationSearch.tsx | 2 + frontend/src/components/map/MapPage.tsx | 22 +- frontend/src/components/map/POIPane.tsx | 2 +- .../map/map-page/DesktopMapPage.tsx | 5 +- .../components/map/map-page/MobileMapPage.tsx | 12 +- frontend/src/components/map/map-page/types.ts | 1 + frontend/src/components/ui/AuthModal.tsx | 21 +- frontend/src/components/ui/Header.tsx | 43 +- frontend/src/components/ui/MobileMenu.tsx | 14 +- frontend/src/components/ui/PillGroup.tsx | 9 +- .../src/components/ui/PlaceSearchInput.tsx | 126 ++-- frontend/src/components/ui/SearchInput.tsx | 13 +- frontend/src/hooks/useListingLayers.ts | 2 + frontend/src/hooks/useLocationSearch.ts | 29 +- frontend/src/i18n/locales/de.ts | 1 + frontend/src/i18n/locales/en.ts | 1 + frontend/src/i18n/locales/fr.ts | 1 + frontend/src/i18n/locales/hi.ts | 1 + frontend/src/i18n/locales/hu.ts | 1 + frontend/src/i18n/locales/zh.ts | 1 + pipeline/test_validate_outputs.py | 119 +++- pipeline/transform/crime_hotspot_tiles.py | 34 +- pipeline/transform/crime_spatial.py | 142 ++++- pipeline/transform/merge.py | 518 +++++++++------- .../transform/postcode_boundaries/output.py | 88 +-- .../test_postcode_boundaries.py | 97 ++- .../transform/postcode_boundaries/uprn.py | 41 +- .../transform/test_crime_hotspot_tiles.py | 52 ++ pipeline/transform/test_crime_spatial.py | 138 ++++- pipeline/transform/test_merge.py | 123 +++- pipeline/transform/test_tree_density.py | 262 +++++--- pipeline/transform/tree_density.py | 559 ++++++------------ pipeline/transform/tree_overlay_tiles.py | 7 +- pipeline/utils/postcode_mapping.py | 6 +- pipeline/validate_outputs.py | 204 ++++++- server-rs/src/routes/stats.rs | 26 +- 40 files changed, 1980 insertions(+), 904 deletions(-) create mode 100644 pipeline/transform/test_crime_hotspot_tiles.py diff --git a/Makefile.data b/Makefile.data index 4d41cbd..7152451 100644 --- a/Makefile.data +++ b/Makefile.data @@ -64,8 +64,6 @@ PBF := $(DATA_DIR)/england-latest.osm.pbf FR_TOW := $(DATA_DIR)/FR_TOW_V1_ALL.zip NFI := $(DATA_DIR)/NFI_WOODLAND_ENGLAND.zip TREE_DENSITY_PC := $(DATA_DIR)/tree_density_by_postcode.parquet -TREE_DENSITY_STREETS := $(DATA_DIR)/tree_density_by_street.parquet -TREE_DENSITY_ADDR := $(DATA_DIR)/tree_density_by_address.parquet OFS_REGISTER := $(DATA_DIR)/ofs_register.xlsx PLACES := $(DATA_DIR)/places.parquet MEDIAN_AGE := $(DATA_DIR)/median_age.parquet @@ -183,6 +181,7 @@ $(PC_BOUNDARIES_STAMP): $(OA_BOUNDARIES) $(INSPIRE_STAMP) $(UPRN_LOOKUP) $(ARCGI --oa-boundaries $(OA_BOUNDARIES) \ --inspire $(INSPIRE_DIR) \ --output $(PC_BOUNDARIES) + $(VALIDATE_OUTPUTS) --active-postcode-boundary-match "$(ARCGIS)::$(PC_BOUNDARIES)" @touch $@ generate-travel-times: $(ARCGIS) $(PLACES) $(PBF) download-transit-network @if [ -f "$(R5_NETWORK_CACHE)" ] && { [ "$(PBF)" -nt "$(R5_NETWORK_CACHE)" ] || [ "$(TRANSIT_STAMP)" -nt "$(R5_NETWORK_CACHE)" ]; }; then \ @@ -358,7 +357,7 @@ $(POIS_FILTERED): $(POIS_RAW) $(NAPTAN) $(GROCERY_RETAIL_POINTS) $(GIAS) $(OFSTE $(EPC_PP): $(PRICE_PAID) $(EPC) pipeline/transform/join_epc_pp.py pipeline/utils/fuzzy_join.py uv run python -m pipeline.transform.join_epc_pp --epc $(EPC) --price-paid $(PRICE_PAID) --output $@ -$(CRIME) $(CRIME_BY_YEAR) &: $(CRIME_STAMP) $(PC_BOUNDARIES) pipeline/transform/crime_spatial.py pipeline/transform/postcode_boundaries/loader.py pipeline/transform/crime.py +$(CRIME) $(CRIME_BY_YEAR) &: $(CRIME_STAMP) $(PC_BOUNDARIES_STAMP) pipeline/transform/crime_spatial.py pipeline/transform/postcode_boundaries/loader.py pipeline/transform/crime.py $(VALIDATE_OUTPUTS) --file $(CRIME_DIR)/archive_manifest.json --glob "$(CRIME_DIR)::**/*-street.csv" uv run python -m pipeline.transform.crime_spatial --input $(CRIME_DIR) --boundaries $(PC_BOUNDARIES)/units --output $(CRIME) --output-by-year $(CRIME_BY_YEAR) @@ -368,15 +367,12 @@ $(POI_PROXIMITY): $(ARCGIS) $(POIS_FILTERED) $(OS_GREENSPACE) $(POI_PROXIMITY_DE $(SCHOOL_PROX): $(OFSTED) $(ARCGIS) pipeline/transform/school_proximity.py pipeline/utils/poi_counts.py uv run python -m pipeline.transform.school_proximity --ofsted $(OFSTED) --arcgis $(ARCGIS) --output $@ -$(TREE_DENSITY_PC): $(FR_TOW) $(NFI) $(ARCGIS) $(PRICE_PAID) $(TREE_DENSITY_DEPS) +$(TREE_DENSITY_PC): $(FR_TOW) $(NFI) $(ARCGIS) $(TREE_DENSITY_DEPS) uv run python -m pipeline.transform.tree_density \ --tow-zip $(FR_TOW) \ --nfi-zip $(NFI) \ --arcgis $(ARCGIS) \ - --price-paid $(PRICE_PAID) \ - --output-postcodes $(TREE_DENSITY_PC) \ - --output-streets $(TREE_DENSITY_STREETS) \ - --output-addresses $(TREE_DENSITY_ADDR) + --output-postcodes $(TREE_DENSITY_PC) # Postcode boundaries require manual generation — fail with instructions $(PC_BOUNDARIES): diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx index 6865f07..b3a23be 100644 --- a/frontend/src/App.tsx +++ b/frontend/src/App.tsx @@ -81,6 +81,15 @@ function isProtectedPage(page: Page): boolean { return page === 'account' || page === 'saved'; } +function isSharedDashboardUrl(): boolean { + const share = new URLSearchParams(window.location.search).get('share'); + return !!share && /^[a-z0-9]{1,20}$/i.test(share); +} + +function isAuthRequiredRoute(page: Page): boolean { + return isProtectedPage(page) || (page === 'dashboard' && !isSharedDashboardUrl()); +} + function buildPageUrl(page: Page, inviteCode?: string, search = '', hash = ''): string { const normalizedHash = normalizeHash(hash); return `${pageToPath(page, inviteCode)}${search}${normalizedHash ? `#${normalizedHash}` : ''}`; @@ -235,6 +244,7 @@ export default function App() { const postAuthCheckoutReturnPathRef = useRef<string | null>(null); const authCompletedRef = useRef(false); const [licenseSuccessStatus, setLicenseSuccessStatus] = useState<LicenseSuccessStatus>('hidden'); + const [dashboardReady, setDashboardReady] = useState(false); // Keep a ref to the latest refreshAuth so the mount-only startup effect always // calls the current implementation without re-running when the callback identity changes. @@ -266,7 +276,7 @@ export default function App() { if (!completed) { setPostAuthIntent(null); postAuthCheckoutReturnPathRef.current = null; - if (isProtectedPage(activePageRef.current)) { + if (isAuthRequiredRoute(activePageRef.current)) { window.history.replaceState({ page: 'home', hash: '' }, '', '/'); setRouteHash(''); setActivePage('home'); @@ -517,7 +527,10 @@ export default function App() { } }, [activePage, fetchSearches]); - const isAuthRequiredPage = activePage === 'account' || activePage === 'saved'; + const isAuthRequiredPage = + activePage === 'account' || + activePage === 'saved' || + (activePage === 'dashboard' && !mapUrlState.share); useEffect(() => { if (authLoading) return; if (isAuthRequiredPage && !user) { @@ -530,6 +543,13 @@ export default function App() { const [exportState, setExportState] = useState<ExportState | null>(null); + useEffect(() => { + if (activePage !== 'dashboard' || !user) { + setDashboardReady(false); + setExportState(null); + } + }, [activePage, user]); + if ((isScreenshotMode || isOgMode) && inviteCode) { return ( <Suspense fallback={<PageFallback />}> @@ -584,8 +604,9 @@ export default function App() { onPageChange={navigateTo} theme={theme} onToggleTheme={toggleTheme} - exportState={activePage === 'dashboard' ? exportState : null} + exportState={activePage === 'dashboard' && user ? exportState : null} dashboardParams={activePage === 'dashboard' ? dashboardParams : ''} + dashboardActionsDisabled={activePage === 'dashboard' && !dashboardReady} onSaveSearch={ activePage === 'dashboard' && user ? editingSearch @@ -675,6 +696,7 @@ export default function App() { onNavigateTo={navigateTo} onExportStateChange={setExportState} onDashboardParamsChange={setDashboardParams} + onDashboardReadyChange={setDashboardReady} isMobile={isMobile} initialTravelTime={mapUrlState.travelTime} initialPostcode={mapUrlState.postcode} diff --git a/frontend/src/components/account/AccountPage.tsx b/frontend/src/components/account/AccountPage.tsx index a14113e..0c18e12 100644 --- a/frontend/src/components/account/AccountPage.tsx +++ b/frontend/src/components/account/AccountPage.tsx @@ -461,6 +461,24 @@ interface ShareLinkListItem { created: string; } +function latestPendingInviteUrls(invites: InviteListItem[]): Record<string, string> { + const latestByType: Record<string, { url: string; createdMs: number }> = {}; + + for (const invite of invites) { + if (invite.used || !invite.url) continue; + + const createdMs = Date.parse(invite.created) || 0; + const existing = latestByType[invite.invite_type]; + if (!existing || createdMs > existing.createdMs) { + latestByType[invite.invite_type] = { url: invite.url, createdMs }; + } + } + + return Object.fromEntries( + Object.entries(latestByType).map(([type, invite]) => [type, invite.url]) + ); +} + function InviteTable({ invites, loading, @@ -673,7 +691,16 @@ function InviteSection({ user }: { user: AuthUser }) { const res = await fetch(apiUrl('invites'), authHeaders()); assertOk(res, 'Fetch invites'); const data = await res.json(); - setInviteHistory(data.invites); + const invites: InviteListItem[] = Array.isArray(data.invites) ? data.invites : []; + setInviteHistory(invites); + const pendingInviteUrls = latestPendingInviteUrls(invites); + setInviteUrl((prev) => { + const next = { ...prev }; + for (const [type, url] of Object.entries(pendingInviteUrls)) { + if (!next[type]) next[type] = url; + } + return next; + }); } catch { // Silent — non-critical } finally { diff --git a/frontend/src/components/map/LocationSearch.test.tsx b/frontend/src/components/map/LocationSearch.test.tsx index 5f871a3..0c45f17 100644 --- a/frontend/src/components/map/LocationSearch.test.tsx +++ b/frontend/src/components/map/LocationSearch.test.tsx @@ -8,8 +8,11 @@ const RECENT_SEARCHES_STORAGE_KEY = 'perfect-postcode.locationSearch.recent'; vi.mock('react-i18next', () => ({ useTranslation: () => ({ - t: (key: string) => - key === 'locationSearch.placeholder' ? 'Search places or postcodes...' : key, + t: (key: string) => { + if (key === 'locationSearch.placeholder') return 'Search places or postcodes...'; + if (key === 'locationSearch.noResults') return 'No matching places or postcodes'; + return key; + }, }), })); @@ -226,6 +229,91 @@ describe('LocationSearch', () => { ); }); + it('selects the first place suggestion with Enter when none is highlighted', async () => { + vi.stubGlobal( + 'fetch', + vi.fn((input: string | URL | Request) => { + const url = new URL(String(input), 'http://localhost'); + if (url.pathname === '/api/places') { + return Promise.resolve( + jsonResponse({ + places: [ + { + type: 'place', + name: 'London', + slug: 'london', + place_type: 'city', + lat: 51.5074, + lon: -0.1278, + }, + ], + postcodes: [], + addresses: [], + }) + ); + } + if (url.pathname === '/api/nearest-postcode') { + return Promise.resolve( + jsonResponse({ + postcode: 'SW1A 1AA', + latitude: 51.501, + longitude: -0.141, + geometry: postcodeGeometry, + }) + ); + } + return Promise.resolve(new Response(null, { status: 404 })); + }) + ); + + const onFlyTo = vi.fn(); + const onLocationSearched = vi.fn(); + render(<LocationSearch onFlyTo={onFlyTo} onLocationSearched={onLocationSearched} />); + + const input = screen.getByRole('textbox'); + fireEvent.change(input, { target: { value: 'London' } }); + + await screen.findByRole('button', { name: 'London' }); + fireEvent.keyDown(input, { key: 'Enter' }); + + await waitFor(() => { + expect(onLocationSearched).toHaveBeenCalledTimes(1); + }); + expect(onFlyTo).toHaveBeenCalledWith(51.5074, -0.1278, 10); + expect(onLocationSearched).toHaveBeenCalledWith({ + postcode: 'SW1A 1AA', + geometry: postcodeGeometry, + latitude: 51.501, + longitude: -0.141, + zoom: 10, + markerLatitude: 51.5074, + markerLongitude: -0.1278, + }); + }); + + it('shows an empty state for invalid place queries', async () => { + vi.stubGlobal( + 'fetch', + vi.fn(() => + Promise.resolve( + jsonResponse({ + places: [], + postcodes: [], + addresses: [], + }) + ) + ) + ); + + render(<LocationSearch onFlyTo={vi.fn()} onLocationSearched={vi.fn()} />); + + fireEvent.change(screen.getByRole('textbox'), { target: { value: '!!!!zzzzzz!!!!' } }); + + await waitFor(() => { + expect(screen.getByText('No matching places or postcodes')).toBeTruthy(); + }); + }); + it('keeps only the three most recent local searches', async () => { vi.stubGlobal( 'fetch', diff --git a/frontend/src/components/map/LocationSearch.tsx b/frontend/src/components/map/LocationSearch.tsx index d8adbd3..e5a3c16 100644 --- a/frontend/src/components/map/LocationSearch.tsx +++ b/frontend/src/components/map/LocationSearch.tsx @@ -333,6 +333,8 @@ export default function LocationSearch({ onSelect={selectResult} loading={loading} placeholder={t('locationSearch.placeholder')} + ariaLabel={t('locationSearch.searchLabel')} + name="location-search" size="sm" inputClassName={ inputClassName ?? diff --git a/frontend/src/components/map/MapPage.tsx b/frontend/src/components/map/MapPage.tsx index ca43d52..3d7df16 100644 --- a/frontend/src/components/map/MapPage.tsx +++ b/frontend/src/components/map/MapPage.tsx @@ -91,6 +91,7 @@ export default function MapPage({ onNavigateTo, onExportStateChange, onDashboardParamsChange, + onDashboardReadyChange, screenshotMode, ogMode, isMobile = false, @@ -642,6 +643,23 @@ export default function MapPage({ onDashboardParamsChange?.(dashboardParams); }, [dashboardParams, onDashboardParamsChange]); + const dashboardReady = + !initialLoading && + !mapData.loading && + !mapData.licenseRequired && + mapData.bounds != null && + mapData.currentView != null; + + useEffect(() => { + onDashboardReadyChange?.(dashboardReady); + }, [dashboardReady, onDashboardReadyChange]); + + useEffect(() => { + return () => { + onDashboardReadyChange?.(false); + }; + }, [onDashboardReadyChange]); + useEffect(() => { if (mapData.licenseRequired) trackEvent('Upgrade Modal Shown'); }, [mapData.licenseRequired]); @@ -830,8 +848,8 @@ export default function MapPage({ </button> <button onClick={() => onUpdateEdit?.(dashboardParams)} - disabled={savingSearch} - className="shrink-0 cursor-pointer px-2.5 py-1 rounded text-xs font-medium bg-teal-600 text-white hover:bg-teal-700 disabled:opacity-50 disabled:cursor-wait flex items-center gap-1.5" + disabled={savingSearch || !dashboardReady} + className="shrink-0 cursor-pointer px-2.5 py-1 rounded text-xs font-medium bg-teal-600 text-white hover:bg-teal-700 disabled:opacity-50 disabled:cursor-not-allowed flex items-center gap-1.5" > {savingSearch ? t('savedPage.updating') : t('common.update')} </button> diff --git a/frontend/src/components/map/POIPane.tsx b/frontend/src/components/map/POIPane.tsx index 472aa03..b4ecc2f 100644 --- a/frontend/src/components/map/POIPane.tsx +++ b/frontend/src/components/map/POIPane.tsx @@ -186,7 +186,7 @@ export default function POIPane({ </div> {!isCollapsed && ( <div className="px-3 py-2"> - <PillGroup> + <PillGroup wrap> {group.categories.map((category) => { const logo = getPoiCategoryLogoUrl(category); return ( diff --git a/frontend/src/components/map/map-page/DesktopMapPage.tsx b/frontend/src/components/map/map-page/DesktopMapPage.tsx index 4f37e3a..3f6bc08 100644 --- a/frontend/src/components/map/map-page/DesktopMapPage.tsx +++ b/frontend/src/components/map/map-page/DesktopMapPage.tsx @@ -269,7 +269,10 @@ export function DesktopMapPage({ </div> )} {poiPaneOpen && ( - <div className="absolute bottom-28 right-4 z-10 flex h-[60vh] min-h-0 w-80 flex-col overflow-hidden rounded-lg border border-warm-200 bg-white shadow-xl dark:border-warm-700 dark:bg-warm-900"> + <div + className="absolute bottom-28 right-4 z-10 flex min-h-0 w-80 max-w-[calc(100%_-_2rem)] flex-col overflow-hidden rounded-lg border border-warm-200 bg-white shadow-xl dark:border-warm-700 dark:bg-warm-900" + style={{ height: 'min(30rem, calc(100vh - 10rem))' }} + > {poiPane} </div> )} diff --git a/frontend/src/components/map/map-page/MobileMapPage.tsx b/frontend/src/components/map/map-page/MobileMapPage.tsx index 845f531..40b8114 100644 --- a/frontend/src/components/map/map-page/MobileMapPage.tsx +++ b/frontend/src/components/map/map-page/MobileMapPage.tsx @@ -132,6 +132,10 @@ export function MobileMapPage({ upgradeModal, editingBar, }: MobileMapPageProps) { + const floatingPaneAvailableHeight = `max(12rem, calc(100dvh - ${Math.ceil( + bottomScreenInset + )}px - 7rem))`; + return ( <div className="flex-1 overflow-hidden relative"> <LoadingOverlay show={initialLoading} /> @@ -219,7 +223,13 @@ export function MobileMapPage({ )} {poiPaneOpen && ( - <div className="absolute top-24 right-3 left-3 z-20 flex h-[45dvh] min-h-0 flex-col overflow-hidden rounded-lg border border-warm-200 bg-white shadow-xl dark:border-warm-700 dark:bg-warm-900"> + <div + className="absolute top-24 right-3 left-3 z-20 flex min-h-0 flex-col overflow-hidden rounded-lg border border-warm-200 bg-white shadow-xl dark:border-warm-700 dark:bg-warm-900" + style={{ + height: `min(22rem, ${floatingPaneAvailableHeight})`, + maxHeight: floatingPaneAvailableHeight, + }} + > {poiPane} </div> )} diff --git a/frontend/src/components/map/map-page/types.ts b/frontend/src/components/map/map-page/types.ts index 23a841a..51e0335 100644 --- a/frontend/src/components/map/map-page/types.ts +++ b/frontend/src/components/map/map-page/types.ts @@ -39,6 +39,7 @@ export interface MapPageProps { onNavigateTo: (page: Page, hash?: string, infoFeature?: string) => void; onExportStateChange?: (state: ExportState) => void; onDashboardParamsChange?: (params: string) => void; + onDashboardReadyChange?: (ready: boolean) => void; screenshotMode?: boolean; ogMode?: boolean; isMobile?: boolean; diff --git a/frontend/src/components/ui/AuthModal.tsx b/frontend/src/components/ui/AuthModal.tsx index 2c8577c..b4ce606 100644 --- a/frontend/src/components/ui/AuthModal.tsx +++ b/frontend/src/components/ui/AuthModal.tsx @@ -1,4 +1,4 @@ -import { useState, useCallback, useEffect } from 'react'; +import { useState, useCallback, useEffect, useId } from 'react'; import { useTranslation } from 'react-i18next'; import { CloseIcon } from './icons/CloseIcon'; import { GoogleIcon } from './icons/GoogleIcon'; @@ -36,6 +36,9 @@ export default function AuthModal({ const [password, setPassword] = useState(''); const [resetSent, setResetSent] = useState(false); const dialogRef = useModalA11y(); + const fieldId = useId(); + const emailInputId = `${fieldId}-email`; + const passwordInputId = `${fieldId}-password`; useEffect(() => { trackEvent('Auth Modal Open', { tab: initialTab }); @@ -194,14 +197,20 @@ export default function AuthModal({ {/* Email form */} <form onSubmit={handleSubmit} className="space-y-4"> <div> - <label className="block text-sm font-medium text-warm-700 dark:text-warm-300 mb-1"> + <label + htmlFor={emailInputId} + className="block text-sm font-medium text-warm-700 dark:text-warm-300 mb-1" + > {t('auth.email')} </label> <input + id={emailInputId} + name="email" type="email" value={email} onChange={(e) => setEmail(e.target.value)} required + autoComplete="email" className="w-full px-3 py-2 text-sm rounded border border-warm-200 dark:border-warm-700 bg-white dark:bg-warm-800 text-navy-950 dark:text-white placeholder-warm-400 dark:placeholder-warm-500 outline-none focus:ring-2 ring-teal-400 dark:ring-teal-500" placeholder={t('auth.emailPlaceholder')} /> @@ -209,15 +218,21 @@ export default function AuthModal({ {view !== 'forgot' && ( <div> - <label className="block text-sm font-medium text-warm-700 dark:text-warm-300 mb-1"> + <label + htmlFor={passwordInputId} + className="block text-sm font-medium text-warm-700 dark:text-warm-300 mb-1" + > {t('auth.password')} </label> <input + id={passwordInputId} + name="password" type="password" value={password} onChange={(e) => setPassword(e.target.value)} required minLength={8} + autoComplete={view === 'register' ? 'new-password' : 'current-password'} className="w-full px-3 py-2 text-sm rounded border border-warm-200 dark:border-warm-700 bg-white dark:bg-warm-800 text-navy-950 dark:text-white placeholder-warm-400 dark:placeholder-warm-500 outline-none focus:ring-2 ring-teal-400 dark:ring-teal-500" placeholder={ view === 'register' diff --git a/frontend/src/components/ui/Header.tsx b/frontend/src/components/ui/Header.tsx index c5b4015..0e4dc5a 100644 --- a/frontend/src/components/ui/Header.tsx +++ b/frontend/src/components/ui/Header.tsx @@ -78,6 +78,7 @@ export default function Header({ onToggleTheme, exportState, dashboardParams, + dashboardActionsDisabled = false, onSaveSearch, savingSearch, editingSearch, @@ -96,6 +97,7 @@ export default function Header({ onToggleTheme: () => void; exportState: HeaderExportState | null; dashboardParams: string; + dashboardActionsDisabled?: boolean; onSaveSearch: (() => void) | null; savingSearch: boolean; editingSearch: EditingSearchState | null; @@ -116,6 +118,7 @@ export default function Header({ () => window.matchMedia(DASHBOARD_TABLET_SIDEBAR_QUERY).matches ); const useSidebarNav = isMobile || (activePage === 'dashboard' && isDashboardTabletSidebarWidth); + const dashboardActionsBlocked = activePage === 'dashboard' && (!user || dashboardActionsDisabled); useEffect(() => { const mql = window.matchMedia(DASHBOARD_TABLET_SIDEBAR_QUERY); @@ -139,6 +142,10 @@ export default function Header({ if (!useSidebarNav) setMenuOpen(false); }, [useSidebarNav]); + useEffect(() => { + if (dashboardActionsBlocked) setExportMenuOpen(false); + }, [dashboardActionsBlocked]); + const doCopy = useCallback((text: string) => { copyToClipboard(text, () => { setCopied(true); @@ -147,6 +154,7 @@ export default function Header({ }, []); const handleShare = useCallback(async () => { + if (dashboardActionsBlocked) return; const params = activePage === 'dashboard' ? dashboardParams : window.location.search.replace(/^\?/, ''); if (!params) { @@ -167,7 +175,7 @@ export default function Header({ } finally { setSharing(false); } - }, [activePage, dashboardParams, doCopy, i18n.language]); + }, [activePage, dashboardActionsBlocked, dashboardParams, doCopy, i18n.language]); const navLink = (page: Page, e: React.MouseEvent, hash?: string) => { if (e.metaKey || e.ctrlKey || e.shiftKey || e.button !== 0) return; @@ -206,8 +214,8 @@ export default function Header({ </button> <button onClick={onUpdateEdit} - disabled={savingSearch} - className="cursor-pointer px-3 py-1.5 rounded bg-teal-600 hover:bg-teal-700 transition-colors text-sm font-medium disabled:opacity-50 disabled:cursor-wait flex items-center gap-1.5" + disabled={savingSearch || dashboardActionsBlocked} + className="cursor-pointer px-3 py-1.5 rounded bg-teal-600 hover:bg-teal-700 transition-colors text-sm font-medium disabled:opacity-50 disabled:cursor-not-allowed flex items-center gap-1.5" > {savingSearch && <SpinnerIcon className="w-4 h-4 animate-spin" />} {savingSearch ? t('savedPage.updating') : t('common.update')} @@ -216,14 +224,16 @@ export default function Header({ </div> )} {/* Left: Logo + nav */} - <div className="flex items-center gap-4"> + <div className="flex min-w-0 items-center gap-4"> <a href="/" - className="flex cursor-pointer items-center gap-2 hover:opacity-80 transition-opacity" + className="flex min-w-0 cursor-pointer items-center gap-2 hover:opacity-80 transition-opacity" onClick={(e) => navLink('home', e)} > - <LogoIcon className="w-5 h-5 text-teal-400" /> - <span className="text-lg font-semibold text-teal-300">{t('header.appName')}</span> + <LogoIcon className="w-5 h-5 shrink-0 text-teal-400" /> + <span className="max-w-[9rem] truncate whitespace-nowrap text-lg font-semibold text-teal-300 sm:max-w-none"> + {t('header.appName')} + </span> </a> {/* Desktop nav */} @@ -266,14 +276,14 @@ export default function Header({ </div> {/* Right side */} - <div className="flex items-center gap-2 ml-auto"> + <div className="ml-auto flex shrink-0 items-center gap-2"> {/* Desktop-only dashboard actions */} - {!useSidebarNav && activePage === 'dashboard' && ( + {!useSidebarNav && activePage === 'dashboard' && user && ( <> <button onClick={handleShare} - disabled={sharing} - className="flex cursor-pointer items-center gap-1.5 px-3 py-1.5 rounded bg-navy-800 hover:bg-navy-700 transition-colors text-sm disabled:opacity-50" + disabled={sharing || dashboardActionsBlocked} + className="flex cursor-pointer items-center gap-1.5 px-3 py-1.5 rounded bg-navy-800 hover:bg-navy-700 transition-colors text-sm disabled:cursor-not-allowed disabled:opacity-50" > {sharing ? ( <> @@ -295,8 +305,8 @@ export default function Header({ {exportState && ( <button onClick={() => setExportMenuOpen(true)} - disabled={exportState.exporting} - className="flex cursor-pointer items-center gap-1.5 px-3 py-1.5 rounded bg-navy-800 hover:bg-navy-700 transition-colors text-sm disabled:opacity-50" + disabled={exportState.exporting || dashboardActionsBlocked} + className="flex cursor-pointer items-center gap-1.5 px-3 py-1.5 rounded bg-navy-800 hover:bg-navy-700 transition-colors text-sm disabled:cursor-not-allowed disabled:opacity-50" title={t('header.exportToExcel')} > <DownloadIcon className="w-4 h-4" /> @@ -306,8 +316,8 @@ export default function Header({ {onSaveSearch && !editingSearch && ( <button onClick={onSaveSearch} - disabled={savingSearch} - className="flex cursor-pointer items-center gap-1.5 px-3 py-1.5 rounded bg-navy-800 hover:bg-navy-700 transition-colors text-sm disabled:opacity-50" + disabled={savingSearch || dashboardActionsBlocked} + className="flex cursor-pointer items-center gap-1.5 px-3 py-1.5 rounded bg-navy-800 hover:bg-navy-700 transition-colors text-sm disabled:cursor-not-allowed disabled:opacity-50" > {savingSearch ? ( <SpinnerIcon className="w-4 h-4 animate-spin" /> @@ -363,7 +373,7 @@ export default function Header({ {useSidebarNav && !user && ( <button onClick={onRegisterClick} - className="cursor-pointer px-4 py-1.5 rounded bg-teal-600 hover:bg-teal-700 transition-colors text-sm font-semibold" + className="flex h-8 max-w-[8.5rem] shrink-0 cursor-pointer items-center justify-center truncate whitespace-nowrap rounded bg-teal-600 px-2.5 text-xs font-semibold leading-none transition-colors hover:bg-teal-700 sm:max-w-none sm:px-3 sm:text-sm" > {t('header.createAccount')} </button> @@ -410,6 +420,7 @@ export default function Header({ onToggleTheme={onToggleTheme} exportState={exportState} onOpenExportMenu={() => setExportMenuOpen(true)} + dashboardActionsDisabled={dashboardActionsBlocked} onSaveSearch={onSaveSearch} savingSearch={savingSearch} isEditingSearch={!!editingSearch} diff --git a/frontend/src/components/ui/MobileMenu.tsx b/frontend/src/components/ui/MobileMenu.tsx index 798a81a..9aa354e 100644 --- a/frontend/src/components/ui/MobileMenu.tsx +++ b/frontend/src/components/ui/MobileMenu.tsx @@ -20,6 +20,7 @@ interface MobileMenuProps { onToggleTheme: () => void; exportState: HeaderExportState | null; onOpenExportMenu: () => void; + dashboardActionsDisabled?: boolean; onSaveSearch: (() => void) | null; savingSearch: boolean; isEditingSearch: boolean; @@ -41,6 +42,7 @@ export default function MobileMenu({ onToggleTheme, exportState, onOpenExportMenu, + dashboardActionsDisabled = false, onSaveSearch, savingSearch, isEditingSearch, @@ -101,7 +103,7 @@ export default function MobileMenu({ </a> ); - const dashboardActions = activePage === 'dashboard' && ( + const dashboardActions = activePage === 'dashboard' && user && ( <div className="px-2 py-2 border-b border-navy-700"> <div className="grid grid-cols-2 gap-2"> <button @@ -109,7 +111,7 @@ export default function MobileMenu({ onShare(); onClose(); }} - disabled={sharing} + disabled={sharing || dashboardActionsDisabled} className={dashboardActionClass} > {sharing ? ( @@ -127,8 +129,8 @@ export default function MobileMenu({ onClose(); onOpenExportMenu(); }} - disabled={exportState.exporting} className={dashboardActionClass} + disabled={exportState.exporting || dashboardActionsDisabled} > <DownloadIcon className="w-4 h-4" /> {exportState.exporting ? t('header.exporting') : t('header.exportLabel')} @@ -140,7 +142,7 @@ export default function MobileMenu({ onSaveSearch(); onClose(); }} - disabled={savingSearch} + disabled={savingSearch || dashboardActionsDisabled} className={dashboardActionClass} > {savingSearch ? ( @@ -199,7 +201,7 @@ export default function MobileMenu({ </button> {/* Language selector */} - <div className="flex max-w-full gap-1 overflow-x-auto overflow-y-hidden px-3 pb-1 scrollbar-hide"> + <div className="grid max-w-full grid-cols-3 gap-1 px-3 pb-1"> {SUPPORTED_LANGUAGES.map((lang) => ( <button key={lang.code} @@ -208,7 +210,7 @@ export default function MobileMenu({ localStorage.setItem('language', lang.code); void changeAppLanguage(lang.code); }} - className={`flex-none min-w-[2.5rem] flex cursor-pointer items-center justify-center gap-1.5 px-2 py-1.5 rounded text-sm ${ + className={`flex min-w-0 cursor-pointer items-center justify-center gap-1.5 rounded px-2 py-1.5 text-sm ${ i18n.language === lang.code ? 'bg-navy-700 text-white font-medium' : 'text-warm-400 hover:bg-navy-800 hover:text-white' diff --git a/frontend/src/components/ui/PillGroup.tsx b/frontend/src/components/ui/PillGroup.tsx index 08faecc..0c9122a 100644 --- a/frontend/src/components/ui/PillGroup.tsx +++ b/frontend/src/components/ui/PillGroup.tsx @@ -3,12 +3,17 @@ import type { ReactNode } from 'react'; interface PillGroupProps { children: ReactNode; className?: string; + wrap?: boolean; } -export function PillGroup({ children, className = '' }: PillGroupProps) { +export function PillGroup({ children, className = '', wrap = false }: PillGroupProps) { return ( <div - className={`flex min-w-0 max-w-full flex-nowrap gap-1.5 overflow-x-auto overscroll-x-contain touch-pan-x touch-pan-y scrollbar-hide md:flex-wrap md:overflow-x-visible ${className}`} + className={`flex min-w-0 max-w-full gap-1.5 ${ + wrap + ? 'flex-wrap overflow-x-visible' + : 'flex-nowrap overflow-x-auto overscroll-x-contain touch-pan-x touch-pan-y scrollbar-hide md:flex-wrap md:overflow-x-visible' + } ${className}`} > {children} </div> diff --git a/frontend/src/components/ui/PlaceSearchInput.tsx b/frontend/src/components/ui/PlaceSearchInput.tsx index 449e246..eed23ed 100644 --- a/frontend/src/components/ui/PlaceSearchInput.tsx +++ b/frontend/src/components/ui/PlaceSearchInput.tsx @@ -1,5 +1,6 @@ import { useRef } from 'react'; import { createPortal } from 'react-dom'; +import { useTranslation } from 'react-i18next'; import type React from 'react'; import type { SearchResult } from '../../hooks/useLocationSearch'; import { useDropdownPosition } from '../../hooks/useDropdownPosition'; @@ -13,6 +14,7 @@ interface SearchHook { activeIndex: number; setActiveIndex: (idx: number) => void; open: boolean; + searching?: boolean; handleInputChange: (value: string) => void; handleKeyDown: (e: React.KeyboardEvent, onSelect: (result: SearchResult) => void) => void; showEmptySearches: () => void; @@ -23,6 +25,8 @@ interface PlaceSearchInputProps { onSelect: (result: SearchResult) => void; loading?: boolean; placeholder?: string; + ariaLabel?: string; + name?: string; size?: 'sm' | 'xs'; inputClassName?: string; inputRef?: React.Ref<HTMLInputElement>; @@ -35,19 +39,28 @@ export function PlaceSearchInput({ onSelect, loading, placeholder, + ariaLabel, + name, size = 'sm', inputClassName, inputRef, onInputChange, portal, }: PlaceSearchInputProps) { + const { t } = useTranslation(); const sm = size === 'sm'; const iconSize = sm ? 'w-4 h-4' : 'w-3 h-3'; const spinnerSize = sm ? 'w-4 h-4' : 'w-3 h-3'; const wrapperRef = useRef<HTMLDivElement>(null); const dropdownPos = useDropdownPosition(wrapperRef, portal ? search.open : false); - const showDropdown = search.open && search.results.length > 0; + const showEmptyResults = + search.open && + !search.searching && + search.query.trim().length >= 2 && + search.results.length === 0; + const showDropdown = search.open && (search.results.length > 0 || showEmptyResults); + const showSpinner = loading || search.searching; const dropdown = showDropdown && ( <div @@ -64,57 +77,66 @@ export function PlaceSearchInput({ : undefined } > - {search.results.map((result, idx) => ( - <button - key={ - result.type === 'postcode' - ? `pc-${result.label}` - : result.type === 'address' - ? `addr-${result.postcode}-${result.address}-${result.lat}` - : `pl-${result.name}-${result.lat}` - } - type="button" - className={`w-full text-left flex items-center cursor-pointer ${ - sm ? 'px-3 py-2 gap-2 text-sm' : 'px-2 py-1.5 gap-1.5 text-xs' - } ${ - idx === search.activeIndex - ? 'bg-teal-50 dark:bg-teal-900/30' - : 'hover:bg-warm-50 dark:hover:bg-warm-700' - }`} - onMouseEnter={() => search.setActiveIndex(idx)} - onMouseDown={(e) => { - e.preventDefault(); - onSelect(result); - }} + {showEmptyResults ? ( + <div + className={`text-warm-500 dark:text-warm-400 ${sm ? 'px-3 py-2 text-sm' : 'px-2 py-1.5 text-xs'}`} + role="status" > - {result.type === 'postcode' ? ( - <> - <SearchIcon className={`${iconSize} text-warm-400 dark:text-warm-500 shrink-0`} /> - <span className="text-warm-700 dark:text-warm-200">{result.label}</span> - </> - ) : result.type === 'address' ? ( - <> - <HouseIcon className={`${iconSize} text-warm-400 dark:text-warm-500 shrink-0`} /> - <span className="min-w-0 text-warm-700 dark:text-warm-200"> - <span className="block truncate">{result.address}</span> - <span className="block truncate text-warm-400 dark:text-warm-500"> - {result.postcode} + {t('locationSearch.noResults')} + </div> + ) : ( + search.results.map((result, idx) => ( + <button + key={ + result.type === 'postcode' + ? `pc-${result.label}` + : result.type === 'address' + ? `addr-${result.postcode}-${result.address}-${result.lat}` + : `pl-${result.name}-${result.lat}` + } + type="button" + className={`w-full text-left flex items-center cursor-pointer ${ + sm ? 'px-3 py-2 gap-2 text-sm' : 'px-2 py-1.5 gap-1.5 text-xs' + } ${ + idx === search.activeIndex + ? 'bg-teal-50 dark:bg-teal-900/30' + : 'hover:bg-warm-50 dark:hover:bg-warm-700' + }`} + onMouseEnter={() => search.setActiveIndex(idx)} + onMouseDown={(e) => { + e.preventDefault(); + onSelect(result); + }} + > + {result.type === 'postcode' ? ( + <> + <SearchIcon className={`${iconSize} text-warm-400 dark:text-warm-500 shrink-0`} /> + <span className="text-warm-700 dark:text-warm-200">{result.label}</span> + </> + ) : result.type === 'address' ? ( + <> + <HouseIcon className={`${iconSize} text-warm-400 dark:text-warm-500 shrink-0`} /> + <span className="min-w-0 text-warm-700 dark:text-warm-200"> + <span className="block truncate">{result.address}</span> + <span className="block truncate text-warm-400 dark:text-warm-500"> + {result.postcode} + </span> </span> - </span> - </> - ) : ( - <> - <MapPinIcon className={`${iconSize} text-warm-400 dark:text-warm-500 shrink-0`} /> - <span className="text-warm-700 dark:text-warm-200"> - {result.name} - {result.city && ( - <span className="text-warm-400 dark:text-warm-500"> ({result.city})</span> - )} - </span> - </> - )} - </button> - ))} + </> + ) : ( + <> + <MapPinIcon className={`${iconSize} text-warm-400 dark:text-warm-500 shrink-0`} /> + <span className="text-warm-700 dark:text-warm-200"> + {result.name} + {result.city && ( + <span className="text-warm-400 dark:text-warm-500"> ({result.city})</span> + )} + </span> + </> + )} + </button> + )) + )} </div> ); @@ -123,6 +145,7 @@ export function PlaceSearchInput({ <input ref={inputRef} type="text" + name={name} value={search.query} onChange={(e) => { search.handleInputChange(e.target.value); @@ -132,11 +155,12 @@ export function PlaceSearchInput({ search.showEmptySearches(); }} onKeyDown={(e) => search.handleKeyDown(e, onSelect)} + aria-label={ariaLabel ?? placeholder} placeholder={placeholder} className={inputClassName} /> - {loading && ( + {showSpinner && ( <div className={`absolute right-2 top-1/2 -translate-y-1/2 ${spinnerSize} border-2 border-warm-300 dark:border-warm-600 border-t-teal-500 rounded-full animate-spin`} /> diff --git a/frontend/src/components/ui/SearchInput.tsx b/frontend/src/components/ui/SearchInput.tsx index 7ed83c8..7e399dc 100644 --- a/frontend/src/components/ui/SearchInput.tsx +++ b/frontend/src/components/ui/SearchInput.tsx @@ -4,18 +4,27 @@ interface SearchInputProps { value: string; onChange: (value: string) => void; placeholder?: string; + ariaLabel?: string; className?: string; } -export function SearchInput({ value, onChange, placeholder, className = '' }: SearchInputProps) { +export function SearchInput({ + value, + onChange, + placeholder, + ariaLabel, + className = '', +}: SearchInputProps) { const { t } = useTranslation(); + const inputPlaceholder = placeholder ?? t('common.search'); return ( <input type="text" value={value} onChange={(e) => onChange(e.target.value)} - placeholder={placeholder ?? t('common.search')} + placeholder={inputPlaceholder} + aria-label={ariaLabel ?? inputPlaceholder} className={`w-full px-2 py-1 text-sm border rounded bg-white dark:bg-navy-800 dark:text-warm-200 border-warm-200 dark:border-navy-700 placeholder-warm-400 dark:placeholder-warm-500 focus:outline-none focus:ring-1 focus:ring-teal-400 ${className}`} /> ); diff --git a/frontend/src/hooks/useListingLayers.ts b/frontend/src/hooks/useListingLayers.ts index 1d4871e..75da1de 100644 --- a/frontend/src/hooks/useListingLayers.ts +++ b/frontend/src/hooks/useListingLayers.ts @@ -13,6 +13,7 @@ const LISTING_CLUSTER_MAX_ZOOM = 24; const LISTING_CLUSTER_POPUP_LIMIT = 30; const LISTING_SPIDERFY_LIMIT = 12; const TILE_SIZE = 512; +const PRICE_LABEL_CHARACTER_SET = '£0123456789.kM'; interface SingleListingPopupInfo { mode: 'single'; @@ -472,6 +473,7 @@ export function useListingLayers({ listings, zoom, isDark }: UseListingLayersPro outlineWidth: 3, outlineColor: isDark ? [10, 10, 10, 220] : [255, 255, 255, 230], fontSettings: { sdf: true }, + characterSet: PRICE_LABEL_CHARACTER_SET, sizeUnits: 'pixels', sizeMinPixels: 10, sizeMaxPixels: 14, diff --git a/frontend/src/hooks/useLocationSearch.ts b/frontend/src/hooks/useLocationSearch.ts index 675f206..34bbed4 100644 --- a/frontend/src/hooks/useLocationSearch.ts +++ b/frontend/src/hooks/useLocationSearch.ts @@ -160,6 +160,7 @@ export function useLocationSearch(mode?: string) { const [recentSearches, setRecentSearches] = useState<SearchResult[]>(readRecentSearches); const [activeIndex, setActiveIndex] = useState(-1); const [open, setOpen] = useState(false); + const [searching, setSearching] = useState(false); const abortRef = useRef<AbortController | null>(null); const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null); const latestQueryRef = useRef(''); @@ -176,6 +177,7 @@ export function useLocationSearch(mode?: string) { const trimmed = value.trim(); if (!trimmed) { + setSearching(false); setResults(recentSearches); lastResultsRef.current = []; setOpen(recentSearches.length > 0); @@ -183,6 +185,7 @@ export function useLocationSearch(mode?: string) { } if (!mode && looksLikePostcode(trimmed)) { + setSearching(false); const postcodeResults: SearchResult[] = [ { type: 'postcode', label: normalizePostcode(trimmed) }, ]; @@ -192,6 +195,7 @@ export function useLocationSearch(mode?: string) { } if (trimmed.length < 2) { + setSearching(false); setResults([]); setOpen(false); return; @@ -200,6 +204,7 @@ export function useLocationSearch(mode?: string) { const locallyFilteredResults = filterResultsForQuery(lastResultsRef.current, trimmed); setResults(locallyFilteredResults); setOpen(locallyFilteredResults.length > 0); + setSearching(true); debounceRef.current = setTimeout(async () => { const controller = new AbortController(); @@ -211,7 +216,13 @@ export function useLocationSearch(mode?: string) { `/api/places?${params}`, authHeaders({ signal: controller.signal }) ); - if (!res.ok) return; + if (!res.ok) { + if (!controller.signal.aborted && latestQueryRef.current.trim() === trimmed) { + setResults([]); + setOpen(true); + } + return; + } const json: { places: PlaceResult[]; postcodes?: string[]; @@ -253,9 +264,17 @@ export function useLocationSearch(mode?: string) { lastResultsRef.current = combinedResults; const matchingResults = filterResultsForQuery(combinedResults, trimmed); setResults(matchingResults); - setOpen(matchingResults.length > 0); + setOpen(true); } catch (err) { logNonAbortError('places search', err); + if (!controller.signal.aborted && latestQueryRef.current.trim() === trimmed) { + setResults([]); + setOpen(true); + } + } finally { + if (!controller.signal.aborted && latestQueryRef.current.trim() === trimmed) { + setSearching(false); + } } }, 200); }, @@ -264,7 +283,7 @@ export function useLocationSearch(mode?: string) { const showEmptySearches = useCallback(() => { if (latestQueryRef.current.trim()) { - setOpen(results.length > 0); + setOpen(results.length > 0 || latestQueryRef.current.trim().length >= 2); return; } @@ -278,6 +297,7 @@ export function useLocationSearch(mode?: string) { const clear = useCallback(() => { setQuery(''); latestQueryRef.current = ''; + setSearching(false); setResults([]); lastResultsRef.current = []; setOpen(false); @@ -308,6 +328,8 @@ export function useLocationSearch(mode?: string) { e.preventDefault(); if (activeIndex >= 0 && activeIndex < results.length) { onSelect(results[activeIndex]); + } else if (results.length > 0) { + onSelect(results[0]); } else if (looksLikePostcode(query)) { onSelect({ type: 'postcode', label: normalizePostcode(query) }); } @@ -332,6 +354,7 @@ export function useLocationSearch(mode?: string) { activeIndex, setActiveIndex, open, + searching, setOpen, handleInputChange, handleKeyDown, diff --git a/frontend/src/i18n/locales/de.ts b/frontend/src/i18n/locales/de.ts index 89e3fc2..a0df5a0 100644 --- a/frontend/src/i18n/locales/de.ts +++ b/frontend/src/i18n/locales/de.ts @@ -916,6 +916,7 @@ const de: Translations = { // ── Location Search ──────────────────────────────── locationSearch: { placeholder: 'Orte oder Postcodes suchen...', + noResults: 'Keine passenden Orte oder Postcodes', postcodeNotFound: 'Postcode nicht gefunden', lookupFailed: 'Suche fehlgeschlagen', searchLabel: 'Orte oder Postcodes suchen', diff --git a/frontend/src/i18n/locales/en.ts b/frontend/src/i18n/locales/en.ts index f59f382..22f0bef 100644 --- a/frontend/src/i18n/locales/en.ts +++ b/frontend/src/i18n/locales/en.ts @@ -892,6 +892,7 @@ const en = { // ── Location Search ──────────────────────────────── locationSearch: { placeholder: 'Search places or postcodes...', + noResults: 'No matching places or postcodes', postcodeNotFound: 'Postcode not found', lookupFailed: 'Lookup failed', searchLabel: 'Search places or postcodes', diff --git a/frontend/src/i18n/locales/fr.ts b/frontend/src/i18n/locales/fr.ts index bd502cc..bd4978b 100644 --- a/frontend/src/i18n/locales/fr.ts +++ b/frontend/src/i18n/locales/fr.ts @@ -924,6 +924,7 @@ const fr: Translations = { // ── Location Search ──────────────────────────────── locationSearch: { placeholder: 'Rechercher des lieux ou codes postaux...', + noResults: 'Aucun lieu ni code postal correspondant', postcodeNotFound: 'Code postal introuvable', lookupFailed: 'Échec de la recherche', searchLabel: 'Rechercher des lieux ou codes postaux', diff --git a/frontend/src/i18n/locales/hi.ts b/frontend/src/i18n/locales/hi.ts index e252cf3..b7b7039 100644 --- a/frontend/src/i18n/locales/hi.ts +++ b/frontend/src/i18n/locales/hi.ts @@ -876,6 +876,7 @@ const hi: Translations = { locationSearch: { placeholder: 'स्थान या पोस्टकोड खोजें...', + noResults: 'कोई मिलती-जुलती जगह या पोस्टकोड नहीं मिला', postcodeNotFound: 'पोस्टकोड नहीं मिला', lookupFailed: 'खोज विफल रही', searchLabel: 'स्थान या पोस्टकोड खोजें', diff --git a/frontend/src/i18n/locales/hu.ts b/frontend/src/i18n/locales/hu.ts index f9baa31..ff5e8d3 100644 --- a/frontend/src/i18n/locales/hu.ts +++ b/frontend/src/i18n/locales/hu.ts @@ -910,6 +910,7 @@ const hu: Translations = { // ── Location Search ──────────────────────────────── locationSearch: { placeholder: 'Helyek vagy irányítószámok keresése...', + noResults: 'Nincs egyező hely vagy irányítószám', postcodeNotFound: 'Irányítószám nem található', lookupFailed: 'A keresés sikertelen', searchLabel: 'Helyek vagy irányítószámok keresése', diff --git a/frontend/src/i18n/locales/zh.ts b/frontend/src/i18n/locales/zh.ts index ff854e8..303da18 100644 --- a/frontend/src/i18n/locales/zh.ts +++ b/frontend/src/i18n/locales/zh.ts @@ -850,6 +850,7 @@ const zh: Translations = { // ── Location Search ──────────────────────────────── locationSearch: { placeholder: '搜索地点或邮编...', + noResults: '未找到匹配的地点或邮编', postcodeNotFound: '未找到该邮编', lookupFailed: '查询失败', searchLabel: '搜索地点或邮编', diff --git a/pipeline/test_validate_outputs.py b/pipeline/test_validate_outputs.py index 4b7d4ce..2f36581 100644 --- a/pipeline/test_validate_outputs.py +++ b/pipeline/test_validate_outputs.py @@ -1,19 +1,33 @@ from __future__ import annotations -import zipfile import json +import zipfile import polars as pl from pipeline.validate_outputs import main -def write_boundary(path, postcodes): +def polygon(offset=0): + x = float(offset) + return { + "type": "Polygon", + "coordinates": [ + [(x, 0.0), (x + 0.001, 0.0), (x + 0.001, 0.001), (x, 0.001), (x, 0.0)] + ], + } + + +def write_boundary(path, postcodes, geometries=None): units = path / "units" units.mkdir(parents=True) features = [ - {"type": "Feature", "properties": {"postcodes": postcode}, "geometry": None} - for postcode in postcodes + { + "type": "Feature", + "properties": {"postcodes": postcode}, + "geometry": (geometries[index] if geometries else polygon(index)), + } + for index, postcode in enumerate(postcodes) ] (units / "AA1.geojson").write_text( json.dumps({"type": "FeatureCollection", "features": features}) @@ -111,3 +125,100 @@ def test_rejects_postcode_boundary_mismatch(tmp_path, monkeypatch, capsys): stderr = capsys.readouterr().err assert "missing boundaries" in stderr assert "boundary postcodes are absent" in stderr + + +def test_rejects_invalid_postcode_boundary_features(tmp_path, monkeypatch, capsys): + postcodes_path = tmp_path / "postcodes.parquet" + boundaries_path = tmp_path / "postcode_boundaries" + units = boundaries_path / "units" + units.mkdir(parents=True) + pl.DataFrame({"postcode": ["AA1 1AA"]}).write_parquet(postcodes_path) + bowtie = { + "type": "Polygon", + "coordinates": [[(0, 0), (1, 1), (1, 0), (0, 1), (0, 0)]], + } + features = [ + { + "type": "Feature", + "properties": {"postcodes": "AA1 1AA"}, + "geometry": polygon(), + }, + { + "type": "Feature", + "properties": {"postcodes": "AA1 1AA"}, + "geometry": polygon(1), + }, + {"type": "Feature", "properties": {}, "geometry": polygon(2)}, + {"type": "Feature", "properties": {"postcodes": "AA1 1AB"}, "geometry": None}, + {"type": "Feature", "properties": {"postcodes": "AA1 1AC"}, "geometry": bowtie}, + ] + (units / "AA1.geojson").write_text( + json.dumps({"type": "FeatureCollection", "features": features}) + ) + + monkeypatch.setattr( + "sys.argv", + [ + "validate_outputs", + "--postcode-boundary-match", + f"{postcodes_path}::{boundaries_path}", + ], + ) + + assert main() == 1 + stderr = capsys.readouterr().err + assert "duplicate boundary postcode features" in stderr + assert "missing properties.postcodes" in stderr + assert "missing or empty geometry" in stderr + assert "invalid boundary geometries" in stderr + + +def test_validates_active_english_arcgis_boundary_matches(tmp_path, monkeypatch): + arcgis_path = tmp_path / "arcgis.parquet" + boundaries_path = tmp_path / "postcode_boundaries" + pl.DataFrame( + { + "pcds": ["AA1 1AA", "AA1 1AB", "CF1 1AA"], + "ctry25cd": ["E92000001", "E92000001", "W92000004"], + "doterm": [None, "2020-01-01", None], + } + ).write_parquet(arcgis_path) + write_boundary(boundaries_path, ["AA1 1AA"]) + + monkeypatch.setattr( + "sys.argv", + [ + "validate_outputs", + "--active-postcode-boundary-match", + f"{arcgis_path}::{boundaries_path}", + ], + ) + + assert main() == 0 + + +def test_rejects_active_english_arcgis_boundary_mismatch(tmp_path, monkeypatch, capsys): + arcgis_path = tmp_path / "arcgis.parquet" + boundaries_path = tmp_path / "postcode_boundaries" + pl.DataFrame( + { + "pcds": ["AA1 1AA", "AA1 1AB", "CF1 1AA"], + "ctry25cd": ["E92000001", "E92000001", "W92000004"], + "doterm": [None, None, None], + } + ).write_parquet(arcgis_path) + write_boundary(boundaries_path, ["AA1 1AA", "CF1 1AA"]) + + monkeypatch.setattr( + "sys.argv", + [ + "validate_outputs", + "--active-postcode-boundary-match", + f"{arcgis_path}::{boundaries_path}", + ], + ) + + assert main() == 1 + stderr = capsys.readouterr().err + assert "active English postcodes" in stderr + assert "not active English postcodes" in stderr diff --git a/pipeline/transform/crime_hotspot_tiles.py b/pipeline/transform/crime_hotspot_tiles.py index 36aebce..87dd131 100644 --- a/pipeline/transform/crime_hotspot_tiles.py +++ b/pipeline/transform/crime_hotspot_tiles.py @@ -46,8 +46,21 @@ def _require_tippecanoe() -> str: return executable -def _write_geojsonseq(csvs: list[Path], output_path: Path) -> int: - df = ( +def _write_geojsonseq(csvs: list[Path], output_path: Path) -> tuple[int, int]: + """Write one weighted GeoJSON point per distinct (anchor, month, type). + + Returns ``(feature_count, incident_count)``. police.uk snaps every incident + to a shared "map point" anchor, so many incidents land on the exact same + coordinate. Collapsing them into one feature carrying ``count`` (the number + of incidents) keeps the per-crime-type and per-month filters intact while + turning each hotspot into a single high-weight point. That matters because + tippecanoe's ``--drop-densest-as-needed`` thins *feature density*, not + weight: with one feature per row the busiest streets were silently deleted; + with one weighted feature per anchor those hotspots survive and the dropped + detail is only redundant duplicate points. The heatmap reads ``count`` as + its weight. + """ + grouped = ( pl.scan_csv( csvs, schema_overrides={ @@ -67,11 +80,15 @@ def _write_geojsonseq(csvs: list[Path], output_path: Path) -> int: .drop_nulls(["lon", "lat"]) .filter(pl.col("lon").is_between(-9.5, 5.0)) .filter(pl.col("lat").is_between(49.0, 57.0)) + .group_by("lon", "lat", "month", "crime_type") + .len() + .rename({"len": "count"}) .collect(engine="streaming") ) + incident_count = int(grouped["count"].sum()) with output_path.open("w") as file: - for row in df.iter_rows(named=True): + for row in grouped.iter_rows(named=True): feature = { "type": "Feature", "geometry": { @@ -79,15 +96,15 @@ def _write_geojsonseq(csvs: list[Path], output_path: Path) -> int: "coordinates": [row["lon"], row["lat"]], }, "properties": { - "count": 1, - "weight": 1, + "count": row["count"], + "weight": row["count"], "month": row["month"], "crime_type": row["crime_type"], }, } file.write(json.dumps(feature, separators=(",", ":")) + "\n") - return df.height + return grouped.height, incident_count def build_crime_hotspot_tiles( @@ -104,9 +121,10 @@ def build_crime_hotspot_tiles( with tempfile.TemporaryDirectory(dir=local_tmp_dir()) as tmp: ndjson_path = Path(tmp) / "crime_hotspots.geojsonseq" - feature_count = _write_geojsonseq(csvs, ndjson_path) + feature_count, incident_count = _write_geojsonseq(csvs, ndjson_path) print( - f"Writing {feature_count:,} approximate crime heatmap points " + f"Writing {feature_count:,} weighted crime heatmap points " + f"({incident_count:,} incidents) " f"from {min(selected_months)} to {max(selected_months)}" ) diff --git a/pipeline/transform/crime_spatial.py b/pipeline/transform/crime_spatial.py index c72a6b5..9bd4f40 100644 --- a/pipeline/transform/crime_spatial.py +++ b/pipeline/transform/crime_spatial.py @@ -1,14 +1,25 @@ -"""Aggregate police.uk street crime to postcodes by 50m spatial proximity. +"""Aggregate police.uk street crime to postcodes by spatial proximity. Instead of attributing each incident to its published LSOA code, this transform -counts the anonymised incident *points* that fall within 50m of each postcode's -boundary polygon (the polygon buffered outward by 50m). A point inside several -overlapping buffers counts for each postcode -- the same multiplicity the -tree-density filter uses for features near more than one postcode. +counts the anonymised incident *points* that fall within ``buffer_m`` (default +100m) of each postcode's boundary polygon (the polygon buffered outward). A point +inside several overlapping buffers counts for each postcode -- the same +multiplicity the tree-density filter uses for features near more than one +postcode. The wide 100m buffer deliberately smooths police.uk's snap-to-grid +coordinates, which would otherwise make the count hypersensitive to which side of +a narrow line a shared "map point" anchor happened to land on. -The metric is a raw annualised count ("incidents/year within 50m"); there is no -per-capita denominator. Outputs mirror the old LSOA transform's shape but are -keyed on ``postcode`` instead of ``LSOA code``: +Counts are **area-normalised**: each postcode's count is divided by its buffered +catchment area and rescaled by the median catchment area, so the metric reflects +crime *density* rather than how much ground the buffer sweeps (a median-sized +catchment is left unchanged; a large rural postcode is no longer inflated simply +for covering more of the map). Normalising by the buffered area -- the region +that actually collects points -- rather than the raw polygon keeps tiny unit +postcodes from being over-inflated by the fixed buffer-ring floor. The headline +``"{type} (avg/yr)"`` is the simple mean of the per-year annualised counts, so it +equals the average of the by-year chart bars. + +Outputs mirror the old LSOA transform's shape but are keyed on ``postcode``: * ``crime_by_postcode.parquet`` -- ``postcode`` + ``"{type} (avg/yr)"`` columns. * ``crime_by_postcode_by_year.parquet`` -- ``postcode`` + ``"{type} (by year)"`` @@ -16,14 +27,15 @@ keyed on ``postcode`` instead of ``LSOA code``: Caveat: police.uk coordinates are snapped to a fixed set of anonymous "map points", not true locations, and a share of rows have no coordinate at all -(dropped here). Spatial totals are therefore lower than, and fuzzier than, the -old LSOA-tagged counts -- by design, not a regression. +(dropped here). Spatial totals are therefore fuzzier than the old LSOA-tagged +counts -- by design, not a regression. """ from __future__ import annotations import argparse import re +import sys from pathlib import Path import numpy as np @@ -41,7 +53,7 @@ from pipeline.transform.postcode_boundaries.loader import load_postcode_polygons # Serious types first so column order is stable and self-documenting. ALL_CRIME_TYPES: tuple[str, ...] = SERIOUS_CRIME_TYPES + MINOR_CRIME_TYPES -DEFAULT_BUFFER_M = 50.0 +DEFAULT_BUFFER_M = 100.0 MONTH_DIR_RE = re.compile(r"^\d{4}-\d{2}$") # Generous GB bounds; points outside fall in no English postcode anyway, but @@ -108,10 +120,11 @@ def _accumulate_counts( "Month": pl.Utf8, "Crime type": pl.Utf8, } - known_types = list(type_to_idx) + years = list(year_to_idx) total_points = 0 total_matches = 0 total_dropped = 0 + unknown_type_counts: dict[str, int] = {} for start in range(0, len(csvs), _CSV_BATCH): batch = csvs[start : start + _CSV_BATCH] @@ -122,31 +135,47 @@ def _accumulate_counts( ignore_errors=True, ) .select("Longitude", "Latitude", "Month", "Crime type") - .with_columns(pl.col("Month").str.slice(0, 4).cast(pl.Int32).alias("year")) + # strict=False: a single malformed Month drops only that row instead + # of aborting the whole build (a non-numeric year becomes null and is + # filtered out by the year membership check below). + .with_columns( + pl.col("Month").str.slice(0, 4).cast(pl.Int32, strict=False).alias("year") + ) .filter( pl.col("Longitude").is_not_null() & pl.col("Latitude").is_not_null() & pl.col("Longitude").is_between(*LON_BOUNDS) & pl.col("Latitude").is_between(*LAT_BOUNDS) - & pl.col("Crime type").is_in(known_types) - & pl.col("year").is_in(list(year_to_idx)) + & pl.col("Crime type").is_not_null() + & (pl.col("Crime type") != "") + & pl.col("year").is_in(years) ) + # Map crime types to indices with default=None so an unrecognised + # type yields a null index we can *report* rather than silently drop + # (the legacy LSOA path surfaced unknown types via its dynamic pivot). .with_columns( pl.col("Crime type") - .replace_strict(type_to_idx, return_dtype=pl.Int32) + .replace_strict(type_to_idx, default=None, return_dtype=pl.Int32) .alias("tidx"), pl.col("year") .replace_strict(year_to_idx, return_dtype=pl.Int32) .alias("yidx"), ) - .select("Longitude", "Latitude", "tidx", "yidx") + .select("Longitude", "Latitude", "Crime type", "tidx", "yidx") .collect(engine="streaming") ) - rows_in = frame.height - if rows_in == 0: + if frame.height == 0: continue + unknown = frame.filter(pl.col("tidx").is_null()) + if unknown.height: + for name, cnt in unknown.group_by("Crime type").len().iter_rows(): + unknown_type_counts[name] = unknown_type_counts.get(name, 0) + cnt + frame = frame.filter(pl.col("tidx").is_not_null()) + if frame.height == 0: + continue + lon = frame["Longitude"].to_numpy() lat = frame["Latitude"].to_numpy() tidx = frame["tidx"].to_numpy() @@ -177,6 +206,20 @@ def _accumulate_counts( if total_dropped: print(f"Dropped {total_dropped:,} points outside the BNG transform domain") + if unknown_type_counts: + total_unknown = sum(unknown_type_counts.values()) + listed = ", ".join( + f"{name!r} ({cnt:,})" + for name, cnt in sorted( + unknown_type_counts.items(), key=lambda kv: kv[1], reverse=True + ) + ) + print( + f"WARNING: dropped {total_unknown:,} incidents with crime types not in " + f"ALL_CRIME_TYPES (taxonomy is stale -- update SERIOUS/MINOR_CRIME_TYPES): " + f"{listed}", + file=sys.stderr, + ) def _rollup_long( @@ -195,12 +238,27 @@ def _rollup_long( def _write_avg_yr( postcodes: np.ndarray, counts: np.ndarray, - valid_month_count: int, + years: list[int], + months_in_year: dict[int, int], + norm: np.ndarray, output_path: Path, ) -> None: - """Write ``postcode`` + ``"{type} (avg/yr)"`` annualised totals.""" - totals = counts.sum(axis=2) # (n_postcodes, n_types) - avg = np.round(totals / valid_month_count * 12.0, 1).astype(np.float32) + """Write ``postcode`` + ``"{type} (avg/yr)"`` density-normalised averages. + + The headline figure is the **simple mean of the per-year annualised counts** + (each year scaled to a 12-month equivalent), so it equals the average of the + by-year chart bars instead of a month-weighted pooled rate. Each postcode's + value is then multiplied by ``norm`` (median_area / buffered catchment area) + so the metric is a density rather than a footprint-inflated raw count. + """ + months = np.array([months_in_year[year] for year in years], dtype=np.float64) + per_year = counts.astype(np.float64) * 12.0 / months[None, None, :] + # Average over the years each type is actually observed anywhere -- the same + # per-type x-span the by-year chart plots (server-rs/.../crime_by_year.rs). + type_year_present = counts.sum(axis=0) > 0 # (n_types, n_years) + years_per_type = np.clip(type_year_present.sum(axis=1), 1, None).astype(np.float64) + avg = per_year.sum(axis=2) / years_per_type[None, :] # (n_postcodes, n_types) + avg = np.round(avg * norm[:, None], 1).astype(np.float32) data: dict[str, np.ndarray] = {"postcode": postcodes} for type_idx, name in enumerate(ALL_CRIME_TYPES): @@ -216,11 +274,20 @@ def _write_by_year( counts: np.ndarray, years: list[int], months_in_year: dict[int, int], + norm: np.ndarray, output_path: Path, ) -> None: - """Write nested ``"{type} (by year)"`` series plus Serious/Minor rollups.""" + """Write nested ``"{type} (by year)"`` series plus Serious/Minor rollups. + + Per-year counts are area-normalised by the same ``norm`` (median_area / + buffered catchment area) factor applied to the avg/yr headline, so the chart + bars and the headline figure remain mutually consistent. + """ months = np.array([months_in_year[year] for year in years], dtype=np.float64) - annual = np.round(counts.astype(np.float64) * 12.0 / months[None, None, :], 1) + annual = np.round( + counts.astype(np.float64) * 12.0 / months[None, None, :] * norm[:, None, None], + 1, + ) pc_i, ty_i, yr_i = np.nonzero(counts) if pc_i.size == 0: @@ -278,8 +345,27 @@ def transform_crime_spatial( ) postcodes, polygons = load_postcode_polygons(boundaries_dir, max_postcodes) + print(f"Buffering {len(postcodes):,} postcode polygons by {buffer_m:g}m...") - _buffers, tree = _build_tree(polygons, buffer_m) + buffers, tree = _build_tree(polygons, buffer_m) + + # Area-normalisation factor (median_area / catchment_area): divides out the + # size of each postcode's catchment so the count measures crime density, not + # how much ground the buffer sweeps. We normalise by the *buffered* area -- + # the region that actually collects points -- rather than the raw polygon, so + # a tiny unit postcode isn't over-inflated by the fixed buffer-ring floor. + # Buffers are in EPSG:27700, so shapely.area is in m^2. + areas = shapely.area(buffers).astype(np.float64) + usable_area = np.isfinite(areas) & (areas > 0) + if not usable_area.any(): + raise ValueError("No postcode buffers have a positive area to normalise by") + median_area = float(np.median(areas[usable_area])) + norm = np.zeros(len(postcodes), dtype=np.float64) + norm[usable_area] = median_area / areas[usable_area] + print( + f"Area-normalising to median catchment area {median_area:,.0f} m^2 " + f"({int(usable_area.sum()):,}/{len(areas):,} postcodes have usable area)" + ) type_to_idx = {name: idx for idx, name in enumerate(ALL_CRIME_TYPES)} year_to_idx = {year: idx for idx, year in enumerate(years)} @@ -288,8 +374,8 @@ def transform_crime_spatial( transformer = Transformer.from_crs("EPSG:4326", "EPSG:27700", always_xy=True) _accumulate_counts(csvs, tree, type_to_idx, year_to_idx, transformer, counts) - _write_avg_yr(postcodes, counts, valid_month_count, output_path) - _write_by_year(postcodes, counts, years, months_in_year, by_year_output_path) + _write_avg_yr(postcodes, counts, years, months_in_year, norm, output_path) + _write_by_year(postcodes, counts, years, months_in_year, norm, by_year_output_path) def main() -> None: diff --git a/pipeline/transform/merge.py b/pipeline/transform/merge.py index 2001140..ff454bb 100644 --- a/pipeline/transform/merge.py +++ b/pipeline/transform/merge.py @@ -116,6 +116,66 @@ TREE_DENSITY_FEATURE = "Street tree density percentile" _POSTCODE_TREE_DENSITY_PERCENTILE_RE = re.compile( r"^Tree canopy density percentile within \d+m$" ) +_FINAL_DROP_COLUMNS = [ + "inspection_date", + "_bedrooms", + "LSOA name (2021)", + "Local Authority District code (2024)", + "Local Authority District name (2024)", + "Wider Barriers Sub-domain Score", + "Geographical Barriers Sub-domain Score", + "Adult Skills Sub-domain Score", + "Children and Young People Sub-domain Score", + "Crime Score", + "Living Environment Score", + "Index of Multiple Deprivation (IMD) Score", + "Income Deprivation Affecting Older People (IDAOPI) Score (rate)", + "Income Deprivation Affecting Children Index (IDACI) Score (rate)", + "Barriers to Housing and Services Score", + "oa21", + "pcon", + "epc_property_type", + "pp_property_type", + "built_form", +] +_FINAL_RENAME_COLUMNS = { + "date_of_transfer": "Date of last transaction", + "construction_age_band": "Construction year", + "is_construction_date_approximate": "Is construction date approximate", + "Income Score (rate)": "Income Score", + "Employment Score (rate)": "Employment Score", + "Indoors Sub-domain Score": "Housing Conditions Score", + "Outdoors Sub-domain Score": "Air Quality and Road Safety Score", + "pp_address": "Address per Property Register", + "epc_address": "Address per EPC", + "postcode": "Postcode", + "duration": "Leasehold/Freehold", + "current_energy_rating": "Current energy rating", + "potential_energy_rating": "Potential energy rating", + "total_floor_area": "Total floor area (sqm)", + "property_type": "Property type", + "restaurants_2km": "Number of restaurants within 2km", + "groceries_2km": "Number of grocery shops and supermarkets within 2km", + "latest_price": "Last known price", + "number_habitable_rooms": "Number of bedrooms & living rooms", + "noise_lden_db": "Noise (dB)", + "good_primary_5km": "Good+ primary schools within 5km", + "good_secondary_5km": "Good+ secondary schools within 5km", + "good_primary_2km": "Good+ primary schools within 2km", + "good_secondary_2km": "Good+ secondary schools within 2km", + "outstanding_primary_5km": "Outstanding primary schools within 5km", + "outstanding_secondary_5km": "Outstanding secondary schools within 5km", + "outstanding_primary_2km": "Outstanding primary schools within 2km", + "outstanding_secondary_2km": "Outstanding secondary schools within 2km", + "max_download_speed": "Max available download speed (Mbps)", + "serious_crime_avg_yr": "Serious crime (avg/yr)", + "minor_crime_avg_yr": "Minor crime (avg/yr)", + "mean_monthly_rent": "Estimated monthly rent", + "floor_height": "Interior height (m)", + "was_council_house": "Former council house", + "median_age": "Median age", + "turnout_pct": "Voter turnout (%)", +} _RENT_SOURCE_UNAVAILABLE_LADS = { # ONS PIPR does not publish LAD-level private-rent estimates for these # small authorities. Keep rent null there, but fail on any other LAD miss. @@ -707,6 +767,181 @@ def _validate_property_postcodes(df: pl.DataFrame) -> None: ) +def _active_english_postcode_area(arcgis_raw: pl.LazyFrame) -> pl.LazyFrame: + """Return the supported postcode universe with geography join keys.""" + return ( + arcgis_raw.filter(pl.col("ctry25cd") == "E92000001") + .filter(pl.col("doterm").is_null()) + .select( + pl.col("pcds").alias("postcode"), + "lat", + pl.col("long").alias("lon"), + "ctry25cd", + pl.col("lsoa21cd").alias("lsoa21"), + pl.col("oa21cd").alias("oa21"), + pl.col("pcon24cd").alias("pcon"), + ) + .drop_nulls(["postcode"]) + .unique(["postcode"]) + ) + + +def _remap_terminated_postcodes( + wide: pl.LazyFrame, postcode_mapping: pl.LazyFrame +) -> pl.LazyFrame: + return ( + wide.join( + postcode_mapping, + left_on="postcode", + right_on="old_postcode", + how="left", + ) + .with_columns( + pl.coalesce("new_postcode", "postcode").alias("postcode"), + ) + .drop("new_postcode") + ) + + +def _filter_to_active_english_postcodes( + wide: pl.LazyFrame, active_postcodes: pl.LazyFrame +) -> pl.LazyFrame: + return wide.join(active_postcodes, on="postcode", how="semi") + + +def _join_area_side_tables( + base: pl.LazyFrame, + *, + iod: pl.LazyFrame, + ethnicity: pl.LazyFrame, + crime: pl.LazyFrame, + median_age: pl.LazyFrame, + election: pl.LazyFrame, + poi_counts: pl.LazyFrame, + noise: pl.LazyFrame, + school_proximity: pl.LazyFrame, + conservation_areas: pl.LazyFrame, + tree_density: pl.LazyFrame | None, + broadband: pl.LazyFrame, +) -> pl.LazyFrame: + base = base.join(iod, left_on="lsoa21", right_on="LSOA code (2021)", how="left") + base = base.join( + ethnicity, + left_on="Local Authority District code (2024)", + right_on="Geography_code", + how="left", + ) + + # Crime is counted spatially per postcode (incidents within 50m of the + # postcode boundary), so it joins on postcode rather than LSOA. + base = base.join(crime, on="postcode", how="left") + base = base.with_columns( + pl.sum_horizontal( + "Violence and sexual offences (avg/yr)", + "Robbery (avg/yr)", + "Burglary (avg/yr)", + "Possession of weapons (avg/yr)", + ).alias("serious_crime_avg_yr"), + pl.sum_horizontal( + "Anti-social behaviour (avg/yr)", + "Criminal damage and arson (avg/yr)", + "Shoplifting (avg/yr)", + "Bicycle theft (avg/yr)", + "Theft from the person (avg/yr)", + "Other theft (avg/yr)", + "Vehicle crime (avg/yr)", + "Public order (avg/yr)", + "Drugs (avg/yr)", + "Other crime (avg/yr)", + ).alias("minor_crime_avg_yr"), + ) + + base = base.join(median_age, on="lsoa21", how="left") + base = base.join(election, on="pcon", how="left") + base = base.join(poi_counts, on="postcode", how="left") + base = base.join(noise, on="postcode", how="left") + base = base.join(school_proximity, on="postcode", how="left") + base = base.join(conservation_areas, on="postcode", how="left").with_columns( + pl.col(CONSERVATION_AREA_FEATURE).fill_null("No") + ) + if tree_density is not None: + base = base.join(tree_density, on="postcode", how="left") + return base.join(broadband, left_on="postcode", right_on="bb_postcode", how="left") + + +def _finalize_merged_columns(frame: pl.LazyFrame) -> pl.LazyFrame: + return frame.drop(_FINAL_DROP_COLUMNS, strict=False).rename( + _FINAL_RENAME_COLUMNS, strict=False + ) + + +def _area_columns_from(columns: list[str]) -> list[str]: + return [ + c for c in columns if c in _AREA_COLUMNS or _is_dynamic_poi_metric_column(c) + ] + + +def _property_columns_from(columns: list[str]) -> list[str]: + return [ + c + for c in columns + if (c not in _AREA_COLUMNS and not _is_dynamic_poi_metric_column(c)) + or c == "Postcode" + ] + + +def _validate_postcode_feature_output( + postcode_df: pl.DataFrame, expected_postcode_count: int +) -> None: + required = {"Postcode", "lat", "lon", "ctry25cd"} + missing = sorted(required - set(postcode_df.columns)) + if missing: + raise ValueError(f"Postcode feature output missing columns: {missing}") + + unique_count = postcode_df["Postcode"].n_unique() + if ( + postcode_df.height != expected_postcode_count + or unique_count != expected_postcode_count + ): + raise ValueError( + "Postcode feature output no longer matches the active England " + "postcode universe: " + f"rows={postcode_df.height:,}, unique={unique_count:,}, " + f"expected={expected_postcode_count:,}" + ) + + invalid = postcode_df.filter( + pl.col("Postcode").is_null() + | (pl.col("Postcode").cast(pl.Utf8).str.strip_chars() == "") + | pl.col("lat").is_null() + | pl.col("lon").is_null() + | pl.col("ctry25cd").is_null() + | (pl.col("ctry25cd") != "E92000001") + ) + if invalid.height > 0: + sample = ( + invalid.select("Postcode", "ctry25cd", "lat", "lon").head(10).to_dicts() + ) + raise ValueError( + "Postcode feature output contains unsupported or ungeocoded rows: " + f"{invalid.height} rows. Sample: {sample}" + ) + + +def _split_normal_outputs( + df: pl.DataFrame, + postcode_features: pl.DataFrame, + *, + expected_postcode_count: int, +) -> tuple[pl.DataFrame, pl.DataFrame]: + postcode_df = postcode_features.select( + _area_columns_from(postcode_features.columns) + ) + _validate_postcode_feature_output(postcode_df, expected_postcode_count) + properties_df = df.select(_property_columns_from(df.columns)) + return postcode_df, properties_df + + # Map listings-parquet source columns to the `_actual_*` overlay columns # carried alongside the wide frame through the postcode-keyed joins. After the # rest of the pipeline finalises, listing rows pick their canonical dashboard @@ -927,9 +1162,7 @@ def _best_listing_match( return best, float(best_score), "address", best_field -def _load_listings_for_merge( - listings_path: Path, arcgis_path: Path -) -> pl.DataFrame: +def _load_listings_for_merge(listings_path: Path, arcgis_path: Path) -> pl.DataFrame: """Read the listings parquet and prepare it for the wide-frame merge. Output is keyed by `_listing_idx` and carries: @@ -1032,7 +1265,11 @@ def _load_direct_epc_candidates( "_direct_epc_outcode": pl.Utf8, "_direct_epc_canonical_property_type": pl.Utf8, "_direct_epc_uprn": pl.Utf8, - **{column: dtype for column, dtype in _DIRECT_EPC_COLUMNS if column.startswith("_direct_")}, + **{ + column: dtype + for column, dtype in _DIRECT_EPC_COLUMNS + if column.startswith("_direct_") + }, } if not listing_outcodes: return pl.DataFrame(schema=schema) @@ -1089,9 +1326,7 @@ def _load_direct_epc_candidates( pl.col("epc_address").alias("_direct_epc_address"), pl.col("uprn").alias("_direct_epc_uprn"), pl.col("total_floor_area").alias("_direct_total_floor_area"), - pl.col("number_habitable_rooms").alias( - "_direct_number_habitable_rooms" - ), + pl.col("number_habitable_rooms").alias("_direct_number_habitable_rooms"), pl.col("floor_height").alias("_direct_floor_height"), pl.col("_direct_was_council_house").fill_null("No"), ) @@ -1141,9 +1376,7 @@ def _listing_match_frame(listings: pl.DataFrame) -> pl.DataFrame: ) -def _optional_lazy_col( - schema: pl.Schema, column: str, dtype: pl.DataType -) -> pl.Expr: +def _optional_lazy_col(schema: pl.Schema, column: str, dtype: pl.DataType) -> pl.Expr: if column in schema: return pl.col(column).cast(dtype, strict=False).alias(column) return pl.lit(None, dtype=dtype).alias(column) @@ -1640,27 +1873,18 @@ def _build( | (pl.col("total_floor_area") > MIN_FLOOR_AREA_M2) ) - # Remap terminated postcodes to nearest active successor + # Remap terminated postcodes to nearest active successor before filtering to + # the supported active-English postcode universe. Historical properties from + # terminated English postcodes are retained under their successor postcode. postcode_mapping = build_postcode_mapping(arcgis_path) - wide = ( - wide.join( - postcode_mapping.lazy(), - left_on="postcode", - right_on="old_postcode", - how="left", - ) - .with_columns( - pl.coalesce("new_postcode", "postcode").alias("postcode"), - ) - .drop("new_postcode") - ) - + wide = _remap_terminated_postcodes(wide, postcode_mapping.lazy()) arcgis_raw = pl.scan_parquet(arcgis_path) - postcode_country = arcgis_raw.select( - pl.col("pcds").alias("postcode"), - pl.col("ctry25cd"), - ).unique(["postcode"]) - wide = wide.join(postcode_country, on="postcode", how="left") + arcgis = _active_english_postcode_area(arcgis_raw) + active_postcodes = arcgis.select("postcode").unique() + active_postcode_count = ( + active_postcodes.select(pl.len()).collect(engine="streaming").item() + ) + wide = _filter_to_active_english_postcodes(wide, active_postcodes) if listed_buildings_path is not None: active_postcodes_for_listed = ( @@ -1691,92 +1915,25 @@ def _build( arcgis_path, epc_path=actual_listings_epc_path, ) + wide = _filter_to_active_english_postcodes(wide, active_postcodes) wide = wide.with_columns(pl.col(LISTED_BUILDING_FEATURE).fill_null("No")) - arcgis = ( - arcgis_raw.filter(pl.col("ctry25cd") == "E92000001") # England only - .filter(pl.col("doterm").is_null()) # Active postcodes only - # NSPL Feb 2026 renamed geographic code columns to {field}{year}cd. - # Alias them back to the short canonical names used across the - # pipeline so downstream joins don't need to know about NSPL's - # versioning scheme. - .select( - pl.col("pcds").alias("postcode"), - "lat", - pl.col("long").alias("lon"), - pl.col("lsoa21cd").alias("lsoa21"), - pl.col("oa21cd").alias("oa21"), - pl.col("pcon24cd").alias("pcon"), - ) - ) + # NSPL Feb 2026 renamed geographic code columns to {field}{year}cd. + # `_active_english_postcode_area` aliases them back to the short canonical + # names used across the pipeline so downstream joins don't need to know + # about NSPL's versioning scheme. wide = wide.join(arcgis, on="postcode", how="left") + postcode_area = arcgis iod = pl.scan_parquet(iod_path).with_columns( *(_less_deprived_percentile_expr(c) for c in _IOD_PERCENTILE_COLUMNS) ) - wide = wide.join(iod, left_on="lsoa21", right_on="LSOA code (2021)", how="left") - ethnicity = pl.scan_parquet(ethnicity_path) - wide = wide.join( - ethnicity, - left_on="Local Authority District code (2024)", - right_on="Geography_code", - how="left", - ) - - # Derive bedroom count: habitable rooms - 1 (assuming 1 reception room), clipped to 0..4 - wide = wide.with_columns( - (pl.col("number_habitable_rooms") - 1) - .clip(0, 4) - .cast(pl.UInt8) - .alias("_bedrooms"), - ) - rental = pl.scan_parquet(rental_prices_path).select( - "area_code", "bedrooms", "mean_monthly_rent" - ) - wide = wide.join( - rental, - left_on=["Local Authority District code (2024)", "_bedrooms"], - right_on=["area_code", "bedrooms"], - how="left", - ) - - # Crime is counted spatially per postcode (incidents within 50m of the - # postcode boundary), so it joins on postcode rather than LSOA. crime = pl.scan_parquet(crime_path) - wide = wide.join(crime, on="postcode", how="left") - - wide = wide.with_columns( - pl.sum_horizontal( - "Violence and sexual offences (avg/yr)", - "Robbery (avg/yr)", - "Burglary (avg/yr)", - "Possession of weapons (avg/yr)", - ).alias("serious_crime_avg_yr"), - pl.sum_horizontal( - "Anti-social behaviour (avg/yr)", - "Criminal damage and arson (avg/yr)", - "Shoplifting (avg/yr)", - "Bicycle theft (avg/yr)", - "Theft from the person (avg/yr)", - "Other theft (avg/yr)", - "Vehicle crime (avg/yr)", - "Public order (avg/yr)", - "Drugs (avg/yr)", - "Other crime (avg/yr)", - ).alias("minor_crime_avg_yr"), - ) - median_age = pl.scan_parquet(median_age_path) - wide = wide.join(median_age, on="lsoa21", how="left") - election = pl.scan_parquet(election_results_path) - wide = wide.join(election, on="pcon", how="left") - poi_counts = pl.scan_parquet(poi_proximity_path) - wide = wide.join(poi_counts, on="postcode", how="left") - noise_cols = ["road_noise_lden_db", "rail_noise_lden_db", "airport_noise_lden_db"] noise = ( pl.scan_parquet(noise_path) @@ -1789,21 +1946,13 @@ def _build( ) .select("postcode", "noise_lden_db") ) - wide = wide.join(noise, on="postcode", how="left") - school_proximity = pl.scan_parquet(school_proximity_path) - wide = wide.join(school_proximity, on="postcode", how="left") - conservation_areas = _conservation_area_by_postcode( arcgis.select("postcode", "lat", "lon"), conservation_areas_path ) - wide = wide.join(conservation_areas, on="postcode", how="left").with_columns( - pl.col(CONSERVATION_AREA_FEATURE).fill_null("No") - ) - + tree_density = None if tree_density_postcodes_path is not None: tree_density = _tree_density_by_postcode(tree_density_postcodes_path) - wide = wide.join(tree_density, on="postcode", how="left") # Broadband: derive max available download speed tier per postcode from # Ofcom availability percentages. Tiers: Gigabit ≥1000, UFBB ≥300, @@ -1828,7 +1977,38 @@ def _build( .agg(pl.col("max_download_speed").max()) .with_columns(pl.col("max_download_speed").cast(pl.Utf8)) ) - wide = wide.join(broadband, left_on="postcode", right_on="bb_postcode", how="left") + area_side_tables = { + "iod": iod, + "ethnicity": ethnicity, + "crime": crime, + "median_age": median_age, + "election": election, + "poi_counts": poi_counts, + "noise": noise, + "school_proximity": school_proximity, + "conservation_areas": conservation_areas, + "tree_density": tree_density, + "broadband": broadband, + } + wide = _join_area_side_tables(wide, **area_side_tables) + postcode_area = _join_area_side_tables(postcode_area, **area_side_tables) + + # Derive bedroom count: habitable rooms - 1 (assuming 1 reception room), clipped to 0..4 + wide = wide.with_columns( + (pl.col("number_habitable_rooms") - 1) + .clip(0, 4) + .cast(pl.UInt8) + .alias("_bedrooms"), + ) + rental = pl.scan_parquet(rental_prices_path).select( + "area_code", "bedrooms", "mean_monthly_rent" + ) + wide = wide.join( + rental, + left_on=["Local Authority District code (2024)", "_bedrooms"], + right_on=["area_code", "bedrooms"], + how="left", + ) # Derive property_type: prefer EPC data, fall back to price-paid. # For Houses, use built_form (e.g. Semi-Detached, Mid-Terrace) for finer detail. @@ -1862,112 +2042,40 @@ def _build( .alias("property_type") ) - wide = ( - wide.with_columns( - pl.when(pl.col("duration") == "U") - .then(None) - .otherwise(pl.col("duration")) - .alias("duration"), - pl.when(pl.col("current_energy_rating") == "INVALID!") - .then(None) - .otherwise(pl.col("current_energy_rating")) - .alias("current_energy_rating"), - ) - .with_columns( - (pl.col("latest_price") / pl.col("total_floor_area")) - .round(0) - .cast(pl.Int32) - .alias("Price per sqm"), - ) - .drop( - "inspection_date", - "_bedrooms", - "LSOA name (2021)", - "Local Authority District code (2024)", - "Local Authority District name (2024)", - "Wider Barriers Sub-domain Score", - "Geographical Barriers Sub-domain Score", - "Adult Skills Sub-domain Score", - "Children and Young People Sub-domain Score", - "Crime Score", - "Living Environment Score", - "Index of Multiple Deprivation (IMD) Score", - "Income Deprivation Affecting Older People (IDAOPI) Score (rate)", - "Income Deprivation Affecting Children Index (IDACI) Score (rate)", - "Barriers to Housing and Services Score", - "oa21", - "pcon", - "epc_property_type", - "pp_property_type", - "built_form", - ) - .rename( - { - "date_of_transfer": "Date of last transaction", - "construction_age_band": "Construction year", - "is_construction_date_approximate": "Is construction date approximate", - "Income Score (rate)": "Income Score", - "Employment Score (rate)": "Employment Score", - "Indoors Sub-domain Score": "Housing Conditions Score", - "Outdoors Sub-domain Score": "Air Quality and Road Safety Score", - "pp_address": "Address per Property Register", - "epc_address": "Address per EPC", - "postcode": "Postcode", - "duration": "Leasehold/Freehold", - "current_energy_rating": "Current energy rating", - "potential_energy_rating": "Potential energy rating", - "total_floor_area": "Total floor area (sqm)", - "property_type": "Property type", - "restaurants_2km": "Number of restaurants within 2km", - "groceries_2km": "Number of grocery shops and supermarkets within 2km", - "latest_price": "Last known price", - "number_habitable_rooms": "Number of bedrooms & living rooms", - "noise_lden_db": "Noise (dB)", - "good_primary_5km": "Good+ primary schools within 5km", - "good_secondary_5km": "Good+ secondary schools within 5km", - "good_primary_2km": "Good+ primary schools within 2km", - "good_secondary_2km": "Good+ secondary schools within 2km", - "outstanding_primary_5km": "Outstanding primary schools within 5km", - "outstanding_secondary_5km": "Outstanding secondary schools within 5km", - "outstanding_primary_2km": "Outstanding primary schools within 2km", - "outstanding_secondary_2km": "Outstanding secondary schools within 2km", - "max_download_speed": "Max available download speed (Mbps)", - "serious_crime_avg_yr": "Serious crime (avg/yr)", - "minor_crime_avg_yr": "Minor crime (avg/yr)", - "mean_monthly_rent": "Estimated monthly rent", - "floor_height": "Interior height (m)", - "was_council_house": "Former council house", - "median_age": "Median age", - "turnout_pct": "Voter turnout (%)", - } - ) + wide = wide.with_columns( + pl.when(pl.col("duration") == "U") + .then(None) + .otherwise(pl.col("duration")) + .alias("duration"), + pl.when(pl.col("current_energy_rating") == "INVALID!") + .then(None) + .otherwise(pl.col("current_energy_rating")) + .alias("current_energy_rating"), + ).with_columns( + (pl.col("latest_price") / pl.col("total_floor_area")) + .round(0) + .cast(pl.Int32) + .alias("Price per sqm"), ) + wide = _finalize_merged_columns(wide) + postcode_area = _finalize_merged_columns(postcode_area) print("Collecting with streaming engine...") - df = wide.collect(engine="streaming") if mode == "listings": + df = wide.collect(engine="streaming") enriched_listings = _finalize_listings(df) _validate_property_postcodes(enriched_listings) print(f"Enriched listings rows: {enriched_listings.height}") return _BuildResult(listings=enriched_listings) + df, postcode_features = pl.collect_all([wide, postcode_area], engine="streaming") _validate_property_postcodes(df) - # Split into postcode-level and property-level dataframes - area_cols = [ - c for c in df.columns if c in _AREA_COLUMNS or _is_dynamic_poi_metric_column(c) - ] - postcode_df = df.select(area_cols).group_by("Postcode").first() + postcode_df, properties_df = _split_normal_outputs( + df, postcode_features, expected_postcode_count=active_postcode_count + ) print(f"Postcode rows: {postcode_df.height} (unique postcodes)") - - property_cols = [ - c - for c in df.columns - if (c not in _AREA_COLUMNS and not _is_dynamic_poi_metric_column(c)) - or c == "Postcode" - ] - properties_df = df.select(property_cols) print(f"Property rows: {properties_df.height}") return _BuildResult(postcode=postcode_df, properties=properties_df) diff --git a/pipeline/transform/postcode_boundaries/output.py b/pipeline/transform/postcode_boundaries/output.py index 7aa010c..a224393 100644 --- a/pipeline/transform/postcode_boundaries/output.py +++ b/pipeline/transform/postcode_boundaries/output.py @@ -1,10 +1,12 @@ import json +import shutil from collections import defaultdict from pathlib import Path from pyproj import Transformer -from shapely import make_valid -from shapely.geometry import MultiPolygon, Polygon +from shapely import make_valid, set_precision +from shapely.geometry import MultiPolygon, Polygon, mapping, shape +from shapely.ops import transform as transform_geometry from shapely.ops import unary_union from tqdm import tqdm @@ -18,49 +20,47 @@ def _get_to_wgs84(): return _to_wgs84 +def _largest_polygonal(geom) -> Polygon | None: + if geom is None or geom.is_empty: + return None + if not geom.is_valid: + geom = make_valid(geom) + if geom.geom_type == "Polygon": + return geom + if geom.geom_type == "MultiPolygon": + return max(geom.geoms, key=lambda g: g.area) + if geom.geom_type == "GeometryCollection": + polygons = [ + polygon + for part in geom.geoms + if (polygon := _largest_polygonal(part)) is not None + ] + if polygons: + return max(polygons, key=lambda g: g.area) + return None + + def to_wgs84_geojson( geom: Polygon | MultiPolygon, tolerance: float = 1.0 ) -> dict | None: """Simplify geometry in BNG, convert to WGS84, return GeoJSON dict.""" - if geom.is_empty: + geom = _largest_polygonal(geom) + if geom is None: return None simplified = geom.simplify(tolerance, preserve_topology=True) - if simplified.is_empty: + simplified = _largest_polygonal(simplified) + if simplified is None: return None transformer = _get_to_wgs84() - - def transform_ring(coords): - xs, ys = zip(*coords) - lons, lats = transformer.transform(list(xs), list(ys)) - return [(round(lon, 6), round(lat, 6)) for lon, lat in zip(lons, lats)] - - def transform_polygon(poly): - exterior = transform_ring(poly.exterior.coords) - holes = [transform_ring(h.coords) for h in poly.interiors] - return [exterior] + holes - - # Force single Polygon — postcodes are contiguous delivery routes - if simplified.geom_type == "MultiPolygon": - simplified = max(simplified.geoms, key=lambda g: g.area) - elif simplified.geom_type == "GeometryCollection": - polys = [ - g for g in simplified.geoms if g.geom_type in ("Polygon", "MultiPolygon") - ] - if not polys: - return None - simplified = max(polys, key=lambda g: g.area) - if simplified.geom_type == "MultiPolygon": - simplified = max(simplified.geoms, key=lambda g: g.area) - - if simplified.geom_type != "Polygon" or simplified.is_empty: + wgs84 = transform_geometry(transformer.transform, simplified) + wgs84 = set_precision(wgs84, 0.000001, mode="valid_output") + wgs84 = _largest_polygonal(wgs84) + if wgs84 is None: return None - return { - "type": "Polygon", - "coordinates": transform_polygon(simplified), - } + return mapping(wgs84) def _fill_holes(geom): @@ -132,7 +132,11 @@ def write_district_geojson( ) -> int: """Group postcodes by district, write GeoJSON files. Returns file count.""" units_dir = output_dir / "units" - units_dir.mkdir(parents=True, exist_ok=True) + tmp_units_dir = output_dir / "units.tmp" + output_dir.mkdir(parents=True, exist_ok=True) + if tmp_units_dir.exists(): + shutil.rmtree(tmp_units_dir) + tmp_units_dir.mkdir(parents=True) by_district: dict[str, list[tuple[str, Polygon | MultiPolygon]]] = defaultdict(list) for pc, geom in postcodes.items(): @@ -141,14 +145,23 @@ def write_district_geojson( by_district[district].append((pc, geom)) file_count = 0 + seen_postcodes: set[str] = set() for district, entries in tqdm( sorted(by_district.items()), desc="Writing GeoJSON", unit="file" ): features = [] for pc, geom in sorted(entries, key=lambda x: x[0]): + if pc in seen_postcodes: + raise ValueError(f"Duplicate postcode boundary feature: {pc}") + seen_postcodes.add(pc) geojson_geom = to_wgs84_geojson(geom) if geojson_geom is None: - continue + raise ValueError(f"Postcode boundary collapsed to empty geometry: {pc}") + written_geom = shape(geojson_geom) + if written_geom.is_empty or not written_geom.is_valid: + raise ValueError( + f"Invalid postcode boundary geometry after output: {pc}" + ) mapit_code = pc.replace(" ", "") features.append( { @@ -165,9 +178,12 @@ def write_district_geojson( continue collection = {"type": "FeatureCollection", "features": features} - out_path = units_dir / f"{district}.geojson" + out_path = tmp_units_dir / f"{district}.geojson" with open(out_path, "w") as f: json.dump(collection, f, separators=(",", ":")) file_count += 1 + if units_dir.exists(): + shutil.rmtree(units_dir) + tmp_units_dir.replace(units_dir) return file_count diff --git a/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py b/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py index 7d83b80..165f9fe 100644 --- a/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py +++ b/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py @@ -3,6 +3,8 @@ Each test targets a specific bug or edge case identified during code review. """ +import json + import numpy as np import polars as pl import pytest @@ -11,7 +13,12 @@ from shapely.ops import unary_union from .oa_boundaries import parse_gpkg_geometry from .greenspace import subtract_greenspace -from .output import _fill_holes, merge_fragments, to_wgs84_geojson +from .output import ( + _fill_holes, + merge_fragments, + to_wgs84_geojson, + write_district_geojson, +) from .process_oa import _extract_polygonal, process_oa from .uprn import get_oa_uprns, load_uprns from .voronoi import _equal_split_fallback, compute_voronoi_regions @@ -154,6 +161,7 @@ class TestWhitespacePostcodes: "pcds": ["AA1 1AA", "AA1 1AB"], "east1m": [500010, 500030], "north1m": [180010, 180020], + "oa21cd": ["E00000001", "E00000001"], "doterm": ["2020-01-01", None], "ctry25cd": ["E92000001", "E92000001"], } @@ -165,6 +173,65 @@ class TestWhitespacePostcodes: assert loaded_df["PCDS"].to_list() == ["AA1 1AB"] + def test_arcgis_filters_to_active_english_postcodes(self, tmp_path): + uprns = pl.DataFrame( + { + "GRIDGB1E": [500010, 500020], + "GRIDGB1N": [180010, 180020], + "PCDS": ["AA1 1AA", "CF1 1AA"], + "OA21CD": ["E00000001", "E00000001"], + } + ) + uprn_path = tmp_path / "uprn.parquet" + uprns.write_parquet(uprn_path) + arcgis = pl.DataFrame( + { + "pcds": ["AA1 1AA", "CF1 1AA"], + "east1m": [500010, 300010], + "north1m": [180010, 220010], + "oa21cd": ["E00000001", "W00000001"], + "doterm": [None, None], + "ctry25cd": ["E92000001", "W92000004"], + } + ) + arcgis_path = tmp_path / "arcgis.parquet" + arcgis.write_parquet(arcgis_path) + + loaded_df, _offsets = load_uprns(uprn_path, arcgis_path) + + assert loaded_df["PCDS"].to_list() == ["AA1 1AA"] + + def test_arcgis_adds_centroid_seed_for_active_postcode_without_uprn(self, tmp_path): + uprns = pl.DataFrame( + { + "GRIDGB1E": [500010], + "GRIDGB1N": [180010], + "PCDS": ["AA1 1AA"], + "OA21CD": ["E00000001"], + } + ) + uprn_path = tmp_path / "uprn.parquet" + uprns.write_parquet(uprn_path) + arcgis = pl.DataFrame( + { + "pcds": ["AA1 1AA", "BB1 1BB"], + "east1m": [500010, 510000], + "north1m": [180010, 190000], + "oa21cd": ["E00000001", "E00000002"], + "doterm": [None, None], + "ctry25cd": ["E92000001", "E92000001"], + } + ) + arcgis_path = tmp_path / "arcgis.parquet" + arcgis.write_parquet(arcgis_path) + + loaded_df, offsets = load_uprns(uprn_path, arcgis_path) + + assert set(loaded_df["PCDS"].to_list()) == {"AA1 1AA", "BB1 1BB"} + points, postcodes = get_oa_uprns(loaded_df, offsets, "E00000002") + assert postcodes == ["BB1 1BB"] + assert points.tolist() == [[510000.0, 190000.0]] + # --------------------------------------------------------------------------- # Bug 3: Voronoi deduplication is first-seen-wins @@ -450,7 +517,9 @@ class TestProcessOAInspireParcelAssignment: ) postcodes = ["A", "B"] - fragments = process_oa(oa_geom, points, postcodes, inspire_candidates=[left, right]) + fragments = process_oa( + oa_geom, points, postcodes, inspire_candidates=[left, right] + ) frag_dict = dict(fragments) assert "A" in frag_dict and "B" in frag_dict @@ -494,7 +563,9 @@ class TestProcessOAInspireParcelAssignment: ) postcodes = ["A", "B"] - fragments = process_oa(oa_geom, points, postcodes, inspire_candidates=[left, right]) + fragments = process_oa( + oa_geom, points, postcodes, inspire_candidates=[left, right] + ) frag_dict = dict(fragments) assert "A" in frag_dict and "B" in frag_dict @@ -539,7 +610,9 @@ class TestProcessOAInspireParcelAssignment: ) postcodes = ["A", "B"] - fragments = process_oa(oa_geom, points, postcodes, inspire_candidates=[straddling]) + fragments = process_oa( + oa_geom, points, postcodes, inspire_candidates=[straddling] + ) for _, geom in fragments: assert geom.difference(oa_geom).area < 0.01 @@ -651,6 +724,22 @@ class TestToWgs84Geojson: assert lon_dp <= 6, f"Longitude {lon_s} has {lon_dp} decimal places" assert lat_dp <= 6, f"Latitude {lat_s} has {lat_dp} decimal places" + def test_write_district_geojson_replaces_stale_units(self, tmp_path): + stale_units = tmp_path / "units" + stale_units.mkdir() + (stale_units / "ZZ1.geojson").write_text( + json.dumps({"type": "FeatureCollection", "features": []}) + ) + + file_count = write_district_geojson( + {"AA1 1AA": box(530000, 180000, 530100, 180100)}, tmp_path + ) + + assert file_count == 1 + assert not (stale_units / "ZZ1.geojson").exists() + written = json.loads((stale_units / "AA1.geojson").read_text()) + assert written["features"][0]["properties"]["postcodes"] == "AA1 1AA" + # --------------------------------------------------------------------------- # Edge case: parse_gpkg_geometry rejects unknown envelope types diff --git a/pipeline/transform/postcode_boundaries/uprn.py b/pipeline/transform/postcode_boundaries/uprn.py index d4c7557..180f68f 100644 --- a/pipeline/transform/postcode_boundaries/uprn.py +++ b/pipeline/transform/postcode_boundaries/uprn.py @@ -13,6 +13,33 @@ def _canonical_postcode_expr(name: str) -> pl.Expr: return pl.col(name).str.strip_chars().str.to_uppercase() +def _active_english_arcgis_postcodes(arcgis_path: Path) -> pl.LazyFrame: + return ( + pl.read_parquet( + arcgis_path, + columns=["pcds", "east1m", "north1m", "oa21cd", "ctry25cd", "doterm"], + ) + .lazy() + .filter(pl.col("ctry25cd") == "E92000001") + .filter(pl.col("doterm").cast(pl.Utf8).is_null()) + .select( + _canonical_postcode_expr("pcds").alias("PCDS"), + pl.col("east1m").cast(pl.Float64).alias("GRIDGB1E"), + pl.col("north1m").cast(pl.Float64).alias("GRIDGB1N"), + pl.col("oa21cd").alias("OA21CD"), + ) + .filter( + pl.col("PCDS").is_not_null() + & (pl.col("PCDS") != "") + & pl.col("GRIDGB1E").is_not_null() + & pl.col("GRIDGB1N").is_not_null() + & pl.col("OA21CD").is_not_null() + & pl.col("OA21CD").str.starts_with("E") + ) + .unique("PCDS") + ) + + def load_uprns( uprn_path: Path, arcgis_path: Path | None = None ) -> tuple[pl.DataFrame, dict[str, tuple[int, int]]]: @@ -25,6 +52,7 @@ def load_uprns( print("Loading UPRN lookup...") mapping = None + active_postcode_points = None if arcgis_path is not None: mapping = ( build_postcode_mapping(arcgis_path) @@ -34,6 +62,7 @@ def load_uprns( ) .unique("old_postcode") ) + active_postcode_points = _active_english_arcgis_postcodes(arcgis_path) # Sort via streaming sink to avoid polars doubling memory during in-memory sort with tempfile.NamedTemporaryFile( @@ -51,11 +80,21 @@ def load_uprns( if mapping is not None and mapping.height > 0: uprns = ( - uprns.join(mapping.lazy(), left_on="PCDS", right_on="old_postcode", how="left") + uprns.join( + mapping.lazy(), left_on="PCDS", right_on="old_postcode", how="left" + ) .with_columns(pl.coalesce("new_postcode", "PCDS").alias("PCDS")) .select("GRIDGB1E", "GRIDGB1N", "PCDS", "OA21CD") ) + if active_postcode_points is not None: + active_postcodes = active_postcode_points.select("PCDS").unique() + uprns = uprns.join(active_postcodes, on="PCDS", how="semi") + missing_active = active_postcode_points.join( + uprns.select("PCDS").unique(), on="PCDS", how="anti" + ).select("GRIDGB1E", "GRIDGB1N", "PCDS", "OA21CD") + uprns = pl.concat([uprns, missing_active], how="vertical_relaxed") + uprns.sort("OA21CD").sink_parquet(tmp_path) release_memory() diff --git a/pipeline/transform/test_crime_hotspot_tiles.py b/pipeline/transform/test_crime_hotspot_tiles.py new file mode 100644 index 0000000..098173d --- /dev/null +++ b/pipeline/transform/test_crime_hotspot_tiles.py @@ -0,0 +1,52 @@ +import json + +from pipeline.transform.crime_hotspot_tiles import _write_geojsonseq + +_HEADER = ( + "Crime ID,Month,Reported by,Falls within,Longitude,Latitude,Location," + "LSOA code,LSOA name,Crime type,Last outcome category,Context" +) + + +def _row(lon, lat, month, crime_type): + return f",{month},F,F,{lon},{lat},On or near X,E01000001,L,{crime_type},U," + + +def _write_csv(path, rows): + path.write_text("\n".join([_HEADER, *rows]) + "\n") + + +def test_write_geojsonseq_collapses_shared_anchors_into_weighted_features(tmp_path): + csv = tmp_path / "2024-01-test-street.csv" + _write_csv( + csv, + [ + # Two incidents snapped to the exact same anchor/month/type -> one + # feature with count=2. + _row(-0.1, 51.5, "2024-01", "Burglary"), + _row(-0.1, 51.5, "2024-01", "Burglary"), + # Same coord, different crime type -> kept separate (per-type filter). + _row(-0.1, 51.5, "2024-01", "Robbery"), + # Out of bounds -> dropped entirely. + _row(-0.1, 80.0, "2024-01", "Burglary"), + # Missing coordinate -> dropped entirely. + _row("", "", "2024-01", "Burglary"), + ], + ) + + out = tmp_path / "hotspots.geojsonseq" + feature_count, incident_count = _write_geojsonseq([csv], out) + + features = [json.loads(line) for line in out.read_text().splitlines()] + assert feature_count == 2 + assert incident_count == 3 # 2 burglaries + 1 robbery, in-bounds only + + by_type = {f["properties"]["crime_type"]: f["properties"] for f in features} + # The busy anchor is a single feature carrying its full incident weight, + # so tippecanoe's density thinning can no longer silently erase it. + assert by_type["Burglary"]["count"] == 2 + assert by_type["Burglary"]["weight"] == 2 + assert by_type["Robbery"]["count"] == 1 + # Geometry preserved as [lon, lat]. + assert by_type["Burglary"]["count"] == 2 + assert all(f["geometry"]["coordinates"] == [-0.1, 51.5] for f in features) diff --git a/pipeline/transform/test_crime_spatial.py b/pipeline/transform/test_crime_spatial.py index b180008..7e6f372 100644 --- a/pipeline/transform/test_crime_spatial.py +++ b/pipeline/transform/test_crime_spatial.py @@ -1,9 +1,13 @@ import json +import numpy as np import polars as pl +import pytest +import shapely from pyproj import Transformer from pipeline.transform.crime_spatial import transform_crime_spatial +from pipeline.transform.postcode_boundaries.loader import load_postcode_polygons _TO_WGS84 = Transformer.from_crs("EPSG:27700", "EPSG:4326", always_xy=True) @@ -82,7 +86,10 @@ def test_buffer_overlap_counts_for_each_postcode(tmp_path): output = tmp_path / "crime_by_postcode.parquet" by_year = tmp_path / "crime_by_postcode_by_year.parquet" - transform_crime_spatial(crime, units, output, by_year) + # Pin the 50m buffer the geometry above was designed around (the production + # default is now 100m). The three squares are equal-area, so area + # normalisation leaves the counts unchanged. + transform_crime_spatial(crime, units, output, by_year, buffer_m=50.0) rows = { r["postcode"]: r @@ -127,7 +134,7 @@ def test_by_year_annualises_and_rolls_up(tmp_path): output = tmp_path / "crime_by_postcode.parquet" by_year = tmp_path / "crime_by_postcode_by_year.parquet" - transform_crime_spatial(crime, units, output, by_year) + transform_crime_spatial(crime, units, output, by_year, buffer_m=50.0) by_year_df = pl.read_parquet(by_year) assert by_year_df.height == 1 @@ -145,3 +152,130 @@ def test_by_year_annualises_and_rolls_up(tmp_path): # 2023 serious = Burglary(12) + Robbery(12) = 24; 2024 = Burglary(12). assert serious[2023] == 24.0 assert serious[2024] == 12.0 + + +def test_area_normalisation_divides_out_buffered_catchment(tmp_path): + # Three postcodes of increasing footprint, each with exactly one incident in + # its buffer. Normalisation rescales by median_catchment / buffered_area, so + # the smallest scores highest and the median-sized one is unchanged -- i.e. + # the metric is a density. Dividing by the *buffered* catchment (not the raw + # polygon) means the fixed buffer-ring floor keeps the spread gentle, so the + # tiniest postcode is not blown up out of proportion. + units = tmp_path / "units" + _write_boundaries( + units, + { + "AB1": [ + _square_feature("AB1 1AA", 1000, 1000, 1010, 1010), # 10x10 + _square_feature("AB1 1AB", 3000, 3000, 3010, 3020), # 10x20 (median) + _square_feature("AB1 1AC", 5000, 5000, 5020, 5020), # 20x20 + ] + }, + ) + + crime = tmp_path / "crime" + _write_month( + crime, + "2024-01", + [ + _crime_row("2024-01", 1005, 1005, "Burglary"), + _crime_row("2024-01", 3005, 3010, "Burglary"), + _crime_row("2024-01", 5010, 5010, "Burglary"), + ], + ) + + output = tmp_path / "crime_by_postcode.parquet" + by_year = tmp_path / "crime_by_postcode_by_year.parquet" + transform_crime_spatial(crime, units, output, by_year, buffer_m=50.0) + + # Re-derive the expected values from the same buffered catchment areas: each + # postcode is 12/yr before normalisation, then x (median_buf / buffered_area). + postcodes, polygons = load_postcode_polygons(units) + buf_area = { + pc: float(shapely.area(shapely.buffer(poly, 50.0, quad_segs=8))) + for pc, poly in zip(postcodes, polygons) + } + median_buf = float(np.median(list(buf_area.values()))) + expected = {pc: 12.0 * median_buf / buf_area[pc] for pc in buf_area} + + rows = {r["postcode"]: r for r in pl.read_parquet(output).to_dicts()} + for pc, exp in expected.items(): + assert rows[pc]["Burglary (avg/yr)"] == pytest.approx(exp, abs=0.1) + + # Median catchment unchanged; ordering is by inverse buffered area, but the + # buffer-ring floor keeps the spread far below the ~4x raw-area ratio. + assert rows["AB1 1AB"]["Burglary (avg/yr)"] == pytest.approx(12.0, abs=0.05) + small = rows["AB1 1AA"]["Burglary (avg/yr)"] + big = rows["AB1 1AC"]["Burglary (avg/yr)"] + assert small > 12.0 > big + assert small / big < 1.5 + + # by-year series carries the same normalisation. + by_year_df = pl.read_parquet(by_year) + small_row = by_year_df.filter(pl.col("postcode") == "AB1 1AA").row(0, named=True) + assert small_row["Burglary (by year)"] == [ + {"year": 2024, "count": pytest.approx(expected["AB1 1AA"], abs=0.1)} + ] + + +def test_avg_yr_is_simple_mean_of_year_bars(tmp_path): + # Uneven month coverage across years: 2023 has 1 month (2 incidents -> 24/yr), + # 2024 has 2 months (2 incidents -> 12/yr). The headline must be the *simple* + # mean of the bars (24+12)/2 = 18, not the month-weighted pooled rate + # (4 incidents / 3 months * 12 = 16). + units = tmp_path / "units" + _write_boundaries( + units, {"AB1": [_square_feature("AB1 1AA", 1000, 1000, 1010, 1010)]} + ) + + crime = tmp_path / "crime" + _write_month( + crime, + "2023-01", + [ + _crime_row("2023-01", 1005, 1005, "Burglary"), + _crime_row("2023-01", 1005, 1005, "Burglary"), + ], + ) + _write_month(crime, "2024-01", [_crime_row("2024-01", 1005, 1005, "Burglary")]) + _write_month(crime, "2024-02", [_crime_row("2024-02", 1005, 1005, "Burglary")]) + + output = tmp_path / "crime_by_postcode.parquet" + by_year = tmp_path / "crime_by_postcode_by_year.parquet" + transform_crime_spatial(crime, units, output, by_year, buffer_m=50.0) + + avg = pl.read_parquet(output).row(0, named=True) + assert avg["Burglary (avg/yr)"] == pytest.approx(18.0, abs=0.05) + + row = pl.read_parquet(by_year).row(0, named=True) + bars = {p["year"]: p["count"] for p in row["Burglary (by year)"]} + assert bars == {2023: pytest.approx(24.0, abs=0.05), 2024: pytest.approx(12.0, abs=0.05)} + + +def test_unknown_crime_type_is_dropped_with_warning(tmp_path, capsys): + units = tmp_path / "units" + _write_boundaries( + units, {"AB1": [_square_feature("AB1 1AA", 1000, 1000, 1010, 1010)]} + ) + + crime = tmp_path / "crime" + _write_month( + crime, + "2024-01", + [ + _crime_row("2024-01", 1005, 1005, "Burglary"), + _crime_row("2024-01", 1005, 1005, "Cyber fraud"), + ], + ) + + output = tmp_path / "crime_by_postcode.parquet" + by_year = tmp_path / "crime_by_postcode_by_year.parquet" + transform_crime_spatial(crime, units, output, by_year, buffer_m=50.0) + + columns = pl.read_parquet(output).columns + # The unknown type is dropped (no column for it) but a warning is emitted. + assert "Cyber fraud (avg/yr)" not in columns + assert "Burglary (avg/yr)" in columns + err = capsys.readouterr().err + assert "Cyber fraud" in err + assert "WARNING" in err diff --git a/pipeline/transform/test_merge.py b/pipeline/transform/test_merge.py index 702c425..7672d55 100644 --- a/pipeline/transform/test_merge.py +++ b/pipeline/transform/test_merge.py @@ -10,8 +10,10 @@ from pipeline.transform.merge import ( LISTED_BUILDING_FEATURE, TREE_DENSITY_FEATURE, _LISTING_OVERLAY_SOURCES, + _active_english_postcode_area, _build_unmatched_listing_seed_rows, _canonical_postcode_expr, + _filter_to_active_english_postcodes, _finalize_listings, _integrate_listings, _match_direct_epc, @@ -24,8 +26,11 @@ from pipeline.transform.merge import ( _matched_listed_building_flags, _postcode_conservation_area_flags, _postcode_listed_building_candidates, + _remap_terminated_postcodes, + _split_normal_outputs, _tree_density_by_postcode, _validate_lad_source_coverage, + _validate_postcode_feature_output, _validate_property_postcodes, ) @@ -79,6 +84,113 @@ def test_crime_columns_are_spatial_counts_not_per_capita() -> None: assert "Minor crime per 1k residents (avg/yr)" not in _AREA_COLUMNS +def test_active_english_postcode_area_filters_to_active_england() -> None: + arcgis = pl.DataFrame( + { + "pcds": ["AA1 1AA", "AA1 1AB", "CF1 1AA"], + "ctry25cd": ["E92000001", "E92000001", "W92000004"], + "doterm": [None, "2020-01-01", None], + "lat": [51.0, 51.1, 52.0], + "long": [-0.1, -0.2, -3.0], + "lsoa21cd": ["L1", "L2", "L3"], + "oa21cd": ["O1", "O2", "O3"], + "pcon24cd": ["P1", "P2", "P3"], + } + ) + + result = _active_english_postcode_area(arcgis.lazy()).collect() + + assert result.to_dicts() == [ + { + "postcode": "AA1 1AA", + "lat": 51.0, + "lon": -0.1, + "ctry25cd": "E92000001", + "lsoa21": "L1", + "oa21": "O1", + "pcon": "P1", + } + ] + + +def test_remap_then_active_filter_keeps_terminated_english_properties() -> None: + wide = pl.DataFrame( + { + "postcode": ["OLD 1AA", "NEW 1AA", "CF1 1AA"], + "row_id": [1, 2, 3], + } + ).lazy() + mapping = pl.DataFrame( + {"old_postcode": ["OLD 1AA"], "new_postcode": ["NEW 1AA"]} + ).lazy() + active_postcodes = pl.DataFrame({"postcode": ["NEW 1AA"]}).lazy() + + result = ( + _filter_to_active_english_postcodes( + _remap_terminated_postcodes(wide, mapping), active_postcodes + ) + .collect() + .sort("row_id") + ) + + assert result.to_dicts() == [ + {"postcode": "NEW 1AA", "row_id": 1}, + {"postcode": "NEW 1AA", "row_id": 2}, + ] + + +def test_split_normal_outputs_uses_postcode_feature_universe() -> None: + df = pl.DataFrame( + { + "Postcode": ["AA1 1AA"], + "Address per Property Register": ["1 Example Road"], + "Last known price": [250_000], + "lat": [51.0], + "lon": [-0.1], + "ctry25cd": ["E92000001"], + "lsoa21": ["L1"], + } + ) + postcode_features = pl.DataFrame( + { + "Postcode": ["AA1 1AA", "BB1 1BB"], + "lat": [51.0, 52.0], + "lon": [-0.1, -0.2], + "ctry25cd": ["E92000001", "E92000001"], + "lsoa21": ["L1", "L2"], + "Distance to nearest amenity (Park) (km)": [0.3, 0.8], + } + ) + + postcode_df, properties_df = _split_normal_outputs( + df, postcode_features, expected_postcode_count=2 + ) + + assert postcode_df["Postcode"].to_list() == ["AA1 1AA", "BB1 1BB"] + assert "Distance to nearest amenity (Park) (km)" in postcode_df.columns + assert properties_df.to_dicts() == [ + { + "Postcode": "AA1 1AA", + "Address per Property Register": "1 Example Road", + "Last known price": 250_000, + } + ] + + +def test_postcode_feature_validation_rejects_unsupported_or_ungeocoded_rows() -> None: + postcode_df = pl.DataFrame( + { + "Postcode": ["AA1 1AA", "CF1 1AA"], + "lat": [51.0, None], + "lon": [-0.1, None], + "ctry25cd": ["E92000001", "W92000004"], + } + ) + + with pytest.raises(ValueError, match="unsupported or ungeocoded"): + _validate_postcode_feature_output(postcode_df, expected_postcode_count=2) + + def test_listed_building_feature_is_property_level() -> None: assert LISTED_BUILDING_FEATURE not in _AREA_COLUMNS @@ -418,9 +530,7 @@ def test_build_unmatched_listing_seed_rows_fills_property_shape_fields( ) unmatched_idxs = listings.select("_listing_idx") - seed = _build_unmatched_listing_seed_rows( - unmatched_idxs, listings, template_schema - ) + seed = _build_unmatched_listing_seed_rows(unmatched_idxs, listings, template_schema) assert seed.height == 1 assert seed["postcode"].to_list() == ["SW1A 1AA"] @@ -550,7 +660,12 @@ def test_match_direct_epc_matches_by_uprn_across_postcodes() -> None: [{"_listing_uprn": "100000000001", "_listing_match_postcode": "ZZ99ZZ"}] ), _direct_epc_candidates( - [{"_direct_epc_uprn": "100000000001", "_direct_epc_match_postcode": "AA11AA"}] + [ + { + "_direct_epc_uprn": "100000000001", + "_direct_epc_match_postcode": "AA11AA", + } + ] ), ) diff --git a/pipeline/transform/test_tree_density.py b/pipeline/transform/test_tree_density.py index f4dd48f..340d9ec 100644 --- a/pipeline/transform/test_tree_density.py +++ b/pipeline/transform/test_tree_density.py @@ -1,81 +1,105 @@ import math +import zipfile from pathlib import Path import numpy as np import polars as pl +import pyogrio import pytest import shapely from pipeline.transform.tree_density import ( - STREET_TREE_COVERAGE_COL, - STREET_TREE_DENSITY_COL, - _add_nfi_batch, + _accumulate_clipped_area, _coverage_percentile_expr, + _finalize_metrics, + _geometry_column, + _layers, _metric_columns, + _nfi_dataset_path, _postcode_buffers, _postcode_density_percentile_col, + _safe_extract_zip_dir, _with_postcode_density_percentiles, - _write_street_rollups, ) -def test_nfi_accumulation_adds_only_clipped_overlap_area() -> None: +def test_accumulate_clipped_area_adds_only_in_buffer_overlap() -> None: radius_m = 50 points = pl.DataFrame({"postcode": ["A", "B"], "x": [0.0, 1000.0], "y": [0.0, 0.0]}) circles, tree = _postcode_buffers(points, radius_m) buffer_area = math.pi * radius_m * radius_m - # A large woodland square centred on postcode A fully covers A's circle. + # A large square centred on postcode A fully covers A's buffer circle. canopy_area = np.zeros(2) - feature_count = np.zeros(2, dtype=np.uint32) big = shapely.box(-500, -500, 500, 500) # 1,000,000 sqm parcel - _add_nfi_batch( - np.array([big], dtype=object), - np.array(["Woodland"], dtype=object), - circles, - tree, - canopy_area, - feature_count, - radius_m, - ) + _accumulate_clipped_area(np.array([big], dtype=object), circles, tree, canopy_area) # Only the clipped circle area is added (the 32-gon buffer approximates the # circle to ~1%), NOT the full 1,000,000 sqm polygon. assert canopy_area[0] == pytest.approx(buffer_area, rel=1e-2) - assert canopy_area[0] <= buffer_area # never exceeds the buffer area + assert canopy_area[0] <= buffer_area # never exceeds the true buffer area assert canopy_area[1] == 0.0 # postcode B is 1km away, no overlap - assert feature_count.tolist() == [1, 0] # A large parcel that only slivers into B's circle must add only the sliver, - # not its full area -- the failure mode the old centroid path could not avoid. + # not its full area -- the failure mode a centroid/full-area path could not avoid. canopy_area = np.zeros(2) - feature_count = np.zeros(2, dtype=np.uint32) sliver = shapely.box(1040, -500, 2000, 500) # left edge 10m inside B's circle - _add_nfi_batch( - np.array([sliver], dtype=object), - np.array(["Woodland"], dtype=object), - circles, - tree, - canopy_area, - feature_count, - radius_m, + _accumulate_clipped_area( + np.array([sliver], dtype=object), circles, tree, canopy_area ) assert canopy_area[0] == 0.0 assert 0.0 < canopy_area[1] < buffer_area # tiny segment, far below 1M sqm - # Non-woodland categories contribute nothing. - canopy_area = np.zeros(2) - feature_count = np.zeros(2, dtype=np.uint32) - _add_nfi_batch( - np.array([big], dtype=object), - np.array(["Non woodland"], dtype=object), + +def test_accumulate_clipped_area_drops_missing_and_empty_geometry() -> None: + radius_m = 50 + points = pl.DataFrame({"postcode": ["A"], "x": [0.0], "y": [0.0]}) + circles, tree = _postcode_buffers(points, radius_m) + + canopy_area = np.zeros(1) + geoms = np.array( + [None, shapely.from_wkt("POLYGON EMPTY"), shapely.box(-10, -10, 10, 10)], + dtype=object, + ) + # A None and an empty geometry must be skipped, not crash, and only the real + # 400 sqm box is accumulated (it is fully inside the buffer). + _accumulate_clipped_area(geoms, circles, tree, canopy_area) + assert canopy_area[0] == pytest.approx(400.0) + + +def test_accumulate_clipped_area_height_weighted_by_overlap() -> None: + radius_m = 50 + points = pl.DataFrame({"postcode": ["A"], "x": [0.0], "y": [0.0]}) + circles, tree = _postcode_buffers(points, radius_m) + + canopy_area = np.zeros(1) + height_weighted_sum = np.zeros(1) + height_weight = np.zeros(1) + geoms = np.array( + [ + shapely.box(-10, -10, 0, 0), # 100 sqm, fully inside + shapely.box(0, 0, 20, 20), # 400 sqm, fully inside + shapely.box(-5, 0, 0, 5), # 25 sqm, NaN height -> ignored for height + ], + dtype=object, + ) + height = np.array([5.0, 10.0, np.nan]) + + _accumulate_clipped_area( + geoms, circles, tree, canopy_area, - feature_count, - radius_m, + height=height, + height_weighted_sum=height_weighted_sum, + height_weight=height_weight, ) - assert canopy_area.tolist() == [0.0, 0.0] - assert feature_count.tolist() == [0, 0] + + # All three clipped areas count toward canopy; only the finite-height ones + # contribute to the area-weighted mean height. + assert canopy_area[0] == pytest.approx(525.0) + assert height_weight[0] == pytest.approx(500.0) + mean_height = height_weighted_sum[0] / height_weight[0] + assert mean_height == pytest.approx((5.0 * 100 + 10.0 * 400) / 500) # 9.0 def test_coverage_percentile_expr_ranks_higher_coverage_higher() -> None: @@ -88,76 +112,142 @@ def test_coverage_percentile_expr_ranks_higher_coverage_higher() -> None: assert result["percentile"].to_list() == [0.0, 50.0, 100.0, None] -def test_coverage_percentile_expr_uses_exact_scale_endpoints() -> None: +def test_coverage_percentile_expr_uses_tie_consistent_average_rank() -> None: + # Tied extremes share their mean rank instead of being pinned to exact 0/100, + # so the whole scale runs on one consistent average-rank formula. df = pl.DataFrame({"coverage": [0.0, 0.0, 5.0, 10.0, 10.0]}) result = df.lazy().with_columns( _coverage_percentile_expr("coverage", "percentile") ).collect() - assert result["percentile"].to_list() == [0.0, 0.0, 50.0, 100.0, 100.0] + assert result["percentile"].to_list() == [12.5, 12.5, 50.0, 87.5, 87.5] -def test_street_rollup_percentiles_are_ranked_over_raw_street_coverage( - tmp_path: Path, -) -> None: +def test_coverage_percentile_expr_all_equal_is_neutral_midpoint() -> None: + all_equal = pl.DataFrame({"coverage": [5.0, 5.0, 5.0]}) + single = pl.DataFrame({"coverage": [7.0]}) + with_null = pl.DataFrame({"coverage": [None, 5.0, 5.0, 5.0]}) + + def percentiles(df: pl.DataFrame) -> list: + return ( + df.lazy() + .with_columns(_coverage_percentile_expr("coverage", "percentile")) + .collect()["percentile"] + .to_list() + ) + + assert percentiles(all_equal) == [50.0, 50.0, 50.0] + assert percentiles(single) == [50.0] + assert percentiles(with_null) == [None, 50.0, 50.0, 50.0] + + +def test_finalize_metrics_caps_density_keeps_raw_area_and_weights_height() -> None: radius_m = 50 - density_col, area_col, count_col, height_col = _metric_columns(radius_m) + buffer_area = math.pi * radius_m * radius_m + density_col, area_col, height_col = _metric_columns(radius_m) + + points = pl.DataFrame({"postcode": ["AA1 1AA", "AA1 1AB", "AA1 1AC"]}) + canopy_area = np.array([0.0, buffer_area * 0.5, buffer_area * 2.0]) + # Postcode 0: no height samples -> null. Postcode 1: area-weighted mean = 5. + height_weighted_sum = np.array([0.0, 500.0, 0.0]) + height_weight = np.array([0.0, 100.0, 0.0]) + + metrics = _finalize_metrics( + points, canopy_area, height_weighted_sum, height_weight, radius_m + ) + + assert metrics[density_col].to_list() == [0.0, 50.0, 100.0] # capped at 100 + # area_col is the raw clipped accumulation, intentionally uncapped. + assert metrics[area_col].to_list() == pytest.approx( + [0.0, round(buffer_area * 0.5, 1), round(buffer_area * 2.0, 1)] + ) + assert metrics[height_col].to_list() == [None, 5.0, None] + # The mixed-unit feature-count column has been removed entirely. + assert "Tree features within 50m" not in metrics.columns + assert set(metrics.columns) == {"postcode", density_col, area_col, height_col} + + +def test_postcode_density_percentiles_rank_over_density() -> None: + radius_m = 50 + density_col, area_col, height_col = _metric_columns(radius_m) percentile_col = _postcode_density_percentile_col(radius_m) - postcode_metrics = _with_postcode_density_percentiles( + metrics = _with_postcode_density_percentiles( pl.DataFrame( { "postcode": ["AA1 1AA", "AA1 1AB", "AA1 1AC"], density_col: [10.0, 30.0, 50.0], area_col: [100.0, 300.0, 500.0], - count_col: [1, 3, 5], height_col: [4.0, 6.0, 8.0], } ), radius_m, ) - price_paid = pl.DataFrame( - { - "postcode": ["AA1 1AA", "AA1 1AA", "AA1 1AB", "AA1 1AC"], - "paon": ["1", "2", "3", "4"], - "saon": ["", "", "", ""], - "street": ["Oak Road", "Oak Road", "Oak Road", "Elm Street"], - "locality": ["", "", "", ""], - "town_city": ["Test Town", "Test Town", "Test Town", "Test Town"], - "district": ["Test District"] * 4, - "county": ["Test County"] * 4, - "date_of_transfer": [ - "2024-01-01", - "2024-01-02", - "2024-01-03", - "2024-01-04", - ], - } + assert percentile_col in metrics.columns + assert metrics[percentile_col].to_list() == [0.0, 50.0, 100.0] + + +def test_safe_extract_zip_dir_rejects_path_traversal(tmp_path: Path) -> None: + malicious = tmp_path / "evil.zip" + with zipfile.ZipFile(malicious, "w") as archive: + archive.writestr("../escape.txt", "pwned") + + with pytest.raises(ValueError, match="Unsafe path"): + _safe_extract_zip_dir(malicious, tmp_path / "extract", force=True) + + +def test_safe_extract_zip_dir_extracts_benign_archive(tmp_path: Path) -> None: + benign = tmp_path / "ok.zip" + with zipfile.ZipFile(benign, "w") as archive: + archive.writestr("data/x.txt", "hello") + + extract_dir = tmp_path / "extract" + result = _safe_extract_zip_dir(benign, extract_dir, force=True) + assert result == extract_dir + assert (extract_dir / "data" / "x.txt").read_text() == "hello" + + +def test_geometry_column_resolution() -> None: + assert _geometry_column({"geometry_name": "SHAPE"}, ["MEANHT", "SHAPE"]) == "SHAPE" + assert _geometry_column({}, ["a", "wkb_geometry", "b"]) == "wkb_geometry" + assert _geometry_column({"geometry_name": None}, ["x", "geom"]) == "geom" + assert _geometry_column({}, ["a", "b", "c"]) == "c" # last-column fallback + + +def _zip_with_shapefiles(zip_path: Path, names: list[str]) -> None: + with zipfile.ZipFile(zip_path, "w") as archive: + for name in names: + archive.writestr(name, "") + + +def test_nfi_dataset_path_requires_exactly_one_shapefile(tmp_path: Path) -> None: + multi = tmp_path / "multi.zip" + _zip_with_shapefiles(multi, ["a.shp", "b.shp"]) + with pytest.raises(ValueError, match="exactly one shapefile"): + _nfi_dataset_path(multi, tmp_path / "multi_x", force_extract=True, use_vsizip=False) + + none = tmp_path / "none.zip" + _zip_with_shapefiles(none, ["readme.txt"]) + with pytest.raises(FileNotFoundError): + _nfi_dataset_path(none, tmp_path / "none_x", force_extract=True, use_vsizip=False) + + one = tmp_path / "one.zip" + _zip_with_shapefiles(one, ["woodland.shp", "woodland.dbf"]) + resolved = _nfi_dataset_path( + one, tmp_path / "one_x", force_extract=True, use_vsizip=False ) - price_paid_path = tmp_path / "price-paid.parquet" - output_streets = tmp_path / "streets.parquet" - output_addresses = tmp_path / "addresses.parquet" - price_paid.write_parquet(price_paid_path) + assert resolved.endswith("woodland.shp") - _write_street_rollups( - postcode_metrics=postcode_metrics, - price_paid_path=price_paid_path, - output_streets=output_streets, - output_addresses=output_addresses, - radius_m=radius_m, + +def test_layers_selection_and_unknown(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.setattr( + pyogrio, + "list_layers", + lambda _path: [("L1", "Polygon"), ("L2", "Polygon")], ) - - streets = pl.read_parquet(output_streets).sort("street") - addresses = pl.read_parquet(output_addresses) - - assert streets["street"].to_list() == ["Elm Street", "Oak Road"] - assert streets[STREET_TREE_COVERAGE_COL].to_list() == pytest.approx([50.0, 16.7]) - assert streets.select("street", STREET_TREE_DENSITY_COL).rows() == [ - ("Elm Street", 100.0), - ("Oak Road", 0.0), - ] - assert percentile_col in addresses.columns - assert STREET_TREE_COVERAGE_COL in addresses.columns - assert STREET_TREE_DENSITY_COL in addresses.columns + assert _layers("ignored", None) == ["L1", "L2"] + assert _layers("ignored", ("L2",)) == ["L2"] + with pytest.raises(ValueError, match="Unknown TOW layer"): + _layers("ignored", ("L3",)) diff --git a/pipeline/transform/tree_density.py b/pipeline/transform/tree_density.py index 06a16a7..9590104 100644 --- a/pipeline/transform/tree_density.py +++ b/pipeline/transform/tree_density.py @@ -1,16 +1,28 @@ -"""Derive street-scale tree density metrics from Forest Research TOW + NFI data. +"""Derive postcode-scale tree density metrics from Forest Research TOW + NFI data. The Forest Research Trees Outside Woodland release is an Esri File Geodatabase inside property-data/FR_TOW_V1_ALL.zip. This transformer computes a compact -postcode-level metric from the tree polygons, then optionally rolls that up to -Price Paid street names so the dashboard can answer "what is this address's -street like?" without loading the full geodatabase at runtime. +postcode-level metric from the tree polygons so the dashboard can answer "how +green is this postcode?" without loading the full geodatabase at runtime. -TOW only covers trees *outside* woodland, so the National Forest Inventory (NFI) -woodland layer is optionally unioned in. TOW canopy is accumulated by centroid -proximity (tiny crowns), while large NFI woodland parcels are accumulated by -true buffer-clipped intersection area so they cannot saturate a postcode from -mere centroid proximity. +Every postcode centroid is expanded into a radius-r buffer ("extended area"). +Both TOW tree crowns and National Forest Inventory (NFI) woodland parcels are +accumulated by *true buffer-clipped intersection area*: only the part of each +polygon that falls inside a postcode's buffer is counted, never the area that +spills outside it. A crown straddling the buffer edge therefore contributes only +its inside portion, and a parcel reaching into the buffer from outside is still +counted -- no polygon can saturate a postcode from mere proximity. + +TOW only covers trees *outside* woodland, so the NFI woodland layer is the +geometric complement of TOW and is optionally unioned in. The two products are +*assumed disjoint*: clipped TOW crown area and clipped NFI woodland area are +summed into the same per-postcode accumulator, so any spatial overlap between a +TOW crown and an NFI parcel (boundary slop where "groups of trees" meet +"woodland") would be double-counted. The final density is capped at 100% and +_finalize_metrics logs how many postcodes exceed 100% raw coverage, which is a +direct symptom of such overlap (or of overlapping crowns within one buffer); if +that count is material the products are not disjoint and the NFI clip should be +taken against the complement of TOW. """ from __future__ import annotations @@ -25,16 +37,12 @@ import numpy as np import polars as pl import pyogrio import shapely -from scipy.spatial import cKDTree TOW_GDB_NAME = "FR_TOW_V1_ALL.gdb" -STREET_TREE_DENSITY_COL = "Street tree density percentile" -STREET_TREE_COVERAGE_COL = "Street tree coverage (%)" POSTCODE_DENSITY_COL = "Tree canopy density within {radius}m (%)" POSTCODE_DENSITY_PERCENTILE_COL = "Tree canopy density percentile within {radius}m" POSTCODE_AREA_COL = "Tree canopy area within {radius}m (sqm)" -POSTCODE_COUNT_COL = "Tree features within {radius}m" POSTCODE_HEIGHT_COL = "Mean TOW height within {radius}m (m)" # National Forest Inventory (NFI) woodland — the geometric complement of TOW. @@ -131,13 +139,24 @@ def _safe_extract_zip_dir(zip_path: Path, extract_dir: Path, force: bool) -> Pat def _nfi_dataset_path( zip_path: Path, extract_dir: Path, force_extract: bool, use_vsizip: bool ) -> str: - """Resolve the NFI woodland shapefile path, extracting the zip if needed.""" + """Resolve the NFI woodland shapefile path, extracting the zip if needed. + + Raises if the archive contains zero or more than one shapefile rather than + silently picking one, so an ambiguous NFI release fails loudly instead of + accumulating canopy from the wrong layer. + """ if use_vsizip: return f"/vsizip/{zip_path.resolve()}" extracted = _safe_extract_zip_dir(zip_path, extract_dir, force_extract) shapefiles = sorted(extracted.rglob("*.shp")) if not shapefiles: raise FileNotFoundError(f"No .shp found inside {zip_path}") + if len(shapefiles) > 1: + names = ", ".join(path.name for path in shapefiles) + raise ValueError( + f"Expected exactly one shapefile inside {zip_path}, found {len(shapefiles)} " + f"({names}); cannot unambiguously pick the NFI woodland layer" + ) return str(shapefiles[0]) @@ -146,7 +165,7 @@ def _geometry_column(metadata: dict, column_names: list[str]) -> str: geometry_name = metadata.get("geometry_name") if geometry_name: return str(geometry_name) - for name in ("wkb_geometry", "geometry", "geom"): + for name in ("wkb_geometry", "geometry", "geom", "SHAPE"): if name in column_names: return name return column_names[-1] @@ -184,11 +203,10 @@ def _layers(dataset_path: str, selected_layers: tuple[str, ...] | None) -> list[ return [layer for layer in available if layer in selected_layers] -def _metric_columns(radius_m: int) -> tuple[str, str, str, str]: +def _metric_columns(radius_m: int) -> tuple[str, str, str]: return ( POSTCODE_DENSITY_COL.format(radius=radius_m), POSTCODE_AREA_COL.format(radius=radius_m), - POSTCODE_COUNT_COL.format(radius=radius_m), POSTCODE_HEIGHT_COL.format(radius=radius_m), ) @@ -198,20 +216,23 @@ def _postcode_density_percentile_col(radius_m: int) -> str: def _coverage_percentile_expr(column: str, alias: str) -> pl.Expr: - """Rank higher tree coverage higher on a 0-100 England-wide percentile scale.""" + """Rank tree coverage on a 0-100 England-wide percentile scale. + + A single tie-consistent average-rank formula is used for every value so the + scale is internally consistent end to end: tied values share their mean rank, + so the lowest coverage maps toward 0 and the highest toward 100 only when they + are not themselves tied. An all-equal (or single-value) column has no spread + and maps to the neutral midpoint (50). + """ value = pl.col(column).fill_nan(None) non_null_count = value.count() rank = value.rank("average") return ( pl.when(value.is_null()) .then(None) - .when(value == value.min()) - .then(0.0) - .when(value == value.max()) - .then(100.0) .when(non_null_count > 1) .then(((rank - 1) / (non_null_count - 1) * 100).round(1)) - .otherwise(100.0) + .otherwise(50.0) .cast(pl.Float32) .alias(alias) ) @@ -220,7 +241,7 @@ def _coverage_percentile_expr(column: str, alias: str) -> pl.Expr: def _with_postcode_density_percentiles( postcode_metrics: pl.DataFrame, radius_m: int ) -> pl.DataFrame: - density_col, _area_col, _count_col, _height_col = _metric_columns(radius_m) + density_col, _area_col, _height_col = _metric_columns(radius_m) return postcode_metrics.with_columns( _coverage_percentile_expr( density_col, @@ -229,28 +250,88 @@ def _with_postcode_density_percentiles( ) -def _accumulate_tree_metrics( +def _postcode_buffers( + points: pl.DataFrame, radius_m: int +) -> tuple[np.ndarray, shapely.STRtree]: + """Build a radius-r circle for every postcode plus an STRtree over them. + + Circle index == postcode index, so an STRtree match resolves directly to the + postcode accumulator slot. + """ + xy = points.select("x", "y").to_numpy() + circles = shapely.buffer(shapely.points(xy), radius_m, quad_segs=8) + return circles, shapely.STRtree(circles) + + +def _accumulate_clipped_area( + geoms: np.ndarray, + circles: np.ndarray, + tree: shapely.STRtree, + canopy_area: np.ndarray, + height: np.ndarray | None = None, + height_weighted_sum: np.ndarray | None = None, + height_weight: np.ndarray | None = None, +) -> None: + """Add each polygon's in-buffer overlap area to every postcode it intersects. + + Only area(polygon ∩ circle) is accumulated -- never the area of the polygon + that falls outside the postcode's extended buffer -- so a crown straddling + the buffer edge contributes only its inside portion and a large parcel cannot + saturate a postcode from mere proximity. When ``height`` is supplied the mean + feature height is accumulated weighted by that same clipped overlap area. + """ + keep = ~shapely.is_missing(geoms) & ~shapely.is_empty(geoms) + geoms = geoms[keep] + if height is not None: + height = height[keep] + if geoms.size == 0: + return + + # query(predicate="intersects") over the circle STRtree returns exactly the + # (polygon, circle) pairs whose clipped overlap can be positive -- i.e. the + # polygon overlaps that postcode's radius-r buffer. + geom_index, postcode_index = tree.query(geoms, predicate="intersects") + if geom_index.size == 0: + return + + clipped_area = shapely.area( + shapely.intersection(geoms[geom_index], circles[postcode_index]) + ) + positive = clipped_area > 0 + geom_index = geom_index[positive] + postcode_index = postcode_index[positive] + clipped_area = clipped_area[positive] + + np.add.at(canopy_area, postcode_index, clipped_area) + + if height is not None: + feature_height = height[geom_index] + finite = np.isfinite(feature_height) + if finite.any(): + np.add.at( + height_weighted_sum, + postcode_index[finite], + feature_height[finite] * clipped_area[finite], + ) + np.add.at(height_weight, postcode_index[finite], clipped_area[finite]) + + +def _accumulate_tow_metrics( dataset_path: str, - points: pl.DataFrame, - radius_m: int, + circles: np.ndarray, + tree: shapely.STRtree, + canopy_area: np.ndarray, + height_weighted_sum: np.ndarray, + height_weight: np.ndarray, batch_size: int, layer_names: tuple[str, ...] | None, max_features_per_layer: int | None, - workers: int, - canopy_area: np.ndarray, - feature_count: np.ndarray, - height_weighted_sum: np.ndarray, - height_weight: np.ndarray, ) -> None: - xy = points.select("x", "y").to_numpy() - tree = cKDTree(xy) - layers = _layers(dataset_path, layer_names) print(f"Processing {len(layers)} TOW layer(s): {', '.join(layers)}") - columns = ["Woodland_Type", "TOW_Area_M", "MEANHT"] + columns = ["MEANHT"] total_features_seen = 0 - total_features_used = 0 for layer in layers: info = pyogrio.read_info(dataset_path, layer=layer) @@ -263,7 +344,7 @@ def _accumulate_tree_metrics( columns=columns, batch_size=batch_size, use_pyarrow=True, - ) as (_meta, reader): + ) as (meta, reader): for batch_index, batch in enumerate(reader, start=1): if max_features_per_layer is not None: remaining = max_features_per_layer - layer_features_seen @@ -275,135 +356,29 @@ def _accumulate_tree_metrics( layer_features_seen += batch.num_rows total_features_seen += batch.num_rows names = batch.schema.names - area = np.asarray( - batch.column(names.index("TOW_Area_M")).to_numpy(zero_copy_only=False), - dtype=np.float64, - ) + geometry_column = _geometry_column(meta, names) height = np.asarray( batch.column(names.index("MEANHT")).to_numpy(zero_copy_only=False), dtype=np.float64, ) geometry = np.asarray( - batch.column(names.index("SHAPE")).to_numpy(zero_copy_only=False), + batch.column(names.index(geometry_column)).to_numpy( + zero_copy_only=False + ), dtype=object, ) - - valid = np.isfinite(area) & (area > 0) - if not valid.any(): - continue - - geometry = geometry[valid] - area = area[valid] - height = height[valid] - - centroids = shapely.centroid(shapely.from_wkb(geometry)) - x = shapely.get_x(centroids) - y = shapely.get_y(centroids) - valid_xy = np.isfinite(x) & np.isfinite(y) - if not valid_xy.any(): - continue - - x = x[valid_xy] - y = y[valid_xy] - area = area[valid_xy] - height = height[valid_xy] - - nearby = tree.query_ball_point( - np.column_stack((x, y)), radius_m, workers=workers + _accumulate_clipped_area( + shapely.from_wkb(geometry), + circles, + tree, + canopy_area, + height=height, + height_weighted_sum=height_weighted_sum, + height_weight=height_weight, ) - lengths = np.fromiter( - (len(postcode_indexes) for postcode_indexes in nearby), - dtype=np.int32, - count=len(nearby), - ) - matching_features = lengths > 0 - if matching_features.any(): - postcode_indexes = np.concatenate( - [indexes for indexes in nearby if indexes] - ).astype(np.int64, copy=False) - feature_indexes = np.repeat( - np.flatnonzero(matching_features), lengths[matching_features] - ) - np.add.at(canopy_area, postcode_indexes, area[feature_indexes]) - np.add.at(feature_count, postcode_indexes, 1) - - feature_height = height[feature_indexes] - valid_height = np.isfinite(feature_height) - if valid_height.any(): - height_area = area[feature_indexes][valid_height] - np.add.at( - height_weighted_sum, - postcode_indexes[valid_height], - feature_height[valid_height] * height_area, - ) - np.add.at( - height_weight, - postcode_indexes[valid_height], - height_area, - ) - - total_features_used += len(area) if batch_index == 1 or batch_index % 25 == 0: - print( - f" batch {batch_index:,}: " - f"{total_features_seen:,} rows read, " - f"{total_features_used:,} features with usable centroids" - ) - - -def _postcode_buffers( - points: pl.DataFrame, radius_m: int -) -> tuple[np.ndarray, shapely.STRtree]: - """Build a radius-r circle for every postcode plus an STRtree over them. - - Circle index == postcode index, matching the order used by the cKDTree path. - """ - xy = points.select("x", "y").to_numpy() - circles = shapely.buffer(shapely.points(xy), radius_m, quad_segs=8) - return circles, shapely.STRtree(circles) - - -def _add_nfi_batch( - geoms: np.ndarray, - category: np.ndarray, - circles: np.ndarray, - tree: shapely.STRtree, - canopy_area: np.ndarray, - feature_count: np.ndarray, - radius_m: int, -) -> None: - """Add NFI woodland into the shared arrays by true buffer-clipped area. - - Unlike the TOW centroid path, this clips each woodland polygon to each - nearby postcode circle and adds only area(polygon ∩ circle); a large parcel - therefore cannot saturate a postcode from mere centroid proximity, and a - buffer-filling parcel whose centroid is outside the radius is not missed. - """ - keep = (category == NFI_WOODLAND_VALUE) & ~shapely.is_missing(geoms) - geoms = geoms[keep] - if geoms.size: - geoms = geoms[~shapely.is_empty(geoms)] - if geoms.size == 0: - return - - # dwithin(polygon, point, r) is true iff the radius-r circle around the - # point intersects the polygon -- exactly the candidate set we want. - nfi_index, postcode_index = tree.query( - geoms, predicate="dwithin", distance=radius_m - ) - if nfi_index.size == 0: - return - - clipped_area = shapely.area( - shapely.intersection(geoms[nfi_index], circles[postcode_index]) - ) - positive = clipped_area > 0 - postcode_index = postcode_index[positive] - clipped_area = clipped_area[positive] - - np.add.at(canopy_area, postcode_index, clipped_area) - np.add.at(feature_count, postcode_index, 1) + print(f" batch {batch_index:,}: {total_features_seen:,} rows read") def _accumulate_nfi_metrics( @@ -411,8 +386,6 @@ def _accumulate_nfi_metrics( circles: np.ndarray, tree: shapely.STRtree, canopy_area: np.ndarray, - feature_count: np.ndarray, - radius_m: int, batch_size: int, max_nfi_features: int | None, ) -> None: @@ -455,14 +428,12 @@ def _accumulate_nfi_metrics( ), dtype=object, ) - _add_nfi_batch( - shapely.from_wkb(geometry), - category, + geoms = shapely.from_wkb(geometry) + _accumulate_clipped_area( + geoms[category == NFI_WOODLAND_VALUE], circles, tree, canopy_area, - feature_count, - radius_m, ) if batch_index == 1 or batch_index % 25 == 0: print(f" NFI batch {batch_index:,}: {features_seen:,} rows read") @@ -471,15 +442,26 @@ def _accumulate_nfi_metrics( def _finalize_metrics( points: pl.DataFrame, canopy_area: np.ndarray, - feature_count: np.ndarray, height_weighted_sum: np.ndarray, height_weight: np.ndarray, radius_m: int, ) -> pl.DataFrame: n_points = points.height - density_col, area_col, count_col, height_col = _metric_columns(radius_m) + density_col, area_col, height_col = _metric_columns(radius_m) buffer_area = math.pi * radius_m * radius_m - density_pct = np.minimum(canopy_area / buffer_area * 100.0, 100.0) + raw_density = canopy_area / buffer_area * 100.0 + density_pct = np.minimum(raw_density, 100.0) + + # Symptom of the assumed-disjoint TOW/NFI union being violated (or of + # overlapping crowns inside one buffer): clipped areas alone cannot exceed the + # buffer unless polygons overlap. Surface it rather than hide it behind the cap. + over_count = int(np.count_nonzero(raw_density > 100.0)) + if over_count: + print( + f" note: {over_count:,} postcode(s) exceeded 100% raw canopy and were " + "capped — indicates overlapping TOW/NFI canopy within the buffer" + ) + mean_height = np.divide( height_weighted_sum, height_weight, @@ -492,7 +474,6 @@ def _finalize_metrics( "postcode": points["postcode"], area_col: canopy_area.round(1).astype(np.float32), density_col: density_pct.round(1).astype(np.float32), - count_col: feature_count.astype(np.uint32), height_col: np.round(mean_height, 1).astype(np.float32), } ).with_columns( @@ -500,181 +481,9 @@ def _finalize_metrics( ) -def _clean_key_expr(column: str) -> pl.Expr: - return ( - pl.col(column) - .fill_null("") - .str.to_uppercase() - .str.replace_all(r"[^A-Z0-9]+", " ") - .str.replace_all(r"\s+", " ") - .str.strip_chars() - ) - - -def _latest_price_paid_addresses(price_paid_path: Path) -> pl.LazyFrame: - return ( - pl.scan_parquet(price_paid_path) - .select( - pl.col("postcode").str.strip_chars().str.to_uppercase().alias("postcode"), - "paon", - "saon", - "street", - "locality", - "town_city", - "district", - "county", - "date_of_transfer", - ) - .filter(pl.col("postcode").is_not_null()) - .filter(pl.col("street").is_not_null()) - .filter(_clean_key_expr("street") != "") - .with_columns( - pl.concat_str( - [pl.col("saon"), pl.col("paon"), pl.col("street")], - separator=" ", - ignore_nulls=True, - ) - .str.replace_all(r"\s+", " ") - .str.strip_chars() - .alias("pp_address"), - ) - .filter(pl.col("pp_address").is_not_null()) - .sort("date_of_transfer") - .group_by("postcode", "pp_address", maintain_order=True) - .agg( - pl.col("street").last(), - pl.col("locality").last(), - pl.col("town_city").last(), - pl.col("district").last(), - pl.col("county").last(), - ) - .with_columns( - pl.concat_str( - [ - _clean_key_expr("street"), - _clean_key_expr("town_city"), - _clean_key_expr("district"), - _clean_key_expr("county"), - ], - separator="|", - ).alias("street_key") - ) - ) - - -def _weighted_mean_expr(column: str, weight: str) -> pl.Expr: - valid = pl.col(column).is_not_null() & ~pl.col(column).is_nan() - numerator = pl.when(valid).then(pl.col(column) * pl.col(weight)).sum() - denominator = pl.when(valid).then(pl.col(weight)).sum() - return pl.when(denominator > 0).then(numerator / denominator).otherwise(None) - - -def _write_street_rollups( - postcode_metrics: pl.DataFrame, - price_paid_path: Path, - output_streets: Path | None, - output_addresses: Path | None, - radius_m: int, -) -> None: - if output_streets is None and output_addresses is None: - return - - density_col, area_col, count_col, height_col = _metric_columns(radius_m) - metrics = postcode_metrics.lazy() - addresses = _latest_price_paid_addresses(price_paid_path).join( - metrics, on="postcode", how="inner" - ) - - per_postcode = ( - addresses.group_by( - "street_key", - "postcode", - "street", - "locality", - "town_city", - "district", - "county", - ) - .agg( - pl.len().alias("address_count"), - pl.col(density_col).first(), - pl.col(area_col).first(), - pl.col(count_col).first(), - pl.col(height_col).first(), - ) - .collect() - ) - - streets = ( - per_postcode.lazy() - .group_by("street_key") - .agg( - pl.col("street").first(), - pl.col("locality").first(), - pl.col("town_city").first(), - pl.col("district").first(), - pl.col("county").first(), - pl.col("postcode").n_unique().alias("postcode_count"), - pl.col("address_count").sum().alias("address_count"), - _weighted_mean_expr(density_col, "address_count") - .round(1) - .cast(pl.Float32) - .alias(STREET_TREE_COVERAGE_COL), - _weighted_mean_expr(area_col, "address_count") - .round(1) - .cast(pl.Float32) - .alias(f"Street average {area_col}"), - _weighted_mean_expr(count_col, "address_count") - .round(1) - .cast(pl.Float32) - .alias(f"Street average {count_col}"), - _weighted_mean_expr(height_col, "address_count") - .round(1) - .cast(pl.Float32) - .alias(f"Street average {height_col}"), - ) - .with_columns( - _coverage_percentile_expr( - STREET_TREE_COVERAGE_COL, - STREET_TREE_DENSITY_COL, - ) - ) - .sort("street_key") - .collect() - ) - - if output_addresses is not None: - output_addresses.parent.mkdir(parents=True, exist_ok=True) - address_output = addresses.join( - streets.lazy().select( - "street_key", - STREET_TREE_COVERAGE_COL, - STREET_TREE_DENSITY_COL, - ), - on="street_key", - how="left", - ) - address_output.sink_parquet(output_addresses, compression="zstd") - print(f"Wrote address tree-density join: {output_addresses}") - - if output_streets is not None: - output_streets.parent.mkdir(parents=True, exist_ok=True) - streets.write_parquet(output_streets, compression="zstd") - print(f"Wrote street tree-density rollup: {output_streets}") - - -def _parse_csv_arg(value: str | None) -> tuple[str, ...] | None: - if value is None: - return None - if value.lower() == "all": - return None - parts = tuple(part.strip() for part in value.split(",") if part.strip()) - return parts or None - - def main() -> None: parser = argparse.ArgumentParser( - description="Build postcode and street tree-density metrics from FR_TOW_V1_ALL.zip" + description="Build postcode-level tree-density metrics from FR_TOW_V1_ALL.zip" ) parser.add_argument( "--tow-zip", @@ -716,35 +525,17 @@ def main() -> None: default=Path("property-data/arcgis_data.parquet"), help="Postcode centroid parquet with east1m/north1m columns", ) - parser.add_argument( - "--price-paid", - type=Path, - default=None, - help="Optional Price Paid parquet used to roll postcode metrics up to streets", - ) parser.add_argument( "--output-postcodes", type=Path, required=True, help="Output postcode-level tree-density parquet", ) - parser.add_argument( - "--output-streets", - type=Path, - default=None, - help="Optional output street-level tree-density parquet", - ) - parser.add_argument( - "--output-addresses", - type=Path, - default=None, - help="Optional output address/street join parquet keyed by postcode and pp_address", - ) parser.add_argument( "--radius-m", type=int, default=50, - help="Radius around each postcode centroid used as the street-scale buffer", + help="Radius around each postcode centroid used as the extended buffer", ) parser.add_argument( "--layers", @@ -757,12 +548,6 @@ def main() -> None: default=65_536, help="Arrow batch size for reading TOW features", ) - parser.add_argument( - "--workers", - type=int, - default=-1, - help="Worker count passed to scipy cKDTree.query_ball_point", - ) parser.add_argument( "--max-postcodes", type=int, @@ -783,9 +568,6 @@ def main() -> None: ) args = parser.parse_args() - if (args.output_streets or args.output_addresses) and args.price_paid is None: - raise SystemExit("--price-paid is required when writing street/address outputs") - if args.radius_m <= 0: raise SystemExit("--radius-m must be greater than zero") @@ -797,36 +579,32 @@ def main() -> None: n_points = points.height canopy_area = np.zeros(n_points, dtype=np.float64) - feature_count = np.zeros(n_points, dtype=np.uint32) height_weighted_sum = np.zeros(n_points, dtype=np.float64) height_weight = np.zeros(n_points, dtype=np.float64) - _accumulate_tree_metrics( + circles, tree = _postcode_buffers(points, args.radius_m) + + _accumulate_tow_metrics( dataset_path=dataset_path, - points=points, - radius_m=args.radius_m, + circles=circles, + tree=tree, + canopy_area=canopy_area, + height_weighted_sum=height_weighted_sum, + height_weight=height_weight, batch_size=args.batch_size, layer_names=layer_names, max_features_per_layer=args.max_features_per_layer, - workers=args.workers, - canopy_area=canopy_area, - feature_count=feature_count, - height_weighted_sum=height_weighted_sum, - height_weight=height_weight, ) if args.nfi_zip is not None and args.nfi_zip.exists(): nfi_path = _nfi_dataset_path( args.nfi_zip, args.nfi_extract_dir, args.force_extract, args.use_vsizip ) - circles, nfi_tree = _postcode_buffers(points, args.radius_m) _accumulate_nfi_metrics( dataset_path=nfi_path, circles=circles, - tree=nfi_tree, + tree=tree, canopy_area=canopy_area, - feature_count=feature_count, - radius_m=args.radius_m, batch_size=args.batch_size, max_nfi_features=args.max_nfi_features, ) @@ -836,7 +614,6 @@ def main() -> None: postcode_metrics = _finalize_metrics( points, canopy_area, - feature_count, height_weighted_sum, height_weight, args.radius_m, @@ -849,14 +626,14 @@ def main() -> None: postcode_metrics.write_parquet(args.output_postcodes, compression="zstd") print(f"\nWrote postcode tree-density metrics: {args.output_postcodes}") - if args.price_paid is not None: - _write_street_rollups( - postcode_metrics=postcode_metrics, - price_paid_path=args.price_paid, - output_streets=args.output_streets, - output_addresses=args.output_addresses, - radius_m=args.radius_m, - ) + +def _parse_csv_arg(value: str | None) -> tuple[str, ...] | None: + if value is None: + return None + if value.lower() == "all": + return None + parts = tuple(part.strip() for part in value.split(",") if part.strip()) + return parts or None if __name__ == "__main__": diff --git a/pipeline/transform/tree_overlay_tiles.py b/pipeline/transform/tree_overlay_tiles.py index b301066..761277d 100644 --- a/pipeline/transform/tree_overlay_tiles.py +++ b/pipeline/transform/tree_overlay_tiles.py @@ -90,7 +90,7 @@ def _write_tree_geojsonseq( columns=columns, batch_size=batch_size, use_pyarrow=True, - ) as (_meta, reader): + ) as (meta, reader): for batch in reader: if max_features_per_layer is not None: remaining = max_features_per_layer - layer_features_seen @@ -101,6 +101,7 @@ def _write_tree_geojsonseq( layer_features_seen += batch.num_rows names = batch.schema.names + geometry_column = _geometry_column(meta, names) area = np.asarray( batch.column(names.index("TOW_Area_M")).to_numpy( zero_copy_only=False @@ -108,7 +109,7 @@ def _write_tree_geojsonseq( dtype=np.float64, ) geometry = np.asarray( - batch.column(names.index("SHAPE")).to_numpy( + batch.column(names.index(geometry_column)).to_numpy( zero_copy_only=False ), dtype=object, @@ -327,7 +328,7 @@ def build_tree_overlay_tiles( str(min_zoom), "--maximum-zoom", str(max_zoom), - "--drop-smallest-as-needed", + "--coalesce-smallest-as-needed", "--extend-zooms-if-still-dropping", "--temporary-directory", tmp, diff --git a/pipeline/utils/postcode_mapping.py b/pipeline/utils/postcode_mapping.py index 6023ef6..f8383d8 100644 --- a/pipeline/utils/postcode_mapping.py +++ b/pipeline/utils/postcode_mapping.py @@ -13,7 +13,11 @@ def build_postcode_mapping(arcgis_path: Path) -> pl.DataFrame: Uses OS National Grid coordinates (east1m, north1m) which are Cartesian metres, so Euclidean distance via cKDTree gives accurate results without projection. """ - arcgis = pl.scan_parquet(arcgis_path).filter(pl.col("ctry25cd") == "E92000001") + arcgis = ( + pl.scan_parquet(arcgis_path) + .filter(pl.col("ctry25cd") == "E92000001") + .with_columns(pl.col("doterm").cast(pl.Utf8).alias("doterm")) + ) active = ( arcgis.filter(pl.col("doterm").is_null()) diff --git a/pipeline/validate_outputs.py b/pipeline/validate_outputs.py index 69ed76e..1bcc30a 100644 --- a/pipeline/validate_outputs.py +++ b/pipeline/validate_outputs.py @@ -9,6 +9,8 @@ import zipfile from pathlib import Path import polars as pl +from shapely.geometry import shape +from shapely.validation import explain_validity def _failures_for_file(path: Path) -> list[str]: @@ -79,9 +81,7 @@ def _split_glob(spec: str) -> tuple[Path, str]: def _split_pair(spec: str, label: str) -> tuple[Path, Path]: if "::" not in spec: - raise argparse.ArgumentTypeError( - f"{spec!r} must use LEFT::RIGHT for {label}" - ) + raise argparse.ArgumentTypeError(f"{spec!r} must use LEFT::RIGHT for {label}") left, right = spec.split("::", 1) if not left or not right: raise argparse.ArgumentTypeError(f"{spec!r} must include both paths") @@ -143,22 +143,140 @@ def _parquet_postcodes(path: Path) -> set[str]: .get_column(column) .to_list() ) - return {_canonical_postcode(value) for value in values if _canonical_postcode(value)} + return { + _canonical_postcode(value) for value in values if _canonical_postcode(value) + } + + +def _active_english_arcgis_postcodes(path: Path) -> set[str]: + schema = pl.scan_parquet(path).collect_schema() + required = {"pcds", "ctry25cd", "doterm"} + missing = sorted(required - set(schema.names())) + if missing: + raise ValueError(f"{path}: missing ArcGIS postcode columns: {missing}") + values = ( + pl.read_parquet(path, columns=["pcds", "ctry25cd", "doterm"]) + .lazy() + .filter(pl.col("ctry25cd") == "E92000001") + .filter(pl.col("doterm").cast(pl.Utf8).is_null()) + .select(pl.col("pcds").drop_nulls().unique()) + .collect() + .get_column("pcds") + .to_list() + ) + return { + _canonical_postcode(value) for value in values if _canonical_postcode(value) + } + + +def _format_samples(samples: list[str]) -> str: + return "; ".join(samples[:10]) + + +def _boundary_postcode_scan(path: Path) -> tuple[set[str], list[str]]: + units_dir = path / "units" if (path / "units").is_dir() else path + postcodes: set[str] = set() + seen: dict[str, str] = {} + failures: list[str] = [] + missing_postcode_samples: list[str] = [] + missing_geometry_samples: list[str] = [] + non_polygon_samples: list[str] = [] + invalid_geometry_samples: list[str] = [] + duplicate_samples: list[str] = [] + missing_postcode_count = 0 + missing_geometry_count = 0 + non_polygon_count = 0 + invalid_geometry_count = 0 + duplicate_count = 0 + + for geojson_path in sorted(units_dir.glob("*.geojson")): + try: + with geojson_path.open("r", encoding="utf-8") as handle: + data = json.load(handle) + except Exception as exc: + failures.append(f"{geojson_path}: unreadable GeoJSON: {exc}") + continue + + for idx, feature in enumerate(data.get("features", [])): + label = f"{geojson_path.name} feature {idx}" + properties = feature.get("properties") or {} + value = properties.get("postcodes") + postcode = _canonical_postcode(value) if value is not None else "" + if not postcode: + missing_postcode_count += 1 + if len(missing_postcode_samples) < 10: + missing_postcode_samples.append(label) + else: + if postcode in seen: + duplicate_count += 1 + if len(duplicate_samples) < 10: + duplicate_samples.append( + f"{postcode} in {seen[postcode]} and {label}" + ) + else: + seen[postcode] = label + postcodes.add(postcode) + + geometry_data = feature.get("geometry") + if geometry_data is None: + missing_geometry_count += 1 + if len(missing_geometry_samples) < 10: + missing_geometry_samples.append(f"{postcode or label}") + continue + try: + geom = shape(geometry_data) + except Exception as exc: + invalid_geometry_count += 1 + if len(invalid_geometry_samples) < 10: + invalid_geometry_samples.append(f"{postcode or label}: {exc}") + continue + if geom.is_empty: + missing_geometry_count += 1 + if len(missing_geometry_samples) < 10: + missing_geometry_samples.append(f"{postcode or label}: empty") + elif geom.geom_type not in {"Polygon", "MultiPolygon"}: + non_polygon_count += 1 + if len(non_polygon_samples) < 10: + non_polygon_samples.append(f"{postcode or label}: {geom.geom_type}") + elif not geom.is_valid: + invalid_geometry_count += 1 + if len(invalid_geometry_samples) < 10: + invalid_geometry_samples.append( + f"{postcode or label}: {explain_validity(geom)}" + ) + + if missing_postcode_count: + failures.append( + f"{path}: {missing_postcode_count:,} boundary features are missing " + f"properties.postcodes; sample: {_format_samples(missing_postcode_samples)}" + ) + if duplicate_count: + failures.append( + f"{path}: {duplicate_count:,} duplicate boundary postcode features; " + f"sample: {_format_samples(duplicate_samples)}" + ) + if missing_geometry_count: + failures.append( + f"{path}: {missing_geometry_count:,} boundary features are missing or empty " + f"geometry; sample: {_format_samples(missing_geometry_samples)}" + ) + if non_polygon_count: + failures.append( + f"{path}: {non_polygon_count:,} boundary features are not polygonal; " + f"sample: {_format_samples(non_polygon_samples)}" + ) + if invalid_geometry_count: + failures.append( + f"{path}: {invalid_geometry_count:,} invalid boundary geometries; " + f"sample: {_format_samples(invalid_geometry_samples)}" + ) + return postcodes, failures def _boundary_postcodes(path: Path) -> set[str]: - units_dir = path / "units" if (path / "units").is_dir() else path - postcodes: set[str] = set() - for geojson_path in sorted(units_dir.glob("*.geojson")): - with geojson_path.open("r", encoding="utf-8") as handle: - data = json.load(handle) - for feature in data.get("features", []): - properties = feature.get("properties") or {} - value = properties.get("postcodes") - if value is not None: - postcode = _canonical_postcode(value) - if postcode: - postcodes.add(postcode) + postcodes, failures = _boundary_postcode_scan(path) + if failures: + raise ValueError("; ".join(failures)) return postcodes @@ -174,11 +292,13 @@ def _failures_for_postcode_boundary_match(spec: str) -> list[str]: try: parquet_postcodes = _parquet_postcodes(parquet_path) - boundary_postcodes = _boundary_postcodes(boundaries_path) + boundary_postcodes, boundary_failures = _boundary_postcode_scan(boundaries_path) except Exception as exc: - return [f"{parquet_path} / {boundaries_path}: postcode match check failed: {exc}"] + return [ + f"{parquet_path} / {boundaries_path}: postcode match check failed: {exc}" + ] - failures = [] + failures = list(boundary_failures) if not boundary_postcodes: failures.append(f"{boundaries_path}: no boundary postcodes found") @@ -197,6 +317,41 @@ def _failures_for_postcode_boundary_match(spec: str) -> list[str]: return failures +def _failures_for_active_postcode_boundary_match(spec: str) -> list[str]: + arcgis_path, boundaries_path = _split_pair( + spec, "active postcode boundary matching" + ) + failures = _failures_for_parquet(arcgis_path) + _failures_for_dir(boundaries_path) + if failures: + return failures + + try: + active_postcodes = _active_english_arcgis_postcodes(arcgis_path) + boundary_postcodes, boundary_failures = _boundary_postcode_scan(boundaries_path) + except Exception as exc: + return [ + f"{arcgis_path} / {boundaries_path}: active postcode boundary check failed: {exc}" + ] + + failures = list(boundary_failures) + if not boundary_postcodes: + failures.append(f"{boundaries_path}: no boundary postcodes found") + + missing_boundaries = active_postcodes - boundary_postcodes + orphan_boundaries = boundary_postcodes - active_postcodes + if missing_boundaries: + failures.append( + f"{boundaries_path}: {len(missing_boundaries):,} active English postcodes " + f"from {arcgis_path} are missing boundaries; sample: {_sample(missing_boundaries)}" + ) + if orphan_boundaries: + failures.append( + f"{boundaries_path}: {len(orphan_boundaries):,} boundary postcodes are not " + f"active English postcodes in {arcgis_path}; sample: {_sample(orphan_boundaries)}" + ) + return failures + + def main() -> int: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--file", action="append", default=[], type=Path) @@ -221,6 +376,15 @@ def main() -> int: default=[], help="Require postcode parquet keys to exactly match boundary GeoJSON postcodes: PARQUET::DIR", ) + parser.add_argument( + "--active-postcode-boundary-match", + action="append", + default=[], + help=( + "Require active English ArcGIS postcodes to exactly match boundary " + "GeoJSON postcodes: ARCGIS_PARQUET::DIR" + ), + ) args = parser.parse_args() failures: list[str] = [] @@ -238,6 +402,8 @@ def main() -> int: failures.extend(_failures_for_zip_glob(spec)) for spec in args.postcode_boundary_match: failures.extend(_failures_for_postcode_boundary_match(spec)) + for spec in args.active_postcode_boundary_match: + failures.extend(_failures_for_active_postcode_boundary_match(spec)) if failures: print("Output validation failed:", file=sys.stderr) diff --git a/server-rs/src/routes/stats.rs b/server-rs/src/routes/stats.rs index cd9eb75..ec50ede 100644 --- a/server-rs/src/routes/stats.rs +++ b/server-rs/src/routes/stats.rs @@ -282,17 +282,23 @@ pub fn compute_crime_by_year( for &row in matching_rows { let postcode = data.postcode(row); - let Some(series_list) = crime_by_year.series_by_postcode.get(postcode) else { - continue; - }; - // For every type the postcode reports, add its per-year counts. - // For types it doesn't report, treat the row as contributing 0 — so we - // bump the row count for *every* known type below. - for series in series_list { - let acc = &mut per_type_year_sums[series.type_idx as usize]; - for point in &series.points { - *acc.entry(point.year).or_insert(0.0) += point.count as f64; + // A postcode absent from the by-year table has no recorded crime within + // 50m, so it contributes 0 to every type's per-year sum. It must still be + // counted in the denominator: the matching `(avg/yr)` stat counts those + // same zero-crime postcodes as 0.0 (crime_by_postcode.parquet has a dense + // row for every boundary postcode), so excluding them here would compute + // the chart over a smaller population and report a higher magnitude than + // the headline. Property postcodes are guaranteed to be boundary + // postcodes by the postcode-boundary-match validation, so "absent" means + // genuinely zero-crime, not missing data. + if let Some(series_list) = crime_by_year.series_by_postcode.get(postcode) { + // For every type the postcode reports, add its per-year counts. + for series in series_list { + let acc = &mut per_type_year_sums[series.type_idx as usize]; + for point in &series.points { + *acc.entry(point.year).or_insert(0.0) += point.count as f64; + } } } for c in per_type_row_counts.iter_mut() { From f99bd4e5c92c3cf7551288b19edf5d214473e6a2 Mon Sep 17 00:00:00 2001 From: Andras Schmelczer <andras@schmelczer.dev> Date: Mon, 1 Jun 2026 20:10:03 +0100 Subject: [PATCH 3/9] Improve data pipeline --- Makefile.data | 10 +- frontend/src/i18n/descriptions.ts | 20 +- frontend/src/i18n/details.ts | 28 +-- frontend/src/i18n/locales/de.ts | 2 +- frontend/src/i18n/locales/en.ts | 2 +- frontend/src/i18n/locales/fr.ts | 2 +- frontend/src/i18n/locales/hi.ts | 2 +- frontend/src/i18n/locales/hu.ts | 2 +- frontend/src/i18n/locales/zh.ts | 2 +- frontend/src/lib/consts.ts | 11 +- frontend/src/lib/ethnicity-filter.ts | 2 +- frontend/src/lib/feature-icons.tsx | 2 +- pipeline/download/ethnicity.py | 13 +- pipeline/download/test_ethnicity.py | 28 +++ pipeline/test_validate_outputs.py | 105 +++++++++ pipeline/transform/crime.py | 17 +- pipeline/transform/crime_hotspot_tiles.py | 6 +- pipeline/transform/crime_spatial.py | 6 + pipeline/transform/join_epc_pp.py | 48 ++++- pipeline/transform/merge.py | 44 ++-- .../transform/postcode_boundaries/output.py | 36 +++- .../test_postcode_boundaries.py | 51 +++++ .../transform/price_estimation/backtest.py | 10 + .../transform/price_estimation/estimate.py | 29 ++- pipeline/transform/price_estimation/index.py | 43 +++- .../transform/price_estimation/shrinkage.py | 7 +- .../transform/price_estimation/test_knn.py | 62 +++++- pipeline/transform/price_estimation/utils.py | 7 + pipeline/transform/school_proximity.py | 92 +++++--- pipeline/transform/test_crime.py | 41 ++++ pipeline/transform/test_crime_spatial.py | 34 +++ pipeline/transform/test_join_epc_pp.py | 26 ++- pipeline/transform/test_school_proximity.py | 82 ++++++++ pipeline/validate_outputs.py | 199 ++++++++++++++++++ server-rs/src/features.rs | 22 +- video/src/storyboard.ts | 2 +- 36 files changed, 966 insertions(+), 129 deletions(-) create mode 100644 pipeline/transform/test_school_proximity.py diff --git a/Makefile.data b/Makefile.data index 7152451..5319cea 100644 --- a/Makefile.data +++ b/Makefile.data @@ -116,9 +116,9 @@ MAP_ASSETS_DEPS := pipeline/download/map_assets.py pipeline/transform/transform_ generate-postcode-boundaries generate-travel-times enrich-actual-listings prepare: $(PRICES_STAMP) download-places tiles satellite-tiles overlay-tiles property-border-tiles generate-postcode-boundaries download-map-assets generate-travel-times | $(POSTCODES_PQ) $(PROPERTIES_PQ) $(PRICE_INDEX) - $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) --parquet $(PRICE_INDEX) --postcode-boundary-match "$(POSTCODES_PQ)::$(PC_BOUNDARIES)" + $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) --parquet $(PRICE_INDEX) --postcode-boundary-match "$(POSTCODES_PQ)::$(PC_BOUNDARIES)" --postcode-features $(POSTCODES_PQ) --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" --price-index $(PRICE_INDEX) merge: $(MERGE_STAMP) | $(POSTCODES_PQ) $(PROPERTIES_PQ) - $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) + $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) --postcode-features $(POSTCODES_PQ) --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" enrich-actual-listings: $(ACTUAL_LISTINGS_ENRICHED) tiles: $(TILES) $(SATELLITE_TILES) $(SATELLITE_HIGHRES_TILES) satellite-tiles: $(SATELLITE_TILES) @@ -413,13 +413,13 @@ $(MERGE_STAMP): $(EPC_PP) $(ARCGIS) $(IOD) $(POI_PROXIMITY) \ --tree-density-postcodes $(TREE_DENSITY_PC) \ --output-postcodes $(POSTCODES_PQ) \ --output-properties $(PROPERTIES_PQ) - $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) + $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) --postcode-features $(POSTCODES_PQ) --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" @touch $@ # ── Price estimation (post-merge) ─────────────────────────────────────────── $(POSTCODES_PQ) $(PROPERTIES_PQ) &: $(MERGE_STAMP) - $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) + $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) --postcode-features $(POSTCODES_PQ) --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" $(PRICE_INDEX): $(MERGE_STAMP) $(PRICE_INDEX_DEPS) | $(PROPERTIES_PQ) $(POSTCODES_PQ) uv run python -m pipeline.transform.price_estimation.index --input $(PROPERTIES_PQ) --postcodes $(POSTCODES_PQ) --output $@ @@ -428,7 +428,7 @@ $(PRICE_INDEX): $(MERGE_STAMP) $(PRICE_INDEX_DEPS) | $(PROPERTIES_PQ) $(POSTCODE $(PRICES_STAMP): $(MERGE_STAMP) $(PRICE_INDEX) $(PRICE_ESTIMATE_DEPS) | $(PROPERTIES_PQ) $(POSTCODES_PQ) @rm -f $@ uv run python -m pipeline.transform.price_estimation.estimate --properties $(PROPERTIES_PQ) --postcodes $(POSTCODES_PQ) --index $(PRICE_INDEX) - $(VALIDATE_OUTPUTS) --parquet $(PROPERTIES_PQ) --parquet $(POSTCODES_PQ) --parquet $(PRICE_INDEX) + $(VALIDATE_OUTPUTS) --parquet $(PROPERTIES_PQ) --parquet $(POSTCODES_PQ) --parquet $(PRICE_INDEX) --postcode-features $(POSTCODES_PQ) --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" --price-index $(PRICE_INDEX) @touch $@ $(ACTUAL_LISTINGS_ENRICHED): $(ACTUAL_LISTINGS_RAW) $(EPC) \ diff --git a/frontend/src/i18n/descriptions.ts b/frontend/src/i18n/descriptions.ts index 941da85..f53fd6b 100644 --- a/frontend/src/i18n/descriptions.ts +++ b/frontend/src/i18n/descriptions.ts @@ -85,7 +85,7 @@ const descriptions: Record<string, Record<string, string>> = { '% White': 'Part de la population s’identifiant comme blanche', '% South Asian': 'Part de la population s’identifiant comme sud-asiatique', '% Black': 'Part de la population s’identifiant comme noire', - '% East Asian': 'Part de la population s’identifiant comme est-asiatique', + '% East/SE Asian': 'Part de la population s’identifiant comme est/sud-est asiatique', '% Mixed': 'Part de la population s’identifiant comme métisse ou de plusieurs groupes ethniques', '% Other': 'Part de la population s’identifiant comme appartenant à un autre groupe ethnique', @@ -98,7 +98,7 @@ const descriptions: Record<string, Record<string, string>> = { '% Green': 'Part des voix vertes aux élections générales de 2024', '% Other parties': 'Part cumulée des voix de tous les autres partis et indépendants', 'Distance to nearest park (km)': 'Distance au parc ou espace vert le plus proche', - 'Noise (dB)': 'Niveau maximal de bruit des transports près du code postal, en décibels (Lden)', + 'Noise (dB)': 'Le plus élevé des bruits routier, ferroviaire ou aérien près du code postal, en décibels (Lden). Angleterre uniquement ; vide = hors zone cartographiée, pas forcément calme.', 'Max available download speed (Mbps)': 'Débit descendant haut débit maximal disponible au code postal', Schools: 'Écoles primaires et secondaires notées à proximité', 'Specific crimes': 'Filtrer une seule catégorie d’infractions de rue à la fois', @@ -185,7 +185,7 @@ const descriptions: Record<string, Record<string, string>> = { '% White': 'Anteil der Personen, die sich als weiß identifizieren', '% South Asian': 'Anteil der Personen, die sich als südasiatisch identifizieren', '% Black': 'Anteil der Personen, die sich als schwarz identifizieren', - '% East Asian': 'Anteil der Personen, die sich als ostasiatisch identifizieren', + '% East/SE Asian': 'Anteil der Personen, die sich als ost-/südostasiatisch identifizieren', '% Mixed': 'Anteil der Personen, die sich als gemischt oder mehreren ethnischen Gruppen zugehörig identifizieren', '% Other': 'Anteil der Personen, die sich einer anderen ethnischen Gruppe zuordnen', @@ -198,7 +198,7 @@ const descriptions: Record<string, Record<string, string>> = { '% Green': 'Stimmenanteil der Grünen bei der Parlamentswahl 2024', '% Other parties': 'Kombinierter Stimmenanteil aller anderen Parteien und Unabhängigen', 'Distance to nearest park (km)': 'Entfernung zum nächsten Park oder Grünfläche', - 'Noise (dB)': 'Maximaler Verkehrslärmpegel in der Nähe des Postcodes in Dezibel (Lden)', + 'Noise (dB)': 'Lautester von Straßen-, Bahn- oder Fluglärm in der Nähe des Postcodes in Dezibel (Lden). Nur England; leer = nicht kartiert, nicht unbedingt leise.', 'Max available download speed (Mbps)': 'Maximal verfügbare Breitband-Downloadgeschwindigkeit am Postcode', Schools: 'Bewertete Grundschulen und weiterführende Schulen in der Nähe', @@ -262,7 +262,7 @@ const descriptions: Record<string, Record<string, string>> = { '% White': '白人人口比例', '% South Asian': '南亚裔人口比例', '% Black': '黑人人口比例', - '% East Asian': '东亚裔人口比例', + '% East/SE Asian': '东亚/东南亚裔人口比例', '% Mixed': '混血或多族裔人口比例', '% Other': '其他族裔人口比例', 'Voter turnout (%)': '2024 年大选中登记选民的投票率', @@ -273,7 +273,7 @@ const descriptions: Record<string, Record<string, string>> = { '% Green': '2024 年大选中绿党得票率', '% Other parties': '所有其他政党和独立候选人的综合得票率', 'Distance to nearest park (km)': '到最近公园或绿地的距离', - 'Noise (dB)': '该邮编附近最高交通噪音水平（Lden，分贝）', + 'Noise (dB)': '该邮编附近道路、铁路或机场中最高的噪音水平（Lden，分贝）。仅英格兰；空白表示未覆盖，不一定安静。', 'Max available download speed (Mbps)': '该邮编可用的最高宽带下载速度', Schools: '附近有评级的小学和中学', 'Specific crimes': '一次筛选一种街面犯罪类别', @@ -347,7 +347,7 @@ const descriptions: Record<string, Record<string, string>> = { '% White': 'श्वेत के रूप में पहचान करने वाली आबादी का प्रतिशत', '% South Asian': 'दक्षिण एशियाई के रूप में पहचान करने वाली आबादी का प्रतिशत', '% Black': 'अश्वेत के रूप में पहचान करने वाली आबादी का प्रतिशत', - '% East Asian': 'पूर्वी एशियाई के रूप में पहचान करने वाली आबादी का प्रतिशत', + '% East/SE Asian': 'पूर्वी/दक्षिण-पूर्वी एशियाई के रूप में पहचान करने वाली आबादी का प्रतिशत', '% Mixed': 'मिश्रित या कई जातीय समूहों से पहचान करने वाली आबादी का प्रतिशत', '% Other': 'अन्य जातीय समूह के रूप में पहचान करने वाली आबादी का प्रतिशत', 'Voter turnout (%)': '2024 आम चुनाव में मतदान करने वाले पंजीकृत मतदाताओं का प्रतिशत', @@ -358,7 +358,7 @@ const descriptions: Record<string, Record<string, string>> = { '% Green': '2024 आम चुनाव में ग्रीन पार्टी का मत-प्रतिशत', '% Other parties': 'बाकी सभी पार्टियों और निर्दलीयों का संयुक्त मत-प्रतिशत', 'Distance to nearest park (km)': 'निकटतम पार्क या हरित क्षेत्र तक दूरी', - 'Noise (dB)': 'पोस्टकोड पर सड़क शोर स्तर, डेसीबल (Lden) में', + 'Noise (dB)': 'पोस्टकोड के पास सड़क, रेल या हवाई अड्डे के शोर में सबसे अधिक, डेसीबल (Lden) में। केवल इंग्लैंड; खाली = मैप नहीं किया गया, जरूरी नहीं कि शांत हो।', 'Max available download speed (Mbps)': 'पोस्टकोड पर उपलब्ध अधिकतम डाउनलोड गति', Schools: 'पास के रेटेड प्राइमरी और सेकेंडरी स्कूल', 'Specific crimes': 'एक समय में एक सड़क-स्तर अपराध श्रेणी से फिल्टर करें', @@ -438,7 +438,7 @@ const descriptions: Record<string, Record<string, string>> = { '% White': 'A fehérként azonosított lakosság aránya', '% South Asian': 'A dél-ázsiaiként azonosított lakosság aránya', '% Black': 'A feketeként azonosított lakosság aránya', - '% East Asian': 'A kelet-ázsiaiként azonosított lakosság aránya', + '% East/SE Asian': 'A kelet-/délkelet-ázsiaiként azonosított lakosság aránya', '% Mixed': 'A vegyes vagy több etnikai csoporthoz tartozóként azonosított lakosság aránya', '% Other': 'Az egyéb etnikai csoportba tartozóként azonosított lakosság aránya', 'Voter turnout (%)': @@ -450,7 +450,7 @@ const descriptions: Record<string, Record<string, string>> = { '% Green': 'A Zöld Párt szavazataránya a 2024-es parlamenti választáson', '% Other parties': 'Az összes többi párt és független jelölt összesített szavazataránya', 'Distance to nearest park (km)': 'Távolság a legközelebbi parkig vagy zöldterületig', - 'Noise (dB)': 'Közúti zajszint az irányítószámnál decibelben (Lden)', + 'Noise (dB)': 'Az út-, vasúti vagy repülőtéri zaj közül a leghangosabb az irányítószámnál, decibelben (Lden). Csak Anglia; üres = nem térképezett, nem feltétlenül csendes.', 'Max available download speed (Mbps)': 'Az irányítószámnál elérhető maximális szélessávú letöltési sebesség', Schools: 'Közeli minősített általános és középiskolák', diff --git a/frontend/src/i18n/details.ts b/frontend/src/i18n/details.ts index e1179ad..72016ed 100644 --- a/frontend/src/i18n/details.ts +++ b/frontend/src/i18n/details.ts @@ -109,8 +109,8 @@ export const details: Record<string, Record<string, string>> = { "Provient du Census 2021. Pourcentage de la population de l'autorité locale s'identifiant comme Indien, Pakistanais, Bangladais ou toute autre origine asiatique.", '% Black': "Provient du Census 2021. Pourcentage de la population de l'autorité locale s'identifiant comme Noir, Noir britannique, Caribéen ou Africain.", - '% East Asian': - "Provient du Census 2021. Pourcentage de la population de l'autorité locale s'identifiant comme Chinois.", + '% East/SE Asian': + "Provient du Census 2021. Pourcentage de la population de l'autorité locale s'identifiant comme Chinois ou d'une autre origine est/sud-est asiatique.", '% Mixed': "Provient du Census 2021. Pourcentage de la population de l'autorité locale s'identifiant comme Mixte ou appartenant à plusieurs groupes ethniques (Blanc et Noir caribéen, Blanc et Noir africain, Blanc et Asiatique, ou tout autre fond mixte ou multiple).", '% Other': @@ -132,7 +132,7 @@ export const details: Record<string, Record<string, string>> = { 'Distance to nearest park (km)': "Distance à vol d'oiseau en kilomètres entre le code postal et l'entrée de parc la plus proche. Couvre les parcs publics, jardins, terrains de sport et aires de jeux. Utilise les points d'accès du jeu de données OS Open Greenspace, afin que les biens en bordure d'un grand parc affichent bien une courte distance.", 'Noise (dB)': - "Niveau maximal de bruit routier, ferroviaire ou aérien en décibels (Lden, moyenne pondérée sur 24 heures) d'après le Strategic Noise Mapping Round 4 de Defra (2022). Modélisé à 4 m au-dessus du sol sur une grille de 10 m et échantillonné comme la cellule de 10 m la plus bruyante autour du point représentatif du code postal. Au-dessus d'environ 55 dB, le bruit est généralement perceptible ; au-dessus d'environ 70 dB, l'OMS le considère comme nocif.", + "Niveau maximal de bruit routier, ferroviaire ou aérien en décibels (Lden, moyenne pondérée sur 24 heures) d'après le Strategic Noise Mapping Round 4 de Defra (2022). Modélisé à 4 m au-dessus du sol sur une grille de 10 m et échantillonné comme la cellule de 10 m la plus bruyante autour du point représentatif du code postal. Au-dessus d'environ 55 dB, le bruit est généralement perceptible ; au-dessus d'environ 70 dB, l'OMS le considère comme nocif. Couvre l'Angleterre uniquement ; une valeur vide signifie l'absence de données cartographiées (pas forcément calme).", 'Max available download speed (Mbps)': "Débit descendant maximal de haut débit fixe disponible auprès de n'importe quel fournisseur, d'après Ofcom Connected Nations 2025. Il s'agit du maximum théorique, pas des débits réellement obtenus. 10 Mbps = basique, 30 = superfast, 100+ = ultrafast, 1000 = gigabit.", Schools: @@ -255,8 +255,8 @@ export const details: Record<string, Record<string, string>> = { 'Aus dem Census 2021. Prozentsatz der Bevölkerung der Gemeinde, die sich als Indisch, Pakistanisch, Bangladeschisch oder mit sonstigem asiatischen Hintergrund identifiziert.', '% Black': 'Aus dem Census 2021. Prozentsatz der Bevölkerung der Gemeinde, die sich als Schwarz, Schwarz-Britisch, Karibisch oder Afrikanisch identifiziert.', - '% East Asian': - 'Aus dem Census 2021. Prozentsatz der Bevölkerung der Gemeinde, die sich als Chinesisch identifiziert.', + '% East/SE Asian': + 'Aus dem Census 2021. Prozentsatz der Bevölkerung der Gemeinde, die sich als Chinesisch oder einer anderen ost-/südostasiatischen Herkunft identifiziert.', '% Mixed': 'Aus dem Census 2021. Prozentsatz der Bevölkerung der Gemeinde, die sich als gemischt oder mit mehreren ethnischen Zugehörigkeiten identifiziert (Weiß und Schwarzkaribisch, Weiß und Schwarzafrikanisch, Weiß und Asiatisch oder sonstiger gemischter Hintergrund).', '% Other': @@ -278,7 +278,7 @@ export const details: Record<string, Record<string, string>> = { 'Distance to nearest park (km)': 'Luftlinienentfernung in Kilometern vom Postleitzahlenzentrum zum nächsten Parkeingang. Umfasst öffentliche Parks, Gärten, Sportplätze und Spielbereiche. Verwendet Zugangspunktstandorte aus dem OS Open Greenspace-Datensatz, sodass Immobilien an der Grenze eines großen Parks korrekt eine kurze Entfernung anzeigen.', 'Noise (dB)': - 'Straßenlärmpegel in Dezibel (Lden, ein 24-Stunden-gewichteter Durchschnitt) aus Defras Strategic Noise Mapping Round 4 (2022). Modelliert in 4 m Höhe über dem Boden auf einem 10-m-Raster. Über ~55 dB ist in der Regel wahrnehmbar; über ~70 dB gilt laut WHO als gesundheitsschädlich.', + 'Straßenlärmpegel in Dezibel (Lden, ein 24-Stunden-gewichteter Durchschnitt) aus Defras Strategic Noise Mapping Round 4 (2022). Modelliert in 4 m Höhe über dem Boden auf einem 10-m-Raster. Über ~55 dB ist in der Regel wahrnehmbar; über ~70 dB gilt laut WHO als gesundheitsschädlich. Nur England; ein leerer Wert bedeutet keine kartierten Daten (nicht unbedingt leise).', 'Max available download speed (Mbps)': 'Maximale verfügbare Festnetz-Download-Geschwindigkeit von einem beliebigen Anbieter, aus Ofcom Connected Nations 2025. Gibt die theoretische Höchstgeschwindigkeit an, keine tatsächlich erreichten Geschwindigkeiten. 10 Mbps = Basis, 30 = schnell, 100+ = ultraschnell, 1000 = Gigabit.', Schools: @@ -398,7 +398,7 @@ export const details: Record<string, Record<string, string>> = { '% South Asian': '来自2021年Census。地方政府人口中认同为印度人、巴基斯坦人、孟加拉国人或其他亚洲背景的百分比。', '% Black': '来自2021年Census。地方政府人口中认同为黑人、英国黑人、加勒比人或非洲人的百分比。', - '% East Asian': '来自2021年Census。地方政府人口中认同为华人的百分比。', + '% East/SE Asian': '来自2021年Census。地方政府人口中认同为华人或其他东亚/东南亚裔的百分比。', '% Mixed': '来自2021年 Census。地方政府人口中认同为混血或多种族群体（白人与黑人加勒比裔、白人与黑人非洲裔、白人与亚洲裔，或其他混血或多种族背景）的百分比。', '% Other': @@ -416,7 +416,7 @@ export const details: Record<string, Record<string, string>> = { 'Distance to nearest park (km)': '从邮政编码到最近公园入口的直线距离（km）。涵盖公共公园、花园、运动场和游乐场地。使用 OS Open Greenspace 数据集中的出入口位置，因此紧邻大型公园的房产可正确显示较短距离。', 'Noise (dB)': - '来自Defra战略噪声图第4轮（2022年）的道路噪声水平，单位为分贝（Lden，24小时加权平均值）。在地面以上4m、10m网格间距处建模。一般而言，超过约55 dB可明显感知；超过约70 dB被世卫组织认定为有害。', + '来自Defra战略噪声图第4轮（2022年）的道路噪声水平，单位为分贝（Lden，24小时加权平均值）。在地面以上4m、10m网格间距处建模。一般而言，超过约55 dB可明显感知；超过约70 dB被世卫组织认定为有害。仅覆盖英格兰；空值表示无映射数据（不一定安静）。', 'Max available download speed (Mbps)': '来自Ofcom Connected Nations 2025的任意运营商可提供的最大固定宽带下载速度。代表理论最大值，而非实际达到的速度。10 Mbps为基础级，30为超快级，100+为极速级，1000为千兆级。', Schools: @@ -539,8 +539,8 @@ export const details: Record<string, Record<string, string>> = { 'Census 2021 से. स्थानीय प्राधिकरण की आबादी का प्रतिशत जो खुद को भारतीय, पाकिस्तानी, बांग्लादेशी या किसी अन्य एशियाई पृष्ठभूमि के रूप में पहचानता है.', '% Black': 'Census 2021 से. स्थानीय प्राधिकरण की आबादी का प्रतिशत जो खुद को अश्वेत, अश्वेत ब्रिटिश, कैरिबियाई या अफ्रीकी के रूप में पहचानता है.', - '% East Asian': - 'Census 2021 से. स्थानीय प्राधिकरण की आबादी का प्रतिशत जो खुद को चीनी के रूप में पहचानता है.', + '% East/SE Asian': + 'Census 2021 से. स्थानीय प्राधिकरण की आबादी का प्रतिशत जो खुद को चीनी या अन्य पूर्वी/दक्षिण-पूर्वी एशियाई के रूप में पहचानता है.', '% Mixed': 'Census 2021 से. स्थानीय प्राधिकरण की आबादी का प्रतिशत जो खुद को मिश्रित या कई जातीय समूहों (श्वेत और अश्वेत कैरिबियाई, श्वेत और अश्वेत अफ्रीकी, श्वेत और एशियाई या अन्य मिश्रित/बहुजातीय पृष्ठभूमि) के रूप में पहचानता है.', '% Other': @@ -562,7 +562,7 @@ export const details: Record<string, Record<string, string>> = { 'Distance to nearest park (km)': 'पोस्टकोड से निकटतम पार्क प्रवेश तक सीधी रेखा में दूरी, किलोमीटर में. इसमें सार्वजनिक पार्क, बगीचे, खेल मैदान और खेल स्थान शामिल हैं. OS Open Greenspace डेटा सेट के प्रवेश-बिंदु स्थानों का उपयोग करता है, इसलिए बड़े पार्क के किनारे स्थित संपत्तियां सही कम दूरी दिखाती हैं.', 'Noise (dB)': - 'Defra Strategic Noise Mapping Round 4 (2022) से सड़क-शोर स्तर, डेसीबल में (Lden, 24-घंटे भारित औसत). जमीन से 4 m ऊपर 10 m ग्रिड पर मॉडल किया गया. लगभग 55 dB से ऊपर शोर आमतौर पर महसूस होता है; लगभग 70 dB से ऊपर WHO इसे हानिकारक मानता है.', + 'Defra Strategic Noise Mapping Round 4 (2022) से सड़क-शोर स्तर, डेसीबल में (Lden, 24-घंटे भारित औसत). जमीन से 4 m ऊपर 10 m ग्रिड पर मॉडल किया गया. लगभग 55 dB से ऊपर शोर आमतौर पर महसूस होता है; लगभग 70 dB से ऊपर WHO इसे हानिकारक मानता है. केवल इंग्लैंड को कवर करता है; खाली मान का अर्थ है कोई मैप किया गया डेटा नहीं (जरूरी नहीं कि शांत हो).', 'Max available download speed (Mbps)': 'Ofcom Connected Nations 2025 से किसी भी प्रदाता द्वारा उपलब्ध अधिकतम स्थिर ब्रॉडबैंड डाउनलोड गति. यह सैद्धांतिक अधिकतम दिखाता है, वास्तविक प्राप्त गति नहीं. 10 Mbps = बुनियादी, 30 = तेज, 100+ = अत्यंत तेज, 1000 = गीगाबिट.', Schools: @@ -685,8 +685,8 @@ export const details: Record<string, Record<string, string>> = { 'A 2021-es Census alapján. A helyi hatóság területén indiai, pakisztáni, bangladesi vagy bármely más ázsiai háttérként azonosított népesség százaléka.', '% Black': 'A 2021-es Census alapján. A helyi hatóság területén fekete, brit fekete, karibi vagy afrikai háttérként azonosított népesség százaléka.', - '% East Asian': - 'A 2021-es Census alapján. A helyi hatóság területén kínaiként azonosított népesség százaléka.', + '% East/SE Asian': + 'A 2021-es Census alapján. A helyi hatóság területén kínai vagy más kelet-/délkelet-ázsiai származásúként azonosított népesség százaléka.', '% Mixed': 'A 2021-es Census alapján. A helyi hatóság területén vegyes vagy többes etnikai csoportként (fehér és fekete karibi, fehér és fekete afrikai, fehér és ázsiai, vagy bármely más vegyes vagy többes háttér) azonosított népesség százaléka.', '% Other': @@ -708,7 +708,7 @@ export const details: Record<string, Record<string, string>> = { 'Distance to nearest park (km)': 'Légvonalbeli távolság kilométerben az irányítószámtól a legközelebbi park bejáratáig. Magában foglalja a közparkokat, kerteket, játszótereket és szabadidős területeket. Az OS Open Greenspace adatkészlet hozzáférési pont helyszíneit használja, így a nagy park szomszédságában lévő ingatlanok helyesen rövid távolságot mutatnak.', 'Noise (dB)': - 'Közúti zajszint decibel (Lden, 24 órás súlyozott átlag) értékben, a Defra Stratégiai Zajtérképezés 4. fordulójából (2022). 4 m magasságban, 10 m-es rácson modellezve. ~55 dB felett általában érzékelhető; ~70 dB felett a WHO károsnak minősíti.', + 'Közúti zajszint decibel (Lden, 24 órás súlyozott átlag) értékben, a Defra Stratégiai Zajtérképezés 4. fordulójából (2022). 4 m magasságban, 10 m-es rácson modellezve. ~55 dB felett általában érzékelhető; ~70 dB felett a WHO károsnak minősíti. Csak Angliát fedi le; az üres érték nem térképezett adatot jelent (nem feltétlenül csendes).', 'Max available download speed (Mbps)': 'Bármely szolgáltatótól elérhető maximális rögzített szélessávú letöltési sebesség, az Ofcom Connected Nations 2025 adataiból. Az elméleti maximumot jelöli, nem a valós sebességet. 10 Mbps = alapszintű, 30 = szupergyors, 100+ = ultragyors, 1000 = gigabites.', Schools: diff --git a/frontend/src/i18n/locales/de.ts b/frontend/src/i18n/locales/de.ts index a0df5a0..7ba16ea 100644 --- a/frontend/src/i18n/locales/de.ts +++ b/frontend/src/i18n/locales/de.ts @@ -1519,7 +1519,7 @@ const de: Translations = { '% White': '% weiß', '% South Asian': '% südasiatisch', '% Black': '% schwarz', - '% East Asian': '% ostasiatisch', + '% East/SE Asian': '% ost-/südostasiatisch', '% Mixed': '% gemischt', '% Other': '% Sonstige', diff --git a/frontend/src/i18n/locales/en.ts b/frontend/src/i18n/locales/en.ts index 22f0bef..a8b2eee 100644 --- a/frontend/src/i18n/locales/en.ts +++ b/frontend/src/i18n/locales/en.ts @@ -1485,7 +1485,7 @@ const en = { '% White': '% White', '% South Asian': '% South Asian', '% Black': '% Black', - '% East Asian': '% East Asian', + '% East/SE Asian': '% East/SE Asian', '% Mixed': '% Mixed', '% Other': '% Other', diff --git a/frontend/src/i18n/locales/fr.ts b/frontend/src/i18n/locales/fr.ts index bd4978b..67188e7 100644 --- a/frontend/src/i18n/locales/fr.ts +++ b/frontend/src/i18n/locales/fr.ts @@ -1531,7 +1531,7 @@ const fr: Translations = { '% White': '% Blancs', '% South Asian': '% Sud-Asiatiques', '% Black': '% Noirs', - '% East Asian': '% Est-Asiatiques', + '% East/SE Asian': '% est/sud-est asiatique', '% Mixed': '% Métis', '% Other': '% Autres', diff --git a/frontend/src/i18n/locales/hi.ts b/frontend/src/i18n/locales/hi.ts index b7b7039..7f9f742 100644 --- a/frontend/src/i18n/locales/hi.ts +++ b/frontend/src/i18n/locales/hi.ts @@ -1431,7 +1431,7 @@ const hi: Translations = { '% White': '% श्वेत', '% South Asian': '% दक्षिण एशियाई', '% Black': '% अश्वेत', - '% East Asian': '% पूर्वी एशियाई', + '% East/SE Asian': '% पूर्वी/दक्षिण-पूर्वी एशियाई', '% Mixed': '% मिश्रित', '% Other': '% अन्य', 'Voter turnout (%)': 'मतदाता भागीदारी (%)', diff --git a/frontend/src/i18n/locales/hu.ts b/frontend/src/i18n/locales/hu.ts index ff5e8d3..5275dc6 100644 --- a/frontend/src/i18n/locales/hu.ts +++ b/frontend/src/i18n/locales/hu.ts @@ -1512,7 +1512,7 @@ const hu: Translations = { '% White': '% fehér', '% South Asian': '% dél-ázsiai', '% Black': '% fekete', - '% East Asian': '% kelet-ázsiai', + '% East/SE Asian': '% kelet-/dél-kelet-ázsiai', '% Mixed': '% vegyes', '% Other': '% egyéb', diff --git a/frontend/src/i18n/locales/zh.ts b/frontend/src/i18n/locales/zh.ts index 303da18..8e1b0ee 100644 --- a/frontend/src/i18n/locales/zh.ts +++ b/frontend/src/i18n/locales/zh.ts @@ -1428,7 +1428,7 @@ const zh: Translations = { '% White': '% 白人', '% South Asian': '% 南亚裔', '% Black': '% 黑人', - '% East Asian': '% 东亚裔', + '% East/SE Asian': '% 东亚/东南亚裔', '% Mixed': '% 混血', '% Other': '% 其他', diff --git a/frontend/src/lib/consts.ts b/frontend/src/lib/consts.ts index 0328579..d996ce2 100644 --- a/frontend/src/lib/consts.ts +++ b/frontend/src/lib/consts.ts @@ -267,7 +267,7 @@ export const STACKED_GROUPS: Record< { label: 'Ethnic composition', unit: '%', - components: ['% White', '% South Asian', '% East Asian', '% Black', '% Mixed', '% Other'], + components: ['% White', '% South Asian', '% East/SE Asian', '% Black', '% Mixed', '% Other'], }, { label: 'Political vote share', @@ -384,13 +384,6 @@ export const ENUM_COLOR_OVERRIDES: Record<string, Record<string, [number, number F: [239, 68, 68], G: [126, 34, 206], }, - 'Max available download speed (Mbps)': { - '10': [107, 114, 128], - '30': [245, 158, 11], - '100': [59, 130, 246], - '300': [20, 184, 166], - '1000': [34, 197, 94], - }, }; /** @@ -451,7 +444,7 @@ export const STACKED_SEGMENT_COLORS: Record<string, string> = { 'Other crime (avg/yr)': '#6b7280', '% White': '#3b82f6', '% South Asian': '#f97316', - '% East Asian': '#eab308', + '% East/SE Asian': '#eab308', '% Black': '#8b5cf6', '% Mixed': '#14b8a6', '% Other': '#6b7280', diff --git a/frontend/src/lib/ethnicity-filter.ts b/frontend/src/lib/ethnicity-filter.ts index 597a7c3..0c1bb93 100644 --- a/frontend/src/lib/ethnicity-filter.ts +++ b/frontend/src/lib/ethnicity-filter.ts @@ -6,7 +6,7 @@ export const ETHNICITIES_FILTER_KEY_PREFIX = `${ETHNICITIES_FILTER_NAME}:`; export const ETHNICITY_FEATURE_NAMES = [ '% White', '% South Asian', - '% East Asian', + '% East/SE Asian', '% Black', '% Mixed', '% Other', diff --git a/frontend/src/lib/feature-icons.tsx b/frontend/src/lib/feature-icons.tsx index 52d21c4..19ed953 100644 --- a/frontend/src/lib/feature-icons.tsx +++ b/frontend/src/lib/feature-icons.tsx @@ -367,7 +367,7 @@ const FEATURE_ICON_PATHS: Record<string, ReactNode> = { <path d="M16 3.13a4 4 0 010 7.75" /> </> ), - '% East Asian': ( + '% East/SE Asian': ( <> <path d="M17 21v-2a4 4 0 00-4-4H5a4 4 0 00-4 4v2" /> <circle cx="9" cy="7" r="4" /> diff --git a/pipeline/download/ethnicity.py b/pipeline/download/ethnicity.py index 5fb9272..6e31ee3 100644 --- a/pipeline/download/ethnicity.py +++ b/pipeline/download/ethnicity.py @@ -36,7 +36,8 @@ GEOGRAPHY_CODE_REPLACEMENTS = { def _ethnicity_percentages(df: pl.DataFrame) -> pl.DataFrame: # Use the detailed 19+1 breakdown to get sub-categories for Asian ethnicity, - # then aggregate back to the broad groups plus South Asian / East Asian split. + # then aggregate back to the broad groups plus a South Asian / East/SE Asian + # split (Indian/Pakistani/Bangladeshi vs Chinese + other East/SE Asian). detailed = df.filter( (pl.col("Ethnicity_type") == "ONS 2021 19+1") & (pl.col("Ethnicity") != "All") ) @@ -53,9 +54,13 @@ def _ethnicity_percentages(df: pl.DataFrame) -> pl.DataFrame: "Indian": "South Asian", "Pakistani": "South Asian", "Bangladeshi": "South Asian", - "Any Other Asian Background": "South Asian", - # East Asian - "Chinese": "East Asian", + # East / Southeast Asian. The ONS "Any Other Asian Background" bucket is + # predominantly East/Southeast Asian (Filipino, Vietnamese, Thai, + # Japanese, Korean, ...) rather than South Asian, so route it here rather + # than inflating "% South Asian". The split is approximate (the ONS + # bucket also holds some South Asian groups such as Sri Lankan/Nepalese). + "Chinese": "East/SE Asian", + "Any Other Asian Background": "East/SE Asian", # Black "Black African": "Black", "Black Caribbean": "Black", diff --git a/pipeline/download/test_ethnicity.py b/pipeline/download/test_ethnicity.py index e428b33..d83b8b4 100644 --- a/pipeline/download/test_ethnicity.py +++ b/pipeline/download/test_ethnicity.py @@ -35,3 +35,31 @@ def test_ethnicity_percentages_recombines_predecessor_lads_by_population(): assert cumberland.select("% White", "% South Asian").to_dicts() == [ {"% White": 45.0, "% South Asian": 55.0} ] + + +def test_ethnicity_routes_any_other_asian_to_east_se_asian(): + """'Any Other Asian Background' and 'Chinese' both fold into '% East/SE Asian' + (not '% South Asian'), fixing the East/SE Asian undercount.""" + rows = [ + { + "Geography_code": "E06000001", + "Ethnicity_type": "ONS 2021 19+1", + "Ethnicity": ethnicity, + "Ethnic Population": pop, + "Value1": 0.0, + } + for ethnicity, pop in [ + ("Chinese", 30), + ("Any Other Asian Background", 20), + ("Indian", 50), + ] + ] + + result = _ethnicity_percentages(pl.DataFrame(rows)) + area = result.filter(pl.col("Geography_code") == "E06000001") + + assert "% East/SE Asian" in result.columns + assert "% East Asian" not in result.columns + assert area.select("% East/SE Asian", "% South Asian").to_dicts() == [ + {"% East/SE Asian": 50.0, "% South Asian": 50.0} + ] diff --git a/pipeline/test_validate_outputs.py b/pipeline/test_validate_outputs.py index 2f36581..748a661 100644 --- a/pipeline/test_validate_outputs.py +++ b/pipeline/test_validate_outputs.py @@ -222,3 +222,108 @@ def test_rejects_active_english_arcgis_boundary_mismatch(tmp_path, monkeypatch, stderr = capsys.readouterr().err assert "active English postcodes" in stderr assert "not active English postcodes" in stderr + + +def _write_postcode_features(path, rows): + pl.DataFrame(rows).write_parquet(path) + + +def test_validates_postcode_features_valid(tmp_path, monkeypatch): + path = tmp_path / "postcode.parquet" + _write_postcode_features( + path, + { + "Postcode": ["AA1 1AA", "BB1 1BB"], + "lat": [51.5, 53.4], + "lon": [-0.1, -2.2], + "ctry25cd": ["E92000001", "E92000001"], + "% White": [80.0, 55.0], + }, + ) + monkeypatch.setattr("sys.argv", ["validate", "--postcode-features", str(path)]) + assert main() == 0 + + +def test_rejects_contaminated_postcode_features(tmp_path, monkeypatch, capsys): + path = tmp_path / "postcode.parquet" + _write_postcode_features( + path, + { + "Postcode": ["AA1 1AA", "AA1 1AA", "CF10 1AA"], # duplicate AA1 1AA + "lat": [51.5, 51.5, None], # Welsh row has null coord + "lon": [-0.1, -0.1, None], + "ctry25cd": ["E92000001", "E92000001", "W92000004"], + "% White": [80.0, 150.0, 90.0], # 150 out of [0,100] + }, + ) + monkeypatch.setattr("sys.argv", ["validate", "--postcode-features", str(path)]) + assert main() == 1 + err = capsys.readouterr().err + assert "not unique" in err + assert "E92000001" in err # country contamination + assert "out-of-England" in err or "lat/lon" in err + assert "[0, 100]" in err + + +def test_validates_properties_subset(tmp_path, monkeypatch): + postcode = tmp_path / "postcode.parquet" + properties = tmp_path / "properties.parquet" + pl.DataFrame({"Postcode": ["AA1 1AA", "BB1 1BB"]}).write_parquet(postcode) + pl.DataFrame( + {"Postcode": ["AA1 1AA"], "Last known price": [250_000]} + ).write_parquet(properties) + monkeypatch.setattr( + "sys.argv", + ["validate", "--properties-subset", f"{properties}::{postcode}"], + ) + assert main() == 0 + + +def test_rejects_orphan_properties(tmp_path, monkeypatch, capsys): + postcode = tmp_path / "postcode.parquet" + properties = tmp_path / "properties.parquet" + pl.DataFrame({"Postcode": ["AA1 1AA"]}).write_parquet(postcode) + pl.DataFrame( + {"Postcode": ["CC1 1CC"], "Last known price": [-5]} # orphan + negative price + ).write_parquet(properties) + monkeypatch.setattr( + "sys.argv", + ["validate", "--properties-subset", f"{properties}::{postcode}"], + ) + assert main() == 1 + err = capsys.readouterr().err + assert "absent from" in err + assert "non-positive" in err + + +def test_validates_price_index_allows_zero_n_pairs(tmp_path, monkeypatch): + path = tmp_path / "price_index.parquet" + pl.DataFrame( + { + "sector": ["A1 1", "A1 1", "B2 2"], + "type_group": ["All", "Detached", "All"], + "year": [2024, 2024, 2024], + "log_index": [0.5, 0.4, 0.0], + "n_pairs": [100, 0, 0], # zero n_pairs is a legitimate fallback + } + ).write_parquet(path) + monkeypatch.setattr("sys.argv", ["validate", "--price-index", str(path)]) + assert main() == 0 + + +def test_rejects_price_index_nonfinite_and_duplicate(tmp_path, monkeypatch, capsys): + path = tmp_path / "price_index.parquet" + pl.DataFrame( + { + "sector": ["A1 1", "A1 1"], + "type_group": ["All", "All"], # duplicate (sector, type_group, year) + "year": [2024, 2024], + "log_index": [float("inf"), 0.3], # non-finite + "n_pairs": [10, 10], + } + ).write_parquet(path) + monkeypatch.setattr("sys.argv", ["validate", "--price-index", str(path)]) + assert main() == 1 + err = capsys.readouterr().err + assert "non-finite" in err + assert "not unique" in err diff --git a/pipeline/transform/crime.py b/pipeline/transform/crime.py index 6cc5784..9dfbafa 100644 --- a/pipeline/transform/crime.py +++ b/pipeline/transform/crime.py @@ -28,6 +28,17 @@ MINOR_CRIME_TYPES = ( "Other crime", ) +# Legacy police.uk crime-type names (pre-2014 taxonomy) mapped to their closest +# current equivalent. Without this, ~1.9M incidents from 2010-2013 ("Violent +# crime", "Public disorder and weapons") are unrecognised and silently dropped, +# which understates pre-2013 serious crime and creates an artificial 2012->2013 +# step in the by-year series. Applied with `.replace` (not `.replace_strict`) so +# unmapped current types pass through unchanged. +LEGACY_CRIME_TYPE_ALIASES = { + "Violent crime": "Violence and sexual offences", + "Public disorder and weapons": "Public order", +} + def find_street_crime_csvs(crime_dir: Path) -> tuple[list[Path], int]: csvs = sorted(crime_dir.rglob("*.csv")) @@ -96,6 +107,7 @@ def transform_crime( & pl.col("Crime type").is_not_null() & (pl.col("Crime type") != "") ) + .with_columns(pl.col("Crime type").replace(LEGACY_CRIME_TYPE_ALIASES)) .group_by("LSOA code", "Month", "Crime type") .agg((pl.col("_weight").first() * pl.len()).alias("count")) .group_by("LSOA code", "Crime type") @@ -147,7 +159,10 @@ def _write_crime_by_year( & (pl.col("LSOA code") != "") & pl.col("Crime type").is_not_null() & (pl.col("Crime type") != "") - ).with_columns(pl.col("Month").str.slice(0, 4).cast(pl.Int32).alias("year")) + ).with_columns( + pl.col("Month").str.slice(0, 4).cast(pl.Int32).alias("year"), + pl.col("Crime type").replace(LEGACY_CRIME_TYPE_ALIASES), + ) # Months observed *anywhere* in the dataset for each year (annualisation denominator). # Using crime-type-specific months would over-scale years where a rare type appears diff --git a/pipeline/transform/crime_hotspot_tiles.py b/pipeline/transform/crime_hotspot_tiles.py index 87dd131..45baa0c 100644 --- a/pipeline/transform/crime_hotspot_tiles.py +++ b/pipeline/transform/crime_hotspot_tiles.py @@ -17,7 +17,7 @@ from pathlib import Path import polars as pl from pipeline.local_temp import local_tmp_dir -from pipeline.transform.crime import find_street_crime_csvs +from pipeline.transform.crime import LEGACY_CRIME_TYPE_ALIASES, find_street_crime_csvs def _latest_months(crime_dir: Path, month_count: int) -> list[str]: @@ -80,6 +80,10 @@ def _write_geojsonseq(csvs: list[Path], output_path: Path) -> tuple[int, int]: .drop_nulls(["lon", "lat"]) .filter(pl.col("lon").is_between(-9.5, 5.0)) .filter(pl.col("lat").is_between(49.0, 57.0)) + # Canonicalise any legacy pre-2014 type names so the heatmap's crime_type + # values always match the frontend's canonical filter list (a no-op for + # the recent months this overlay normally covers). + .with_columns(pl.col("crime_type").replace(LEGACY_CRIME_TYPE_ALIASES)) .group_by("lon", "lat", "month", "crime_type") .len() .rename({"len": "count"}) diff --git a/pipeline/transform/crime_spatial.py b/pipeline/transform/crime_spatial.py index 9bd4f40..0c41284 100644 --- a/pipeline/transform/crime_spatial.py +++ b/pipeline/transform/crime_spatial.py @@ -44,6 +44,7 @@ import shapely from pyproj import Transformer from pipeline.transform.crime import ( + LEGACY_CRIME_TYPE_ALIASES, MINOR_CRIME_TYPES, SERIOUS_CRIME_TYPES, find_street_crime_csvs, @@ -150,6 +151,11 @@ def _accumulate_counts( & (pl.col("Crime type") != "") & pl.col("year").is_in(years) ) + # Canonicalise legacy pre-2014 crime-type names ("Violent crime", + # "Public disorder and weapons") to their current equivalents before + # indexing, so ~1.9M historical incidents are counted instead of + # dropped. `.replace` leaves current types unchanged. + .with_columns(pl.col("Crime type").replace(LEGACY_CRIME_TYPE_ALIASES)) # Map crime types to indices with default=None so an unrecognised # type yields a null index we can *report* rather than silently drop # (the legacy LSOA path surfaced unknown types via its dynamic pivot). diff --git a/pipeline/transform/join_epc_pp.py b/pipeline/transform/join_epc_pp.py index ebc0c35..873f65d 100644 --- a/pipeline/transform/join_epc_pp.py +++ b/pipeline/transform/join_epc_pp.py @@ -18,11 +18,49 @@ from ..utils import ( normalize_postcode_key, ) - pl.Config.set_tbl_cols(-1) RATING_RANK = {"A": 1, "B": 2, "C": 3, "D": 4, "E": 5, "F": 6, "G": 7} MIN_PRICE = 50_000 + +# Plausible construction-year range; band-derived years outside it (e.g. OCR +# noise like 1012 or 2202) are nulled rather than published. +MIN_BUILD_YEAR = 1700 +MAX_BUILD_YEAR = 2030 + + +def epc_band_to_year(band: pl.Expr) -> pl.Expr: + """Map an EPC construction age band to a single representative build year. + + EPC age bands are ranges (e.g. ``1950-1966``); we use the band MIDPOINT + (1958) rather than the lower bound, which previously biased every band-derived + year ~10-15 years too young. Open-ended lower bands (``before 1900``) are too + wide to pin to a year and return null. Single-year / ``... onwards`` bands use + that year. Already-numeric inputs (a year produced by an earlier call) pass + through unchanged. Years outside [MIN_BUILD_YEAR, MAX_BUILD_YEAR] are nulled. + """ + text = ( + band.cast(pl.Utf8) + .str.replace("England and Wales: ", "") + .str.replace(" onwards", "") + ) + low = text.str.extract(r"(\d{4})", 1).cast(pl.Int32, strict=False) + high = text.str.extract(r"(\d{4})\D+(\d{4})", 2).cast(pl.Int32, strict=False) + year = ( + pl.when(text.str.starts_with("before ")) + .then(None) + .when(high.is_not_null()) + .then(((low + high) / 2).round(0).cast(pl.Int32)) + .otherwise(low) + ) + return ( + pl.when((year >= MIN_BUILD_YEAR) & (year <= MAX_BUILD_YEAR)) + .then(year) + .otherwise(None) + .cast(pl.UInt16, strict=False) + ) + + EPC_SOURCE_COLUMNS = [ "address", "postcode", @@ -410,13 +448,7 @@ def _run(epc_path: Path, price_paid_path: Path, output_path: Path, temp_dir: Pat # For new-builds (old_new == "Y"), use the first transaction date year as # the exact construction date; otherwise fall back to the EPC age band. - epc_band_year = ( - pl.col("construction_age_band") - .str.replace("England and Wales: ", "") - .str.replace(" onwards", "") - .str.extract(r"(\d{4})", 1) - .cast(pl.UInt16, strict=False) - ) + epc_band_year = epc_band_to_year(pl.col("construction_age_band")) transfer_year = ( pl.col("first_transfer_date").dt.year().cast(pl.UInt16, strict=False) ) diff --git a/pipeline/transform/merge.py b/pipeline/transform/merge.py index ff454bb..d544e4d 100644 --- a/pipeline/transform/merge.py +++ b/pipeline/transform/merge.py @@ -17,7 +17,11 @@ from shapely.strtree import STRtree from thefuzz import fuzz from pipeline.local_temp import local_tmp_dir -from pipeline.transform.join_epc_pp import _scan_epc_certificates +from pipeline.transform.join_epc_pp import _scan_epc_certificates, epc_band_to_year +from pipeline.transform.price_estimation.knn import ( + MAX_COMPARABLE_PSM, + MIN_COMPARABLE_PSM, +) from pipeline.utils.fuzzy_join import ( normalize_address_key, normalize_postcode_key, @@ -59,7 +63,7 @@ _AREA_COLUMNS = [ "Air Quality and Road Safety Score", # Ethnicity "% South Asian", - "% East Asian", + "% East/SE Asian", "% Black", "% Mixed", "% White", @@ -1060,14 +1064,10 @@ def _canonical_epc_property_type_expr() -> pl.Expr: def _construction_year_expr(column: str = "construction_age_band") -> pl.Expr: - return ( - pl.col(column) - .cast(pl.Utf8) - .str.replace("England and Wales: ", "") - .str.replace(" onwards", "") - .str.extract(r"(\d{4})", 1) - .cast(pl.UInt16, strict=False) - ) + # Use the shared band->midpoint-year mapping so the direct-EPC / listings + # path matches join_epc_pp (band midpoint, not lower bound; 'before 1900' and + # implausible years -> null). Already-numeric inputs pass through unchanged. + return epc_band_to_year(pl.col(column)) def _address_score(query: str, candidate: str | None) -> int: @@ -1956,7 +1956,9 @@ def _build( # Broadband: derive max available download speed tier per postcode from # Ofcom availability percentages. Tiers: Gigabit ≥1000, UFBB ≥300, - # UFBB(100) ≥100, SFBB ≥30 Mbps. Stored as string enum. + # UFBB(100) ≥100, SFBB ≥30 Mbps. Stored as a numeric (UInt16) Mbps value so + # it sorts/filters correctly; null (not a fabricated 10) when no availability + # tier is present, so "no data" is distinguishable from a genuine 10 Mbps. broadband = ( pl.scan_parquet(broadband_path) .select( @@ -1969,13 +1971,12 @@ def _build( .then(100) .when(pl.col("SFBB availability (% premises)") > 0) .then(30) - .otherwise(10) + .otherwise(None) .cast(pl.UInt16) .alias("max_download_speed"), ) .group_by("bb_postcode") .agg(pl.col("max_download_speed").max()) - .with_columns(pl.col("max_download_speed").cast(pl.Utf8)) ) area_side_tables = { "iod": iod, @@ -2052,9 +2053,20 @@ def _build( .otherwise(pl.col("current_energy_rating")) .alias("current_energy_rating"), ).with_columns( - (pl.col("latest_price") / pl.col("total_floor_area")) - .round(0) - .cast(pl.Int32) + # Null out implausible per-sqm values (outside the kNN comparable band): + # bulk/block transactions divided by a single unit's floor area otherwise + # produce figures up to ~£1.5M/sqm. + pl.when( + (pl.col("total_floor_area") > MIN_FLOOR_AREA_M2) + & ( + (pl.col("latest_price") / pl.col("total_floor_area")) + .is_between(MIN_COMPARABLE_PSM, MAX_COMPARABLE_PSM) + ) + ) + .then( + (pl.col("latest_price") / pl.col("total_floor_area")).round(0).cast(pl.Int32) + ) + .otherwise(None) .alias("Price per sqm"), ) wide = _finalize_merged_columns(wide) diff --git a/pipeline/transform/postcode_boundaries/output.py b/pipeline/transform/postcode_boundaries/output.py index a224393..ecd3d1c 100644 --- a/pipeline/transform/postcode_boundaries/output.py +++ b/pipeline/transform/postcode_boundaries/output.py @@ -5,6 +5,7 @@ from pathlib import Path from pyproj import Transformer from shapely import make_valid, set_precision +from shapely.errors import GEOSException from shapely.geometry import MultiPolygon, Polygon, mapping, shape from shapely.ops import transform as transform_geometry from shapely.ops import unary_union @@ -43,7 +44,14 @@ def _largest_polygonal(geom) -> Polygon | None: def to_wgs84_geojson( geom: Polygon | MultiPolygon, tolerance: float = 1.0 ) -> dict | None: - """Simplify geometry in BNG, convert to WGS84, return GeoJSON dict.""" + """Simplify geometry in BNG, convert to WGS84, return a valid GeoJSON dict. + + Validates the *serialized* GeoJSON dict (via a ``shape()`` round-trip), not + just the intermediate Shapely object: coordinate snapping during + serialization can otherwise leave a self-intersecting ring that only shows up + once the feature is read back from disk. Any such geometry is repaired with + ``make_valid`` before returning so written features are always valid. + """ geom = _largest_polygonal(geom) if geom is None: return None @@ -55,12 +63,28 @@ def to_wgs84_geojson( transformer = _get_to_wgs84() wgs84 = transform_geometry(transformer.transform, simplified) - wgs84 = set_precision(wgs84, 0.000001, mode="valid_output") + try: + wgs84 = set_precision(wgs84, 0.000001, mode="valid_output") + except GEOSException: + # Precision snapping can fail on pathological geometries; fall back to a + # plain validity repair without coordinate snapping. + wgs84 = make_valid(wgs84) wgs84 = _largest_polygonal(wgs84) if wgs84 is None: return None - return mapping(wgs84) + geojson_dict = mapping(wgs84) + + # The geometry that actually reaches disk is the GeoJSON dict, so validate + # *that* (not the pre-serialization object) and repair if needed. + round_trip = shape(geojson_dict) + if round_trip.is_empty or not round_trip.is_valid: + round_trip = _largest_polygonal(make_valid(round_trip)) + if round_trip is None or round_trip.is_empty: + return None + geojson_dict = mapping(round_trip) + + return geojson_dict def _fill_holes(geom): @@ -119,7 +143,11 @@ def merge_fragments( pre_green = combined combined = subtract_greenspace(combined, greenspace_tree, greenspace_geoms) combined = _largest_polygon(combined) - combined = _fill_holes(combined) + # Do NOT _fill_holes here: interior holes carved by the greenspace + # subtraction (lakes, enclosed parks) are intentional, not artifacts. + # Filling them would re-add the removed area and negate the + # subtraction. Artifact holes from the INSPIRE+Voronoi+make_valid + # chain were already removed by the _fill_holes above (pre-subtraction). # Revert if subtraction + fragment selection lost >90% of area if pre_green.area > 0 and combined.area / pre_green.area < 0.1: combined = pre_green diff --git a/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py b/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py index 165f9fe..02655e0 100644 --- a/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py +++ b/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py @@ -893,3 +893,54 @@ class TestSubtractGreenspace: result = subtract_greenspace(postcode, tree, geoms) # 80% < 90% cap, so subtraction should happen assert result.area == pytest.approx(2000, rel=0.01) + + +class TestToWgs84GeojsonValidity: + """to_wgs84_geojson must emit GeoJSON that round-trips to a valid geometry.""" + + def test_geojson_round_trips_to_valid_geometry(self): + from shapely.geometry import shape + + geojson = to_wgs84_geojson(box(530000, 180000, 530100, 180100)) + assert geojson is not None + rt = shape(geojson) + assert not rt.is_empty + assert rt.is_valid + + def test_written_district_features_are_all_valid(self, tmp_path): + from shapely.geometry import shape + + postcodes = { + "AA1 1AA": box(530000, 180000, 530100, 180100), + "AA1 1AB": MultiPolygon( + [ + box(530200, 180000, 530250, 180050), + box(530200, 180060, 530250, 180110), + ] + ), + } + assert write_district_geojson(postcodes, tmp_path) == 1 + collection = json.loads((tmp_path / "units" / "AA1.geojson").read_text()) + for feature in collection["features"]: + geom = shape(feature["geometry"]) + assert geom.is_valid + assert not geom.is_empty + + +class TestGreenspaceHolePreserved: + """Interior holes carved by greenspace subtraction must survive merge_fragments + (the post-subtraction _fill_holes that previously negated them was removed).""" + + def test_interior_lake_hole_survives_merge_fragments(self): + from shapely.strtree import STRtree + + postcode = box(0, 0, 100, 100) # 10000 sqm + lake = box(30, 30, 70, 70) # 1600 sqm fully-interior hole (16% removal) + result = merge_fragments( + [("TEST1", postcode)], + greenspace_tree=STRtree([lake]), + greenspace_geoms=[lake], + ) + merged = result["TEST1"] + assert len(list(merged.interiors)) == 1 + assert merged.area == pytest.approx(10000 - 1600, rel=0.05) diff --git a/pipeline/transform/price_estimation/backtest.py b/pipeline/transform/price_estimation/backtest.py index 0687387..4860bb8 100644 --- a/pipeline/transform/price_estimation/backtest.py +++ b/pipeline/transform/price_estimation/backtest.py @@ -67,6 +67,16 @@ def extract_test_set(input_path: Path) -> pl.DataFrame: .struct.field("price") .alias("input_price"), ) + .with_columns( + # Date of the input (second-to-last) sale, used by the kNN leakage + # filter to exclude the target property's own prior sale from its + # comparables. Built from year+month (day defaults to the 1st). + pl.date( + pl.col("input_year").cast(pl.Int32), + pl.col("input_month").cast(pl.Int32), + 1, + ).alias("input_date"), + ) .with_columns( ( pl.col("actual_year").cast(pl.Float64) diff --git a/pipeline/transform/price_estimation/estimate.py b/pipeline/transform/price_estimation/estimate.py index a66f1d9..fb0af8e 100644 --- a/pipeline/transform/price_estimation/estimate.py +++ b/pipeline/transform/price_estimation/estimate.py @@ -18,6 +18,8 @@ import polars as pl from pipeline.transform.price_estimation.knn import ( KNN_BLEND_WEIGHT, + MAX_COMPARABLE_PSM, + MIN_COMPARABLE_PSM, build_knn_pool, knn_median_psm, ) @@ -31,7 +33,13 @@ from pipeline.transform.price_estimation.utils import ( MAX_KNN_TO_INDEX_RATIO = 2.0 MIN_KNN_TO_INDEX_RATIO = 0.5 -MAX_ESTIMATE_TO_LAST_PRICE_RATIO = 6.0 +# Cap the final estimate at this multiple of the last known price as a guard +# against data errors. Set to ~exp(MAX_LOG_ADJUSTMENT) (~20x) so it is +# consistent with the log-index clip already applied to the index move: many +# UK sectors legitimately grew >6x since the 1990s (e.g. parts of inner London +# 12-14x), so the previous 6x cap truncated genuine appreciation rather than +# only catching outliers. +MAX_ESTIMATE_TO_LAST_PRICE_RATIO = 20.0 def guarded_blend_estimates( @@ -222,11 +230,22 @@ def main(): ).height print(f" kNN blended: {n_blended:,} of {n_estimated:,} estimates") - # Derive estimated price per sqm where both estimated price and floor area exist + # Derive estimated price per sqm where both estimated price and floor area + # exist. Null out values outside the plausibility band [MIN_COMPARABLE_PSM, + # MAX_COMPARABLE_PSM] (the same band the kNN pool uses): extreme values come + # from bulk/block transactions or floor-area errors and are not meaningful + # per-unit prices. + _est_psm = pl.col("Estimated current price") / pl.col("Total floor area (sqm)") df = df.with_columns( - (pl.col("Estimated current price") / pl.col("Total floor area (sqm)")) - .round(0) - .cast(pl.Int32, strict=False) + pl.when( + pl.col("Estimated current price").is_not_null() + & pl.col("Total floor area (sqm)").is_not_null() + & (pl.col("Total floor area (sqm)") > 0) + & (_est_psm >= MIN_COMPARABLE_PSM) + & (_est_psm <= MAX_COMPARABLE_PSM) + ) + .then(_est_psm.round(0).cast(pl.Int32, strict=False)) + .otherwise(None) .alias("Est. price per sqm"), ) diff --git a/pipeline/transform/price_estimation/index.py b/pipeline/transform/price_estimation/index.py index a07bc0b..0f4665f 100644 --- a/pipeline/transform/price_estimation/index.py +++ b/pipeline/transform/price_estimation/index.py @@ -24,6 +24,7 @@ from pipeline.transform.price_estimation.shrinkage import ( ) from pipeline.transform.price_estimation.utils import ( CURRENT_YEAR, + TEMPORAL_SMOOTHNESS_LAMBDA, TYPE_GROUPS, build_hedonic_features, extract_centroids, @@ -165,12 +166,50 @@ def solve_robust_index( cols_arr = np.concatenate([col2[mask2], col1[mask1]]) signs_arr = np.concatenate([np.ones(mask2.sum()), -np.ones(mask1.sum())]) + # Temporal smoothness prior: penalise curvature in the year betas with a + # second-difference penalty lambda * (beta_t - 2*beta_{t-1} + beta_{t-2})^2, + # encoded as extra least-squares rows (sqrt(lambda) * [1, -2, 1] against a + # zero target). This damps single-year index spikes without flattening + # genuine multi-year trends. Betas are ordered by calendar year; the baseline + # year (min_year, implicit beta=0) has no column, so the penalty spans the + # non-baseline years only. For cells with <3 betas there is no curvature to + # penalise and the solve is unchanged. + n_pen = 0 + pen_rows_arr = pen_cols_arr = np.empty(0, dtype=np.int64) + pen_vals_arr = pen_b = np.empty(0, dtype=np.float64) + if TEMPORAL_SMOOTHNESS_LAMBDA > 0 and n_cols >= 3: + sqrt_lambda = float(np.sqrt(TEMPORAL_SMOOTHNESS_LAMBDA)) + cols_by_year = [c for _, c in sorted(year_to_col.items())] + n_pen = n_cols - 2 + pen_rows = np.repeat(n + np.arange(n_pen), 3) + pen_cols = np.empty(n_pen * 3, dtype=np.int64) + for k in range(n_pen): + pen_cols[3 * k : 3 * k + 3] = ( + cols_by_year[k], + cols_by_year[k + 1], + cols_by_year[k + 2], + ) + pen_rows_arr = pen_rows.astype(np.int64) + pen_cols_arr = pen_cols + pen_vals_arr = np.tile( + [sqrt_lambda, -2.0 * sqrt_lambda, sqrt_lambda], n_pen + ).astype(np.float64) + pen_b = np.zeros(n_pen, dtype=np.float64) + n_total_rows = n + n_pen + weights = base_weights.copy() for _ in range(IRLS_ITERATIONS): data = signs_arr * weights[rows_arr] - A = csc_matrix((data, (rows_arr, cols_arr)), shape=(n, n_cols)) - b = log_ratios * weights + if n_pen: + all_data = np.concatenate([data, pen_vals_arr]) + all_rows = np.concatenate([rows_arr, pen_rows_arr]) + all_cols = np.concatenate([cols_arr, pen_cols_arr]) + b = np.concatenate([log_ratios * weights, pen_b]) + else: + all_data, all_rows, all_cols = data, rows_arr, cols_arr + b = log_ratios * weights + A = csc_matrix((all_data, (all_rows, all_cols)), shape=(n_total_rows, n_cols)) betas = lsqr(A, b, atol=1e-10, btol=1e-10)[0] # Residuals diff --git a/pipeline/transform/price_estimation/shrinkage.py b/pipeline/transform/price_estimation/shrinkage.py index bfd977f..7f3410d 100644 --- a/pipeline/transform/price_estimation/shrinkage.py +++ b/pipeline/transform/price_estimation/shrinkage.py @@ -96,8 +96,11 @@ def spatial_smooth( for i, sec in enumerate(sectors_with_coords): n = counts.get(sec, 0) self_w = n / (n + SPATIAL_BLEND_K) - if self_w > 0.95: - continue # enough data, skip smoothing + if self_w > 0.90: + # Enough data, skip smoothing. Relaxed from 0.95 so higher-volume + # cells (n ~270-570) that still carry single-year noise get a light + # spatial blend, complementing the temporal smoothness prior. + continue dists, idxs = tree.query(scaled_coords[i], k=SPATIAL_NEIGHBORS + 1) # Skip self (index 0, distance ~0) diff --git a/pipeline/transform/price_estimation/test_knn.py b/pipeline/transform/price_estimation/test_knn.py index fc4ad80..c5309aa 100644 --- a/pipeline/transform/price_estimation/test_knn.py +++ b/pipeline/transform/price_estimation/test_knn.py @@ -81,8 +81,21 @@ def test_guarded_blend_routes_unstable_knn_to_index_and_caps_uplift(): last_prices=np.array([100_000.0, 100_000.0]), ) + # Property 0: unstable kNN (>2x index) is dropped, index estimate kept. assert blended[0] == 120_000.0 - assert blended[1] == 600_000.0 + # Property 1: a 10x uplift over the last price is legitimate appreciation and + # is no longer truncated (cap raised from 6x to 20x). + assert blended[1] == 1_000_000.0 + + +def test_guarded_blend_caps_uplift_at_20x_last_price(): + # 50x index estimate over the last price is capped at the 20x ceiling. + blended = guarded_blend_estimates( + index_est=np.array([5_000_000.0]), + knn_est=np.array([np.nan]), + last_prices=np.array([100_000.0]), + ) + assert blended[0] == 2_000_000.0 # 100_000 * 20 def test_bungalow_is_not_a_dead_price_index_type_group(): @@ -92,3 +105,50 @@ def test_bungalow_is_not_a_dead_price_index_type_group(): assert "Bungalow" not in TYPE_GROUPS assert df["type_group"].to_list() == [None, None] + + +def test_temporal_regularization_damps_curvature_without_breaking_solve(): + """The second-difference prior reduces year-to-year curvature and keeps the + index well-formed (all years present, finite, contiguous).""" + from pipeline.transform.price_estimation import index as index_mod + + years = np.arange(2010, 2021) + true = {y: 0.04 * (y - 2010) for y in years} + y1, y2, lr, w = [], [], [], [] + for y in years[:-1]: # adjacent-year pairs following a smooth trend + y1.append(y) + y2.append(y + 1) + lr.append(true[y + 1] - true[y]) + w.append(1.0) + # A spurious single-year jump at 2015 (poorly identified curvature spike). + y1.append(2014) + y2.append(2015) + lr.append(0.5) + w.append(1.0) + y1, y2 = np.array(y1), np.array(y2) + lr, w = np.array(lr, float), np.array(w, float) + + def solve(lmbda): + original = index_mod.TEMPORAL_SMOOTHNESS_LAMBDA + index_mod.TEMPORAL_SMOOTHNESS_LAMBDA = lmbda + try: + return index_mod.solve_robust_index(y1, y2, lr, w) + finally: + index_mod.TEMPORAL_SMOOTHNESS_LAMBDA = original + + unregularised = solve(0.0) + regularised = solve(0.2) + + # Index is well-formed for both. + assert set(regularised) == set(range(2010, 2021)) + assert all(np.isfinite(v) for v in regularised.values()) + assert regularised[2010] == 0.0 # baseline year pinned to 0 + + def max_curvature(d): + betas = np.array([d[y] for y in sorted(d)]) + return float(np.abs(np.diff(betas, 2)).max()) + + # Regularisation strictly reduces curvature, and never flattens the genuine + # uptrend (the index still rises end to end). + assert max_curvature(regularised) < max_curvature(unregularised) + assert regularised[2020] > regularised[2010] diff --git a/pipeline/transform/price_estimation/utils.py b/pipeline/transform/price_estimation/utils.py index fff4bd0..bdb80d3 100644 --- a/pipeline/transform/price_estimation/utils.py +++ b/pipeline/transform/price_estimation/utils.py @@ -22,6 +22,13 @@ FLAT_TYPES = ["Flats/Maisonettes"] TYPE_GROUPS = ["Detached", "Semi-Detached", "Terraced", "Flats"] SHRINKAGE_K = 50 +# Temporal regularization for the repeat-sales index: a second-difference +# (curvature) penalty lambda * sum((beta_t - 2*beta_{t-1} + beta_{t-2})^2) added +# to the IRLS solve. A mild penalty damps single-year index spikes (which would +# otherwise distort the estimate of any property whose last sale landed on a +# noisy year) without flattening genuine multi-year trends. +TEMPORAL_SMOOTHNESS_LAMBDA = 0.05 + def type_group_expr(): """Polars expression: Property type -> type_group.""" diff --git a/pipeline/transform/school_proximity.py b/pipeline/transform/school_proximity.py index e83c1f7..49e6edf 100644 --- a/pipeline/transform/school_proximity.py +++ b/pipeline/transform/school_proximity.py @@ -15,6 +15,66 @@ SCHOOL_GROUPS = { } +def classify_good_plus_schools(ofsted: pl.DataFrame) -> pl.DataFrame: + """Label good+/outstanding primary & secondary schools for proximity counts. + + Derives a grade ("1" = outstanding, "2" = good) and a proximity ``category``, + returning a ``(postcode, category)`` frame. + + Schools with a recent GRADED inspection carry a 1-4 grade in "Latest OEIF + overall effectiveness" (OEIF = the previous Ofsted Education Inspection + Framework). A large and growing share of schools were last inspected under an + UNGRADED (Section 8) inspection or the post-2024 report-card framework, so + that column is null/"Not judged" for them even when they are demonstrably + good — their status lives in "Ungraded inspection overall outcome" ("School + remains Good"/"School remains Outstanding", incl. "(Concerns)"/"(Improving)" + variants). Filtering on the graded column alone dropped ~7,000 genuinely + good/outstanding schools. We fall back to the ungraded outcome, but ONLY when + there is no usable graded result (null/"Not judged"), so a genuine grade 3/4 + is never overridden. + """ + # Cast to Utf8 so the string predicates below are well-defined even if a + # column happens to be entirely null (read back as a Null dtype). + oeif = pl.col("Latest OEIF overall effectiveness").cast(pl.Utf8, strict=False) + ungraded = pl.col("Ungraded inspection overall outcome").cast(pl.Utf8, strict=False) + no_usable_grade = oeif.is_null() | (oeif == "Not judged") + graded = ( + ofsted.filter(pl.col("Ofsted phase").is_in(["Primary", "Secondary"])) + .with_columns( + pl.when(oeif.is_in(["1", "2"])) + .then(oeif) + .when( + no_usable_grade + & ungraded.str.starts_with("School remains Outstanding") + ) + .then(pl.lit("1")) + .when(no_usable_grade & ungraded.str.starts_with("School remains Good")) + .then(pl.lit("2")) + .otherwise(None) + .alias("_ofsted_grade") + ) + .filter(pl.col("_ofsted_grade").is_not_null()) + ) + # Good+ groups include both grade variants; outstanding groups count grade 1. + return graded.with_columns( + pl.when(pl.col("Ofsted phase") == "Primary") + .then( + pl.when(pl.col("_ofsted_grade") == "1") + .then(pl.lit("outstanding_primary")) + .otherwise(pl.lit("good_primary")) + ) + .otherwise( + pl.when(pl.col("_ofsted_grade") == "1") + .then(pl.lit("outstanding_secondary")) + .otherwise(pl.lit("good_secondary")) + ) + .alias("category") + ).select( + pl.col("Postcode").alias("postcode"), + "category", + ) + + def main(): parser = argparse.ArgumentParser( description="Count good+ and outstanding primary/secondary schools near each postcode" @@ -30,42 +90,14 @@ def main(): ) args = parser.parse_args() - # Load Ofsted data: filter to good+ (1, 2) primary/secondary schools. - # Post-2025 reform the single "Overall effectiveness" grade was retired; - # the legacy 1–4 scale is now carried forward under "Latest OEIF overall - # effectiveness" (OEIF = the previous Ofsted Education Inspection - # Framework). The new report-card columns use text judgements instead. - ofsted = pl.read_parquet(args.ofsted).filter( - pl.col("Ofsted phase").is_in(["Primary", "Secondary"]) - & pl.col("Latest OEIF overall effectiveness").is_in(["1", "2"]) - ) + ofsted = classify_good_plus_schools(pl.read_parquet(args.ofsted)) if ofsted.is_empty(): raise ValueError("No good+ primary/secondary Ofsted schools found") print(f"Good+ schools: {len(ofsted):,}") print( "Outstanding schools: " - f"{ofsted.filter(pl.col('Latest OEIF overall effectiveness') == '1').height:,}" - ) - - # Assign category based on phase and rating. Good+ groups include both - # category variants; outstanding groups count grade 1 only. - ofsted = ofsted.with_columns( - pl.when(pl.col("Ofsted phase") == "Primary") - .then( - pl.when(pl.col("Latest OEIF overall effectiveness") == "1") - .then(pl.lit("outstanding_primary")) - .otherwise(pl.lit("good_primary")) - ) - .otherwise( - pl.when(pl.col("Latest OEIF overall effectiveness") == "1") - .then(pl.lit("outstanding_secondary")) - .otherwise(pl.lit("good_secondary")) - ) - .alias("category") - ).select( - pl.col("Postcode").alias("postcode"), - "category", + f"{ofsted.filter(pl.col('category').str.starts_with('outstanding')).height:,}" ) # Join with arcgis to get lat/lng for each school's postcode diff --git a/pipeline/transform/test_crime.py b/pipeline/transform/test_crime.py index 438f2ce..17acde7 100644 --- a/pipeline/transform/test_crime.py +++ b/pipeline/transform/test_crime.py @@ -226,3 +226,44 @@ def test_transform_crime_applies_lsoa_2011_to_2021_lookup(tmp_path): assert burglaries["E01000050"] == [{"year": 2024, "count": 12.0}] assert burglaries["E01000051"] == [{"year": 2024, "count": 12.0}] assert burglaries["E01000099"] == [{"year": 2024, "count": 12.0}] + + +def test_transform_crime_maps_legacy_crime_types(tmp_path): + """Pre-2014 police.uk type names are aliased to current equivalents instead + of being dropped.""" + crime_dir = tmp_path / "crime" + month_dir = crime_dir / "2013-01" + month_dir.mkdir(parents=True) + + header = "Crime ID,Month,Reported by,Falls within,Longitude,Latitude,Location,LSOA code,LSOA name,Crime type,Last outcome category,Context" + (month_dir / "2013-01-test-force-street.csv").write_text( + "\n".join( + [ + header, + "1,2013-01,Test Force,Test Force,-0.1,51.5,On or near X,E01000001,L,Violent crime,Under investigation,", + "2,2013-01,Test Force,Test Force,-0.1,51.5,On or near X,E01000001,L,Public disorder and weapons,Under investigation,", + "3,2013-01,Test Force,Test Force,-0.1,51.5,On or near X,E01000001,L,Burglary,Under investigation,", + ] + ) + + "\n" + ) + + output = tmp_path / "crime.parquet" + by_year_output = tmp_path / "crime_by_year.parquet" + transform_crime(crime_dir, output, by_year_output) + + row = pl.read_parquet(output).to_dicts()[0] + # Single month -> annualised x12. Legacy names mapped to current columns. + assert row["Violence and sexual offences (avg/yr)"] == 12.0 + assert row["Public order (avg/yr)"] == 12.0 + assert row["Burglary (avg/yr)"] == 12.0 + # The legacy names must NOT survive as their own columns. + assert "Violent crime (avg/yr)" not in row + assert "Public disorder and weapons (avg/yr)" not in row + + by_year = pl.read_parquet(by_year_output).row(0, named=True) + serious = {p["year"]: p["count"] for p in by_year["Serious crime (by year)"]} + # Serious = Violence and sexual offences (12) + Burglary (12) = 24 + assert serious[2013] == 24.0 + minor = {p["year"]: p["count"] for p in by_year["Minor crime (by year)"]} + assert minor[2013] == 12.0 # Public order diff --git a/pipeline/transform/test_crime_spatial.py b/pipeline/transform/test_crime_spatial.py index 7e6f372..4ce8204 100644 --- a/pipeline/transform/test_crime_spatial.py +++ b/pipeline/transform/test_crime_spatial.py @@ -279,3 +279,37 @@ def test_unknown_crime_type_is_dropped_with_warning(tmp_path, capsys): err = capsys.readouterr().err assert "Cyber fraud" in err assert "WARNING" in err + + +def test_legacy_crime_types_are_mapped(tmp_path): + """Pre-2014 crime-type names are aliased to current equivalents in the + spatial transform instead of being dropped as unknown types.""" + units = tmp_path / "units" + _write_boundaries( + units, {"AB1": [_square_feature("AB1 1AA", 1000, 1000, 1010, 1010)]} + ) + + crime = tmp_path / "crime" + _write_month( + crime, + "2013-01", + [ + _crime_row("2013-01", 1005, 1005, "Violent crime"), + _crime_row("2013-01", 1005, 1005, "Public disorder and weapons"), + ], + ) + + output = tmp_path / "crime_by_postcode.parquet" + by_year = tmp_path / "crime_by_postcode_by_year.parquet" + transform_crime_spatial(crime, units, output, by_year, buffer_m=50.0) + + row = pl.read_parquet(output).to_dicts()[0] + # Single postcode -> area-norm factor 1.0; single month/year -> x12. + assert row["Violence and sexual offences (avg/yr)"] == 12.0 + assert row["Public order (avg/yr)"] == 12.0 + + by_year_row = pl.read_parquet(by_year).row(0, named=True) + assert by_year_row["Violence and sexual offences (by year)"] == [ + {"year": 2013, "count": 12.0} + ] + assert by_year_row["Public order (by year)"] == [{"year": 2013, "count": 12.0}] diff --git a/pipeline/transform/test_join_epc_pp.py b/pipeline/transform/test_join_epc_pp.py index 67c0752..7484ba0 100644 --- a/pipeline/transform/test_join_epc_pp.py +++ b/pipeline/transform/test_join_epc_pp.py @@ -169,7 +169,8 @@ def test_run_joins_domestic_zip_with_price_paid(tmp_path: Path): "epc_address": "1 Example Street", "current_energy_rating": "C", "total_floor_area": 85.0, - "construction_age_band": 1950, + # Band midpoint of 1950-1966, not the lower bound. + "construction_age_band": 1958, "was_council_house": "Yes", } ] @@ -256,3 +257,26 @@ def test_run_does_not_attach_epc_facts_to_low_score_address_match(tmp_path: Path "current_energy_rating": None, } ] + + +def test_epc_band_to_year_uses_midpoint_and_clamps(): + import polars as pl + + from pipeline.transform.join_epc_pp import epc_band_to_year + + df = pl.DataFrame( + { + "b": [ + "England and Wales: 1950-1966", # midpoint 1958 + "1900-1929", # midpoint 1914 + "England and Wales: before 1900", # too wide -> null + "2012 onwards", # single year + "1012", # implausible -> null + "2202", # implausible -> null + None, # null -> null + "1958", # already-numeric-as-string -> pass through + ] + } + ) + years = df.select(epc_band_to_year(pl.col("b")).alias("y"))["y"].to_list() + assert years == [1958, 1914, None, 2012, None, None, None, 1958] diff --git a/pipeline/transform/test_school_proximity.py b/pipeline/transform/test_school_proximity.py new file mode 100644 index 0000000..9d94b8d --- /dev/null +++ b/pipeline/transform/test_school_proximity.py @@ -0,0 +1,82 @@ +import polars as pl + +from pipeline.transform.school_proximity import classify_good_plus_schools + + +def _school(phase, oeif, ungraded, postcode="AA1 1AA"): + return { + "Postcode": postcode, + "Ofsted phase": phase, + "Latest OEIF overall effectiveness": oeif, + "Ungraded inspection overall outcome": ungraded, + } + + +def _classify(rows): + result = classify_good_plus_schools(pl.DataFrame(rows)) + return {(r["postcode"], r["category"]) for r in result.to_dicts()} + + +def test_legacy_oeif_grades_1_and_2_are_kept(): + rows = [ + _school("Primary", "1", None, "AA1 1AA"), + _school("Primary", "2", None, "AA1 1AB"), + _school("Secondary", "1", None, "AA1 1AC"), + _school("Secondary", "2", None, "AA1 1AD"), + ] + assert _classify(rows) == { + ("AA1 1AA", "outstanding_primary"), + ("AA1 1AB", "good_primary"), + ("AA1 1AC", "outstanding_secondary"), + ("AA1 1AD", "good_secondary"), + } + + +def test_grades_3_and_4_are_excluded(): + rows = [_school("Primary", "3", None), _school("Primary", "4", None)] + assert _classify(rows) == set() + + +def test_ungraded_remains_good_is_recovered_when_no_graded_result(): + # Null and "Not judged" OEIF fall back to the ungraded outcome. + rows = [ + _school("Primary", None, "School remains Good", "AA1 1AA"), + _school("Secondary", "Not judged", "School remains Outstanding", "AA1 1AB"), + # "(Concerns)"/"(Improving)" variants are still good+. + _school("Primary", None, "School remains Good (Concerns) - S5 Next", "AA1 1AC"), + _school( + "Secondary", + None, + "School remains Outstanding (Concerns) - S5 Next", + "AA1 1AD", + ), + ] + assert _classify(rows) == { + ("AA1 1AA", "good_primary"), + ("AA1 1AB", "outstanding_secondary"), + ("AA1 1AC", "good_primary"), + ("AA1 1AD", "outstanding_secondary"), + } + + +def test_ungraded_non_good_outcomes_are_excluded(): + rows = [ + _school("Primary", None, "Some aspects not as strong"), + _school("Primary", None, "Standards maintained"), + _school("Primary", None, None), + ] + assert _classify(rows) == set() + + +def test_genuine_grade_3_is_not_overridden_by_stale_remains_good(): + # A real grade 3 must not be promoted by an ungraded "remains Good". + rows = [_school("Primary", "3", "School remains Good")] + assert _classify(rows) == set() + + +def test_non_primary_secondary_phases_excluded(): + rows = [ + _school("Nursery", "1", None), + _school("Not applicable", "2", None), + ] + assert _classify(rows) == set() diff --git a/pipeline/validate_outputs.py b/pipeline/validate_outputs.py index 1bcc30a..360b65b 100644 --- a/pipeline/validate_outputs.py +++ b/pipeline/validate_outputs.py @@ -352,6 +352,176 @@ def _failures_for_active_postcode_boundary_match(spec: str) -> list[str]: return failures +def _failures_for_postcode_features(path: Path) -> list[str]: + """Validate the postcode feature output: unique Postcode, non-null lat/lon + inside the England bbox, ctry25cd == E92000001, and every '% ' column in + [0, 100]. Mirrors the in-build invariant (merge._validate_postcode_feature_output) + so a stale/contaminated file on disk cannot pass `make`. + """ + failures = _failures_for_parquet(path) + if failures: + return failures + + try: + names = pl.scan_parquet(path).collect_schema().names() + required = {"Postcode", "lat", "lon", "ctry25cd"} + missing = sorted(required - set(names)) + if missing: + return [f"{path}: postcode features missing required columns: {missing}"] + + pct_cols = [c for c in names if c.startswith("% ")] + df = ( + pl.scan_parquet(path) + .select(["Postcode", "lat", "lon", "ctry25cd", *pct_cols]) + .collect() + ) + except Exception as exc: + return [f"{path}: postcode features validation failed: {exc}"] + + height = df.height + if df["Postcode"].n_unique() != height: + failures.append( + f"{path}: Postcode is not unique " + f"({height - df['Postcode'].n_unique():,} duplicate rows)" + ) + + # England bounding box (generous): lat 49.5-60N, lon -8 to 2.5E. + bad_coords = df.filter( + pl.col("lat").is_null() + | pl.col("lon").is_null() + | ~pl.col("lat").is_between(49.5, 60.0) + | ~pl.col("lon").is_between(-8.0, 2.5) + ) + if bad_coords.height: + sample = bad_coords.get_column("Postcode").head(10).to_list() + failures.append( + f"{path}: {bad_coords.height:,} rows have null or out-of-England " + f"lat/lon; sample: {_format_samples(sample)}" + ) + + bad_country = df.filter(pl.col("ctry25cd") != "E92000001") + if bad_country.height: + sample = bad_country.get_column("Postcode").head(10).to_list() + failures.append( + f"{path}: {bad_country.height:,} rows have ctry25cd != 'E92000001' " + f"(non-England contamination); sample: {_format_samples(sample)}" + ) + + for col in pct_cols: + out_of_range = df.filter( + pl.col(col).is_not_null() & ~pl.col(col).is_between(0.0, 100.0) + ).height + if out_of_range: + failures.append( + f"{path}: {col!r} has {out_of_range:,} values outside [0, 100]" + ) + + return failures + + +def _failures_for_properties_subset(spec: str) -> list[str]: + """Validate that every properties Postcode exists in the postcode feature + table (no orphan properties) and that numeric price columns are positive.""" + properties_path, postcode_path = _split_pair(spec, "properties subset") + failures = _failures_for_parquet(properties_path) + _failures_for_parquet( + postcode_path + ) + if failures: + return failures + + try: + postcode_set = _parquet_postcodes(postcode_path) + property_set = _parquet_postcodes(properties_path) + except Exception as exc: + return [f"{properties_path} / {postcode_path}: subset check failed: {exc}"] + + orphans = property_set - postcode_set + if orphans: + failures.append( + f"{properties_path}: {len(orphans):,} property postcodes are absent from " + f"{postcode_path}; sample: {_sample(orphans)}" + ) + + # Positivity check for genuine numeric price columns only (skip nested/list + # columns like historical_prices, which contain "price" in the name). + try: + schema = pl.scan_parquet(properties_path).collect_schema() + numeric = { + pl.Int8, pl.Int16, pl.Int32, pl.Int64, + pl.UInt8, pl.UInt16, pl.UInt32, pl.UInt64, + pl.Float32, pl.Float64, + } + price_cols = [ + c + for c, dtype in schema.items() + if ("price" in c.lower() or "rent" in c.lower()) and dtype in numeric + ] + for col in price_cols: + bad = ( + pl.scan_parquet(properties_path) + .filter(pl.col(col).is_not_null() & (pl.col(col) <= 0)) + .select(pl.len()) + .collect() + .item() + ) + if bad: + failures.append( + f"{properties_path}: {col!r} has {bad:,} non-positive values" + ) + except Exception as exc: + failures.append(f"{properties_path}: price positivity check failed: {exc}") + + return failures + + +def _failures_for_price_index(path: Path) -> list[str]: + """Validate price_index.parquet structural integrity: required columns, a + finite non-null log_index, and unique (sector, type_group, year) keys. + + n_pairs == 0 is intentionally NOT treated as a failure: those rows are + legitimate hedonic/shrinkage fallbacks for sectors with too few repeat-sale + pairs. + """ + failures = _failures_for_parquet(path) + if failures: + return failures + + try: + names = pl.scan_parquet(path).collect_schema().names() + required = {"sector", "type_group", "year", "log_index", "n_pairs"} + missing = sorted(required - set(names)) + if missing: + return [f"{path}: price index missing required columns: {missing}"] + + stats = ( + pl.scan_parquet(path) + .select( + pl.len().alias("n"), + pl.col("log_index").null_count().alias("null_log"), + (~pl.col("log_index").is_finite()).sum().alias("nonfinite_log"), + pl.struct("sector", "type_group", "year").n_unique().alias("unique_keys"), + ) + .collect() + .row(0, named=True) + ) + except Exception as exc: + return [f"{path}: price index validation failed: {exc}"] + + if stats["null_log"]: + failures.append(f"{path}: {stats['null_log']:,} rows have null log_index") + if stats["nonfinite_log"]: + failures.append( + f"{path}: {stats['nonfinite_log']:,} rows have non-finite log_index" + ) + if stats["unique_keys"] != stats["n"]: + failures.append( + f"{path}: (sector, type_group, year) is not unique " + f"({stats['n'] - stats['unique_keys']:,} duplicate rows)" + ) + + return failures + + def main() -> int: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--file", action="append", default=[], type=Path) @@ -385,6 +555,29 @@ def main() -> int: "GeoJSON postcodes: ARCGIS_PARQUET::DIR" ), ) + parser.add_argument( + "--postcode-features", + action="append", + default=[], + type=Path, + help=( + "Validate a postcode feature parquet: unique Postcode, non-null " + "lat/lon in England, ctry25cd=E92000001, '% ' columns in [0,100]" + ), + ) + parser.add_argument( + "--properties-subset", + action="append", + default=[], + help="Require properties postcodes to be a subset of postcode keys: PROPERTIES::POSTCODE", + ) + parser.add_argument( + "--price-index", + action="append", + default=[], + type=Path, + help="Validate price_index.parquet: finite log_index and unique (sector,type_group,year)", + ) args = parser.parse_args() failures: list[str] = [] @@ -404,6 +597,12 @@ def main() -> int: failures.extend(_failures_for_postcode_boundary_match(spec)) for spec in args.active_postcode_boundary_match: failures.extend(_failures_for_active_postcode_boundary_match(spec)) + for path in args.postcode_features: + failures.extend(_failures_for_postcode_features(path)) + for spec in args.properties_subset: + failures.extend(_failures_for_properties_subset(spec)) + for path in args.price_index: + failures.extend(_failures_for_price_index(path)) if failures: print("Output validation failed:", file=sys.stderr) diff --git a/server-rs/src/features.rs b/server-rs/src/features.rs index 25bd6cb..74b74f9 100644 --- a/server-rs/src/features.rs +++ b/server-rs/src/features.rs @@ -202,7 +202,7 @@ pub static FEATURE_GROUPS: &[FeatureGroup] = &[ }, step: 1.0, description: "Maximum transport noise level near the postcode in decibels (Lden)", - detail: "Maximum road, rail, or airport noise level in decibels (Lden, a 24-hour weighted average) from Defra's Strategic Noise Mapping Round 4 (2022). Modelled at 4m above ground on a 10m grid and sampled as the maximum 10m cell around the postcode representative point. Above ~55 dB is typically noticeable; above ~70 dB is considered harmful by the WHO.", + detail: "Loudest of road, rail, or airport noise in decibels (Lden, a 24-hour day-evening-night weighted average) from Defra's Strategic Noise Mapping Round 4 (2022). Covers England only; rail noise dominates the value at ~120k postcodes and airport noise at ~4k. Modelled at 4m above ground on a 10m grid and sampled as the maximum 10m cell around the postcode representative point. Blank means no mapped data in the source (Wales, Scotland and areas away from major roads/railways/airports all return blank) — not necessarily quiet. Above ~55 dB is typically noticeable; above ~70 dB is considered harmful by the WHO.", source: "noise", prefix: "", suffix: " dB", @@ -832,14 +832,14 @@ pub static FEATURE_GROUPS: &[FeatureGroup] = &[ absolute: false, }), Feature::Numeric(FeatureConfig { - name: "% East Asian", + name: "% East/SE Asian", bounds: Bounds::Fixed { min: 0.0, max: 100.0, }, step: 0.1, - description: "Percentage of population identifying as East Asian", - detail: "From the 2021 Census. Percentage of the local authority population identifying as Chinese.", + description: "Percentage of population identifying as East or Southeast Asian", + detail: "From the 2021 Census. Percentage of the local authority population identifying as Chinese, Vietnamese, Filipino, Thai, or any other East or Southeast Asian background.", source: "ethnicity", prefix: "", suffix: "%", @@ -987,12 +987,20 @@ pub static FEATURE_GROUPS: &[FeatureGroup] = &[ FeatureGroup { name: "Amenities", features: &[ - Feature::Enum(EnumFeatureConfig { + Feature::Numeric(FeatureConfig { name: "Max available download speed (Mbps)", - order: Some(&["10", "30", "100", "300", "1000"]), + bounds: Bounds::Fixed { + min: 10.0, + max: 1000.0, + }, + step: 1.0, description: "Maximum broadband download speed available at the postcode", - detail: "Maximum fixed broadband download speed available from any provider, from Ofcom Connected Nations 2025. Represents theoretical maximum, not achieved speeds. 10 Mbps = basic, 30 = superfast, 100+ = ultrafast, 1000 = gigabit.", + detail: "Maximum fixed broadband download speed available from any provider, from Ofcom Connected Nations 2025. Represents theoretical maximum, not achieved speeds. 10 Mbps = basic, 30 = superfast, 100+ = ultrafast, 1000 = gigabit. Null where no availability data is published.", source: "broadband", + prefix: "", + suffix: " Mbps", + raw: true, + absolute: true, }), ], }, diff --git a/video/src/storyboard.ts b/video/src/storyboard.ts index 6b5051c..1f45a4a 100644 --- a/video/src/storyboard.ts +++ b/video/src/storyboard.ts @@ -549,7 +549,7 @@ function createRecordingStoryboard( 'Good+ primary schools within 2km': [1, 10], 'Noise (dB)': [50, 70], 'Street tree density percentile': [25, 100], - 'Max available download speed (Mbps)': ['100', '300', '1000'], + 'Max available download speed (Mbps)': [100, 1000], }, // Travel-time filters returned by the AI stub. Slug matches the real // /api/travel-destinations?mode=transit response. From a04ac2d857fe0df879e7023667129f9a709247e5 Mon Sep 17 00:00:00 2001 From: Andras Schmelczer <andras@schmelczer.dev> Date: Tue, 2 Jun 2026 08:21:47 +0100 Subject: [PATCH 4/9] . --- Makefile.data | 4 +- .../components/map/LocationSearch.test.tsx | 81 ++++++++++++++++++- frontend/src/components/map/Map.tsx | 5 ++ frontend/src/components/map/MobileDrawer.tsx | 5 +- .../map/map-page/useExportController.ts | 4 +- frontend/src/components/ui/ExportMenu.tsx | 12 +-- frontend/src/components/ui/FeatureLabel.tsx | 4 +- frontend/src/hooks/useHexagonSelection.ts | 7 +- frontend/src/i18n/locales/de.ts | 24 ++---- frontend/src/i18n/locales/fr.ts | 9 +-- frontend/src/i18n/locales/hi.ts | 24 +++--- frontend/src/i18n/locales/hu.ts | 3 +- frontend/src/i18n/locales/zh.ts | 6 +- pipeline/download/satellite_highres.py | 2 - .../transform/postcode_boundaries/README.md | 4 +- server-rs/src/routes/export.rs | 12 +-- 16 files changed, 132 insertions(+), 74 deletions(-) diff --git a/Makefile.data b/Makefile.data index 5319cea..ecc065e 100644 --- a/Makefile.data +++ b/Makefile.data @@ -327,8 +327,8 @@ $(GREENSPACE): $(PBF) $(OS_GREENSPACE): uv run python -m pipeline.download.os_greenspace --output $@ -$(PLACES): $(PBF) $(ENGLAND_BOUNDARY) $(NAPTAN) $(OFS_REGISTER) $(ARCGIS) - uv run python -m pipeline.download.places --output $@ --pbf $(PBF) --boundary $(ENGLAND_BOUNDARY) --naptan $(NAPTAN) --university-register $(OFS_REGISTER) --postcodes $(ARCGIS) +$(PLACES): $(PBF) $(ENGLAND_BOUNDARY) $(NAPTAN) $(OFS_REGISTER) $(ARCGIS) $(POIS_RAW) + uv run python -m pipeline.download.places --output $@ --pbf $(PBF) --boundary $(ENGLAND_BOUNDARY) --naptan $(NAPTAN) --university-register $(OFS_REGISTER) --postcodes $(ARCGIS) --pois $(POIS_RAW) --include-streets $(MEDIAN_AGE): diff --git a/frontend/src/components/map/LocationSearch.test.tsx b/frontend/src/components/map/LocationSearch.test.tsx index 0c45f17..7b5774a 100644 --- a/frontend/src/components/map/LocationSearch.test.tsx +++ b/frontend/src/components/map/LocationSearch.test.tsx @@ -291,7 +291,69 @@ describe('LocationSearch', () => { }); }); - it('shows an empty state for invalid place queries', async () => { + it('preserves the server unified ordering and sends the viewport centre', async () => { + const fetchMock = vi.fn((input: string | URL | Request) => { + const url = new URL(String(input), 'http://localhost'); + if (url.pathname === '/api/places') { + return Promise.resolve( + jsonResponse({ + places: [], + postcodes: [], + addresses: [], + // Intentionally out of "bucket" order: an address outranks a place. The hook must + // render them in this server order rather than re-bucketing or re-filtering. + results: [ + { + type: 'address', + address: '1 High Street', + postcode: 'CR0 1AA', + lat: 51.37, + lon: -0.1, + score: 930, + }, + { + type: 'place', + name: 'Croydon', + slug: 'croydon', + place_type: 'town', + lat: 51.37, + lon: -0.1, + score: 880, + }, + ], + }) + ); + } + return Promise.resolve(new Response(null, { status: 404 })); + }); + vi.stubGlobal('fetch', fetchMock); + + render( + <LocationSearch + onFlyTo={vi.fn()} + onLocationSearched={vi.fn()} + getViewportCenter={() => ({ lat: 51.5, lng: -0.12 })} + /> + ); + + fireEvent.change(screen.getByRole('textbox'), { target: { value: 'high street' } }); + + // The address (first in the server list) renders before the place, unfiltered. + const firstResult = await screen.findByText('1 High Street'); + const place = screen.getByText('Croydon'); + expect( + firstResult.compareDocumentPosition(place) & Node.DOCUMENT_POSITION_FOLLOWING + ).toBeTruthy(); + + const placesCall = fetchMock.mock.calls.find(([input]) => + String(input).includes('/api/places') + ); + const calledUrl = new URL(String(placesCall?.[0]), 'http://localhost'); + expect(calledUrl.searchParams.get('lat')).toBe('51.5'); + expect(calledUrl.searchParams.get('lng')).toBe('-0.12'); + }); + + it('shows an empty state for invalid place queries (legacy server, no results key)', async () => { vi.stubGlobal( 'fetch', vi.fn(() => @@ -314,6 +376,23 @@ describe('LocationSearch', () => { }); }); + it('shows the empty state when the new server returns an empty results array', async () => { + vi.stubGlobal( + 'fetch', + vi.fn(() => + Promise.resolve(jsonResponse({ places: [], postcodes: [], addresses: [], results: [] })) + ) + ); + + render(<LocationSearch onFlyTo={vi.fn()} onLocationSearched={vi.fn()} />); + + fireEvent.change(screen.getByRole('textbox'), { target: { value: 'zzzznowhere' } }); + + await waitFor(() => { + expect(screen.getByText('No matching places or postcodes')).toBeTruthy(); + }); + }); + it('keeps only the three most recent local searches', async () => { vi.stubGlobal( 'fetch', diff --git a/frontend/src/components/map/Map.tsx b/frontend/src/components/map/Map.tsx index f1b81dc..423cf1b 100644 --- a/frontend/src/components/map/Map.tsx +++ b/frontend/src/components/map/Map.tsx @@ -937,6 +937,10 @@ export default memo(function Map({ dimensions.width < DESKTOP_TOP_CARDS_ROW_MIN_MAP_WIDTH; const showLocationSearch = !hideLocationSearch && !hideDesktopTopCardsForWidth; const showLegend = !hideLegend && !hideDesktopTopCardsForWidth; + const getViewportCenter = useCallback(() => { + const center = mapRef.current?.getCenter(); + return center ? { lat: center.lat, lng: center.lng } : null; + }, []); const desktopTopCardsLayoutClass = stackDesktopTopCards ? 'flex-col items-start' : 'items-start justify-between'; @@ -1099,6 +1103,7 @@ export default memo(function Map({ onLocationSearched={onLocationSearched} onCurrentLocationFound={onCurrentLocationFound} onMouseEnter={handleMouseLeave} + getViewportCenter={getViewportCenter} className={DESKTOP_TOP_CARD_CLASS} inputClassName={DESKTOP_LOCATION_SEARCH_INPUT_CLASS} /> diff --git a/frontend/src/components/map/MobileDrawer.tsx b/frontend/src/components/map/MobileDrawer.tsx index 58a6718..39bdf6c 100644 --- a/frontend/src/components/map/MobileDrawer.tsx +++ b/frontend/src/components/map/MobileDrawer.tsx @@ -103,7 +103,10 @@ export default function MobileDrawer({ }, []); return ( - <div data-tutorial="right-pane" className="pointer-events-none fixed inset-0 z-50 flex flex-col"> + <div + data-tutorial="right-pane" + className="pointer-events-none fixed inset-0 z-50 flex flex-col" + > <div className="h-[10%] shrink-0" aria-hidden="true" /> {/* Panel — bottom 90% */} diff --git a/frontend/src/components/map/map-page/useExportController.ts b/frontend/src/components/map/map-page/useExportController.ts index bd2bc65..d372edf 100644 --- a/frontend/src/components/map/map-page/useExportController.ts +++ b/frontend/src/components/map/map-page/useExportController.ts @@ -192,9 +192,7 @@ export function useExportController({ const detail = err instanceof Error && err.message.trim() ? ` ${err.message}` : ''; showExportNotice({ kind: 'error', - message: timedOut - ? t('header.exportTimedOut') - : `${t('header.exportFailed')}${detail}`, + message: timedOut ? t('header.exportTimedOut') : `${t('header.exportFailed')}${detail}`, }); } finally { window.clearTimeout(timeoutId); diff --git a/frontend/src/components/ui/ExportMenu.tsx b/frontend/src/components/ui/ExportMenu.tsx index ae3ea39..2edd0cf 100644 --- a/frontend/src/components/ui/ExportMenu.tsx +++ b/frontend/src/components/ui/ExportMenu.tsx @@ -78,11 +78,7 @@ export default function ExportMenu({ open, exporting, onClose, onExport }: Expor } else { inputRefs.current[idx + 1]?.focus(); } - } else if ( - e.key === 'Backspace' && - postcodes[idx] === '' && - postcodes.length > 1 - ) { + } else if (e.key === 'Backspace' && postcodes[idx] === '' && postcodes.length > 1) { e.preventDefault(); focusIndexRef.current = Math.max(0, idx - 1); removeAt(idx); @@ -98,11 +94,7 @@ export default function ExportMenu({ open, exporting, onClose, onExport }: Expor return ( <> - <div - className="fixed inset-0 bg-black/50 z-[90]" - onClick={onClose} - aria-hidden="true" - /> + <div className="fixed inset-0 bg-black/50 z-[90]" onClick={onClose} aria-hidden="true" /> <div role="dialog" aria-modal="true" diff --git a/frontend/src/components/ui/FeatureLabel.tsx b/frontend/src/components/ui/FeatureLabel.tsx index cbdf916..3335537 100644 --- a/frontend/src/components/ui/FeatureLabel.tsx +++ b/frontend/src/components/ui/FeatureLabel.tsx @@ -68,9 +68,7 @@ export function FeatureLabel({ {GroupIcon && <GroupIcon className={iconClass} />} {translatedDesc ? ( <div className="min-w-0"> - <div className={`flex ${wrap ? 'items-start' : 'items-center'} gap-1`}> - {nameContent} - </div> + <div className={`flex ${wrap ? 'items-start' : 'items-center'} gap-1`}>{nameContent}</div> <span className="text-xs text-warm-400 dark:text-warm-500 block">{translatedDesc}</span> </div> ) : ( diff --git a/frontend/src/hooks/useHexagonSelection.ts b/frontend/src/hooks/useHexagonSelection.ts index 425158a..ae53464 100644 --- a/frontend/src/hooks/useHexagonSelection.ts +++ b/frontend/src/hooks/useHexagonSelection.ts @@ -144,12 +144,7 @@ export function useHexagonSelection({ ); const fetchPostcodeStats = useCallback( - async ( - postcode: string, - signal?: AbortSignal, - includeFilters = true, - fields?: string[] - ) => { + async (postcode: string, signal?: AbortSignal, includeFilters = true, fields?: string[]) => { const params = new URLSearchParams({ postcode }); const filterStr = includeFilters ? buildFilterString(filters, features) : ''; if (filterStr) params.append('filters', filterStr); diff --git a/frontend/src/i18n/locales/de.ts b/frontend/src/i18n/locales/de.ts index 7ba16ea..b4fdb4e 100644 --- a/frontend/src/i18n/locales/de.ts +++ b/frontend/src/i18n/locales/de.ts @@ -214,22 +214,19 @@ const de: Translations = { 'Relax one constraint at a time': 'Lockere eine Einschränkung nach der anderen', 'When the search becomes too narrow, loosen a single filter and watch which postcodes reappear. This makes compromise explicit instead of relying on guesswork.': 'Wenn die Suche zu eng wird, lockere einen einzelnen Filter und sieh, welche Postcodes wieder auftauchen. So werden Kompromisse sichtbar statt geraten.', - 'Turn vague areas into specific postcodes': - 'Verwandle vage Gebiete in konkrete Postcodes', + 'Turn vague areas into specific postcodes': 'Verwandle vage Gebiete in konkrete Postcodes', 'Broad town or borough searches hide large differences between streets. Perfect Postcode helps you move from a general area to postcodes that satisfy your hard requirements.': 'Breite Stadt- oder Borough-Suchen verdecken große Unterschiede zwischen Straßen. Perfect Postcode hilft dir, von einem allgemeinen Gebiet zu Postcodes zu gelangen, die deine Muss-Kriterien erfüllen.', 'Keep trade-offs visible': 'Halte Kompromisse sichtbar', 'When there are too many or too few matches, adjust one constraint at a time and see exactly which postcodes reappear. That makes compromises explicit instead of relying on guesswork.': 'Wenn es zu viele oder zu wenige Treffer gibt, ändere jeweils eine Anforderung und sieh genau, welche Postcodes wieder auftauchen. So werden Kompromisse sichtbar statt geraten.', - 'Why postcode-level comparison matters': - 'Warum Vergleiche auf Postcode-Ebene wichtig sind', + 'Why postcode-level comparison matters': 'Warum Vergleiche auf Postcode-Ebene wichtig sind', 'Two nearby postcodes can differ on schools, road noise, transport access, property mix, and price. Comparing at postcode level reduces the chance of treating a whole town as one uniform market.': 'Zwei nahegelegene Postcodes können sich bei Schulen, Straßenlärm, Verkehrsanbindung, Immobilienmix und Preis stark unterscheiden. Der Vergleich auf Postcode-Ebene verhindert, dass eine ganze Stadt wie ein einheitlicher Markt behandelt wird.', 'How to use the results': 'So nutzt du die Ergebnisse', 'Treat matching postcodes as a research queue: check live listings, visit streets, confirm schools and admissions, and review current official sources.': 'Behandle passende Postcodes wie eine Recherche-Liste: Prüfe Live-Inserate, geh durch die Straßen, bestätige Schulen und Admissions und nutze aktuelle offizielle Quellen.', - 'Can I save a postcode property search?': - 'Kann ich eine Postcode-Immobiliensuche speichern?', + 'Can I save a postcode property search?': 'Kann ich eine Postcode-Immobiliensuche speichern?', 'Yes. Licensed users can save searches and return to them later. Saved searches are designed for shortlists and comparison notes.': 'Ja. Lizenzierte Nutzer können Suchen speichern und später darauf zurückgreifen. Gespeicherte Suchen sind für Auswahllisten und Vergleichsnotizen gedacht.', 'Can I search without knowing the area?': 'Kann ich suchen, ohne die Gegend zu kennen?', @@ -268,8 +265,7 @@ const de: Translations = { 'Pendeln nach Postcode, nicht nur nach Ortsname', 'Two streets in the same town can have very different station access, road routes, and public transport options. Postcode-level travel-time filtering keeps that difference visible.': 'Zwei Straßen in derselben Stadt können sehr unterschiedliche Bahnhofsanbindungen, Straßenrouten und ÖPNV-Optionen haben. Fahrzeitfilter auf Postcode-Ebene halten diesen Unterschied sichtbar.', - 'Balance journey time with the rest of the move': - 'Fahrzeit mit dem restlichen Umzug abwägen', + 'Balance journey time with the rest of the move': 'Fahrzeit mit dem restlichen Umzug abwägen', 'A fast commute only helps if the area also fits your budget, housing needs, school preferences, safety threshold, broadband requirement, and tolerance for road noise.': 'Ein kurzer Arbeitsweg hilft nur, wenn die Gegend auch zu Budget, Wohnbedarf, Schulwünschen, Sicherheitsgefühl, Breitbandbedarf und Lärmtoleranz passt.', 'How travel-time filters should be interpreted': 'Wie Fahrzeitfilter zu verstehen sind', @@ -320,8 +316,7 @@ const de: Translations = { 'Die Schulqualität ist ein Teil der engeren Auswahl', 'Perfect Postcode helps you compare nearby school data with the other practical constraints that shape a family move: space, price, commute, parks, safety, and local services.': 'Mit Perfect Postcode vergleichst du Schuldaten in der Nähe mit den anderen praktischen Faktoren eines Familienumzugs: Platz, Preis, Pendelweg, Parks, Sicherheit und lokale Infrastruktur.', - 'Check catchments before making decisions': - 'Catchments vor Entscheidungen prüfen', + 'Check catchments before making decisions': 'Catchments vor Entscheidungen prüfen', 'Admissions rules and catchment boundaries can change. Use postcode-level school data to find promising areas, then verify current admissions details with the school or local authority.': 'Admissions-Regeln und Catchment-Grenzen können sich ändern. Nutze Schuldaten auf Postcode-Ebene, um vielversprechende Gebiete zu finden, und prüfe aktuelle Details bei Schule oder Local Authority.', 'How to treat school filters': 'Wie du Schulfilter einordnest', @@ -474,12 +469,10 @@ const de: Translations = { 'Make commute constraints explicit': 'Mache Pendelanforderungen klar', 'If access to the centre, a station, hospital, university, or business park matters, use travel-time filters first and then compare the remaining postcodes by property data.': 'Wenn die Erreichbarkeit des Zentrums, eines Bahnhofs, Krankenhauses, einer Universität oder eines Business Parks wichtig ist, nutze zuerst Fahrzeitfilter und vergleiche dann die übrigen Postcodes anhand der Immobiliendaten.', - 'Compare value, not just headline price': - 'Wert vergleichen, nicht nur den Angebotspreis', + 'Compare value, not just headline price': 'Wert vergleichen, nicht nur den Angebotspreis', 'Use price, property type, and floor-area filters together. This helps distinguish lower-cost areas from areas that simply contain smaller or different homes.': 'Nutze Preis-, Immobilientyp- und Wohnflächenfilter gemeinsam. So kannst du günstigere Gebiete von Gebieten unterscheiden, in denen einfach kleinere oder andere Immobilien stehen.', - 'Screen environmental and local-service signals': - 'Umwelt- und Infrastruktur-Signale prüfen', + 'Screen environmental and local-service signals': 'Umwelt- und Infrastruktur-Signale prüfen', 'Road noise, parks, broadband, crime, and amenities can affect whether a property works day to day. Use them as screening criteria before booking viewings.': 'Straßenlärm, Parks, Breitband, Kriminalität und Infrastruktur können entscheiden, ob eine Immobilie im Alltag funktioniert. Nutze sie als Screening-Kriterien, bevor du Besichtigungen buchst.', 'Can I use this for commuter villages around Bristol?': @@ -604,8 +597,7 @@ const de: Translations = { logIn: 'Anmelden', createAccount: 'Konto erstellen', resetPassword: 'Passwort zurücksetzen', - valueProp: - 'Speichere Suchen, merke Immobilien und erstelle eine Shortlist passender Gebiete.', + valueProp: 'Speichere Suchen, merke Immobilien und erstelle eine Shortlist passender Gebiete.', continueWithGoogle: 'Weiter mit Google', email: 'E-Mail', emailPlaceholder: 'name@beispiel.de', diff --git a/frontend/src/i18n/locales/fr.ts b/frontend/src/i18n/locales/fr.ts index 67188e7..918d22d 100644 --- a/frontend/src/i18n/locales/fr.ts +++ b/frontend/src/i18n/locales/fr.ts @@ -322,8 +322,7 @@ const fr: Translations = { 'La qualité des écoles n’est qu’une partie de la sélection', 'Perfect Postcode helps you compare nearby school data with the other practical constraints that shape a family move: space, price, commute, parks, safety, and local services.': 'Perfect Postcode vous aide à comparer les données des écoles à proximité avec les autres contraintes pratiques d’un déménagement familial : espace, prix, trajet, parcs, sécurité et services locaux.', - 'Check catchments before making decisions': - 'Vérifier les catchment areas avant de décider', + 'Check catchments before making decisions': 'Vérifier les catchment areas avant de décider', 'Admissions rules and catchment boundaries can change. Use postcode-level school data to find promising areas, then verify current admissions details with the school or local authority.': 'Les règles d’admission et les limites de catchment peuvent changer. Utilisez les données scolaires par code postal pour repérer des secteurs prometteurs, puis vérifiez les admissions à jour auprès de l’école ou de l’autorité locale.', 'How to treat school filters': 'Comment traiter les filtres scolaires', @@ -382,8 +381,7 @@ const fr: Translations = { 'Ce qu’une vérification du code postal ne peut pas prouver', 'It can’t confirm the condition of a home, future development, legal title, lender requirements, or current street-level experience. Those still need direct checks.': 'Il ne peut pas confirmer l’état d’un logement, les futurs projets, le titre de propriété, les exigences du prêteur ou le ressenti actuel dans la rue. Ces points demandent encore des vérifications directes.', - 'Can I use the checker before a viewing?': - 'Puis-je utiliser cet outil avant une visite ?', + 'Can I use the checker before a viewing?': 'Puis-je utiliser cet outil avant une visite ?', 'Yes. That’s one of the main use cases: screen the postcode first, then decide whether the viewing is worth the time.': 'Oui. C’est l’un des principaux cas d’utilisation : examinez d’abord le code postal, puis décidez si la visite vaut le temps consacré.', 'Does the checker include exact property condition?': @@ -482,8 +480,7 @@ const fr: Translations = { 'Compare value, not just headline price': 'Comparez la valeur, pas seulement le prix affiché', 'Use price, property type, and floor-area filters together. This helps distinguish lower-cost areas from areas that simply contain smaller or different homes.': 'Utilisez ensemble les filtres de prix, de type de bien et de surface. Cela distingue les secteurs vraiment moins chers de ceux qui comptent simplement des logements plus petits ou différents.', - 'Screen environmental and local-service signals': - 'Examiner environnement et services locaux', + 'Screen environmental and local-service signals': 'Examiner environnement et services locaux', 'Road noise, parks, broadband, crime, and amenities can affect whether a property works day to day. Use them as screening criteria before booking viewings.': 'Le bruit routier, les parcs, le haut débit, la criminalité et les services de proximité peuvent affecter la vie quotidienne dans un logement. Utilisez-les comme critères de tri avant de réserver des visites.', 'Can I use this for commuter villages around Bristol?': diff --git a/frontend/src/i18n/locales/hi.ts b/frontend/src/i18n/locales/hi.ts index 7f9f742..175eb45 100644 --- a/frontend/src/i18n/locales/hi.ts +++ b/frontend/src/i18n/locales/hi.ts @@ -205,7 +205,8 @@ const hi: Translations = { 'Relax one constraint at a time': 'एक बार में एक constraint ढीला करें', 'When the search becomes too narrow, loosen a single filter and watch which postcodes reappear. This makes compromise explicit instead of relying on guesswork.': 'जब search बहुत संकरी हो जाए, तो एक फ़िल्टर ढीला करें और देखें कौन से पोस्टकोड वापस आते हैं. इससे guesswork के बजाय compromise साफ दिखता है.', - 'Turn vague areas into specific postcodes': 'धुंधले area ideas को specific postcodes में बदलें', + 'Turn vague areas into specific postcodes': + 'धुंधले area ideas को specific postcodes में बदलें', 'Broad town or borough searches hide large differences between streets. Perfect Postcode helps you move from a general area to postcodes that satisfy your hard requirements.': 'Town या borough-level searches सड़कों के बीच बड़े फर्क छिपा देती हैं. Perfect Postcode आपको general area से उन पोस्टकोड तक ले जाता है जो आपकी hard requirements पूरी करते हैं.', 'Keep trade-offs visible': 'Trade-offs साफ रखें', @@ -217,7 +218,8 @@ const hi: Translations = { 'How to use the results': 'परिणामों का उपयोग कैसे करें', 'Treat matching postcodes as a research queue: check live listings, visit streets, confirm schools and admissions, and review current official sources.': 'Matching postcodes को research queue की तरह लें: live listings देखें, streets visit करें, schools और admissions confirm करें, और current official sources check करें.', - 'Can I save a postcode property search?': 'क्या मैं postcode property search सेव कर सकता हूँ?', + 'Can I save a postcode property search?': + 'क्या मैं postcode property search सेव कर सकता हूँ?', 'Yes. Licensed users can save searches and return to them later. Saved searches are designed for shortlists and comparison notes.': 'हाँ. Licensed users searches सेव कर सकते हैं और बाद में वहीं लौट सकते हैं. Saved searches shortlist और comparison notes के लिए बनाई गई हैं.', 'Can I search without knowing the area?': 'क्या area जाने बिना search कर सकता हूँ?', @@ -231,8 +233,7 @@ const hi: Translations = { 'Greater Manchester के आसपास broad search को narrow करने के लिए regional guide.', 'Start a postcode search': 'Postcode search शुरू करें', 'Commute property search': 'Commute के हिसाब से प्रॉपर्टी खोजें', - 'Search for places to live by commute time': - 'Commute time के हिसाब से रहने की जगहें खोजें', + 'Search for places to live by commute time': 'Commute time के हिसाब से रहने की जगहें खोजें', 'Commute property search - Find places to live by travel time': 'Commute property search - travel time से रहने की जगहें खोजें', 'Filter postcodes by commute time, then compare price, schools, safety, broadband, road noise, parks and property data on one map.': @@ -260,8 +261,7 @@ const hi: Translations = { 'Journey time को move की बाकी जरूरतों से balance करें', 'A fast commute only helps if the area also fits your budget, housing needs, school preferences, safety threshold, broadband requirement, and tolerance for road noise.': 'Fast commute तभी मदद करता है जब area आपके बजट, housing needs, school preferences, safety threshold, ब्रॉडबैंड जरूरत और road noise tolerance से भी match करता हो.', - 'How travel-time filters should be interpreted': - 'Travel-time filters को कैसे पढ़ें', + 'How travel-time filters should be interpreted': 'Travel-time filters को कैसे पढ़ें', 'Travel-time modelling is useful for comparing areas consistently. Before committing, check current timetables, disruption patterns, parking, cycling conditions, and walking routes.': 'Travel-time modelling इलाकों की consistent comparison के लिए useful है. Commit करने से पहले current timetables, disruption patterns, parking, cycling conditions और walking routes जरूर check करें.', 'Why commute filters are combined with property data': @@ -305,7 +305,8 @@ const hi: Translations = { 'Verify admissions before deciding': 'फैसले से पहले admissions verify करें', 'School data can point to promising areas, but admissions rules and catchments can change. Confirm current arrangements with schools and local authorities.': 'School data promising areas दिखा सकता है, लेकिन admissions rules और catchments बदल सकते हैं. Schools और local authorities से current arrangements confirm करें.', - 'School quality is one part of the shortlist': 'School quality shortlist का सिर्फ एक हिस्सा है', + 'School quality is one part of the shortlist': + 'School quality shortlist का सिर्फ एक हिस्सा है', 'Perfect Postcode helps you compare nearby school data with the other practical constraints that shape a family move: space, price, commute, parks, safety, and local services.': 'Perfect Postcode nearby school data को उन practical constraints के साथ compare करने में मदद करता है जो family move को shape करती हैं: space, price, commute, parks, safety और local services.', 'Check catchments before making decisions': 'फैसले से पहले catchments check करें', @@ -317,7 +318,8 @@ const hi: Translations = { 'Family trade-offs to compare': 'Compare करने लायक family trade-offs', 'Combine schools with parks, road noise, crime, property size, commute, broadband, and price so the shortlist reflects the whole move.': 'Schools को parks, road noise, crime, property size, commute, broadband और price के साथ मिलाएं ताकि shortlist पूरा move दिखाए.', - 'Does this show school catchment guarantees?': 'क्या यह school catchment guarantee दिखाता है?', + 'Does this show school catchment guarantees?': + 'क्या यह school catchment guarantee दिखाता है?', 'No. It helps identify promising areas, but catchments and admissions must be verified with the school or local authority.': 'नहीं. यह promising areas पहचानने में मदद करता है, लेकिन catchments और admissions school या local authority से verify करने होंगे.', 'Can I combine school filters with parks and safety?': @@ -396,8 +398,7 @@ const hi: Translations = { 'Compare price with property type': 'Price को property type के साथ compare करें', 'Median prices alone can be misleading if the local property mix changes. Add property type, tenure, floor area, and price filters so similar areas are compared fairly.': 'अगर local property mix बदलता है, तो सिर्फ median prices misleading हो सकती हैं. Similar areas की fair comparison के लिए property type, tenure, floor area और price filters जोड़ें.', - 'Keep family and environment trade-offs visible': - 'Family और environment trade-offs साफ रखें', + 'Keep family and environment trade-offs visible': 'Family और environment trade-offs साफ रखें', 'Layer school context, parks, road noise, broadband, and crime signals on top of the property filters. That makes it easier to decide which compromises are acceptable.': 'Property filters के ऊपर school context, parks, road noise, broadband और crime signals layer करें. इससे तय करना आसान होता है कि कौन से compromises acceptable हैं.', 'Can Perfect Postcode tell me the best area in Birmingham?': @@ -460,8 +461,7 @@ const hi: Translations = { 'Make commute constraints explicit': 'Commute constraints साफ करें', 'If access to the centre, a station, hospital, university, or business park matters, use travel-time filters first and then compare the remaining postcodes by property data.': 'अगर centre, station, hospital, university या business park तक access मायने रखती है, तो पहले travel-time filters लगाएं और फिर बचे postcodes को property data से compare करें.', - 'Compare value, not just headline price': - 'सिर्फ headline price नहीं, value compare करें', + 'Compare value, not just headline price': 'सिर्फ headline price नहीं, value compare करें', 'Use price, property type, and floor-area filters together. This helps distinguish lower-cost areas from areas that simply contain smaller or different homes.': 'Price, property type और floor-area filters साथ इस्तेमाल करें. इससे सच में lower-cost areas को उन areas से अलग करना आसान होता है जहां बस छोटे या अलग homes हैं.', 'Screen environmental and local-service signals': diff --git a/frontend/src/i18n/locales/hu.ts b/frontend/src/i18n/locales/hu.ts index 5275dc6..35f0282 100644 --- a/frontend/src/i18n/locales/hu.ts +++ b/frontend/src/i18n/locales/hu.ts @@ -471,8 +471,7 @@ const hu: Translations = { 'Make commute constraints explicit': 'Tedd egyértelművé az ingázási korlátokat', 'If access to the centre, a station, hospital, university, or business park matters, use travel-time filters first and then compare the remaining postcodes by property data.': 'Ha fontos a központ, állomás, kórház, egyetem vagy business park elérése, először használd az utazási idő szűrőit, majd hasonlítsd össze a fennmaradó irányítószámokat ingatlanadatok alapján.', - 'Compare value, not just headline price': - 'Az értéket nézd, ne csak a kiemelt árat', + 'Compare value, not just headline price': 'Az értéket nézd, ne csak a kiemelt árat', 'Use price, property type, and floor-area filters together. This helps distinguish lower-cost areas from areas that simply contain smaller or different homes.': 'Használd együtt az ár-, ingatlantípus- és alapterület-szűrőket. Ez segít megkülönböztetni az olcsóbb területeket azoktól, ahol egyszerűen kisebb vagy eltérő otthonok vannak.', 'Screen environmental and local-service signals': diff --git a/frontend/src/i18n/locales/zh.ts b/frontend/src/i18n/locales/zh.ts index 8e1b0ee..0e8c41d 100644 --- a/frontend/src/i18n/locales/zh.ts +++ b/frontend/src/i18n/locales/zh.ts @@ -133,7 +133,8 @@ const zh: Translations = { '按邮编筛选历史成交价与当前估值。', 'Compare value with commute, schools, broadband, crime, noise, and amenities.': '把房价与通勤、学校、宽带、治安、噪音和周边设施放在一起比较。', - 'Build a shortlist before spending weekends on viewings.': '把周末花在看房前，先整理出候选名单。', + 'Build a shortlist before spending weekends on viewings.': + '把周末花在看房前，先整理出候选名单。', 'Find postcodes that fit the budget before listings appear': '抢在房源上架之前，先锁定符合预算的邮编', 'Start with a maximum price and property type, then colour the map by price per square metre or estimated current price. This helps reveal areas where similar homes have historically traded within reach, even when there are no live listings today.': @@ -1074,7 +1075,8 @@ const zh: Translations = { dsConservationAreasUse: '英格兰指定保护区边界。用于标记邮编代表点是否位于保护区内。', dsListedBuildingsName: 'Historic England 受保护建筑', dsListedBuildingsOrigin: 'Historic England 英格兰国家遗产名录', - dsListedBuildingsUse: '英格兰受保护建筑点位记录。用于标记地址似乎与附近受保护建筑条目匹配的房产。', + dsListedBuildingsUse: + '英格兰受保护建筑点位记录。用于标记地址似乎与附近受保护建筑条目匹配的房产。', dsNaptanName: 'NaPTAN（公共交通站点）', dsNaptanOrigin: 'Department for Transport', dsNaptanUse: '英格兰各地铁路、公交、地铁/有轨电车、渡轮和机场的站点位置。', diff --git a/pipeline/download/satellite_highres.py b/pipeline/download/satellite_highres.py index 06141df..0de2d72 100644 --- a/pipeline/download/satellite_highres.py +++ b/pipeline/download/satellite_highres.py @@ -186,7 +186,6 @@ def _download_and_extract( """Download one survey zip and extract its ECW raster(s).""" url = f"{tile.uri}?subscription-key={key}" zip_path = ecw_dir / f"{tile.os_tile_id}.zip" - last_error: Exception | None = None for attempt in range(retries + 1): try: with urllib.request.urlopen( @@ -196,7 +195,6 @@ def _download_and_extract( shutil.copyfileobj(response, out, length=1 << 20) break except (urllib.error.URLError, TimeoutError, ConnectionError) as err: - last_error = err if attempt == retries: raise RuntimeError(f"Failed to download {url}: {err}") from err extracted: list[Path] = [] diff --git a/pipeline/transform/postcode_boundaries/README.md b/pipeline/transform/postcode_boundaries/README.md index 15d96e3..0d98651 100644 --- a/pipeline/transform/postcode_boundaries/README.md +++ b/pipeline/transform/postcode_boundaries/README.md @@ -37,11 +37,11 @@ Pre-allocates numpy arrays at 25M capacity and grows by 1.5x if needed (using in **Loading** (`inspire.py:load_inspire`): Bboxes and offsets are loaded into RAM (~1.1GB). Coords are memory-mapped — the OS pages them in on demand from the ~3GB file, never loading the whole thing. -**Candidate retrieval** (`inspire.py:get_inspire_candidates`): Given an OA's bounding box, performs a vectorized numpy overlap test against all 24M INSPIRE bboxes — four comparisons broadcast across the entire array. Typically matches 10-500 parcels per OA. Only those matches are materialized as Shapely Polygon objects by reading their coordinate slice from the memory-mapped file. Invalid polygons are repaired with `make_valid`. +**Candidate retrieval** (`inspire.py:InspireIndex`): A uniform 1km grid index is built once over the 24M parcel bboxes (`build_inspire_index`). Each OA lookup (`InspireIndex.candidates`) gathers parcels from the cells its bounding box covers plus a small overflow list of parcels larger than one cell, then applies the exact bbox overlap test — O(cells + candidates) instead of an O(24M) scan per OA (the old linear scan was ~4h of the run on its own). The candidate set and order are identical to the scan. Typically matches 10-500 parcels per OA, materialized as Shapely Polygon objects by reading their coordinate slice from the memory-mapped file; invalid polygons are repaired with `make_valid`. ### Phase 3: Processing OAs -The main loop in `__main__.py` iterates through every OA that has both a boundary polygon and UPRNs. For each OA, it retrieves the OA's UPRN points and postcodes. +The main loop in `__main__.py` (`_process_oas`) iterates through every OA that has both a boundary polygon and UPRNs. For each OA, it retrieves the OA's UPRN points and postcodes. OAs are independent, so the loop fans out across CPU cores with a `fork` process pool (`--workers`, default all CPUs): workers share the big read-only inputs (INSPIRE arrays + coords mmap, UPRN arrays, OA geometries) copy-on-write and return WKB-encoded fragments. Workers slice the UPRN data from plain numpy/Arrow arrays (`extract_uprn_arrays`) rather than polars, avoiding the fork-after-threads hazard of polars' thread pool. Fragment order doesn't affect the output (`merge_fragments` unions per postcode), so the parallel result is identical to single-process. **Fast path**: If every UPRN in the OA shares the same postcode, the entire OA polygon is assigned to that postcode. No geometry computation needed. This covers the majority of OAs (~70-80%). diff --git a/server-rs/src/routes/export.rs b/server-rs/src/routes/export.rs index 505e939..ae5f588 100644 --- a/server-rs/src/routes/export.rs +++ b/server-rs/src/routes/export.rs @@ -208,7 +208,7 @@ struct ParsedPostcodeList { fn parse_postcode_list( raw: &str, state: &crate::state::AppState, -) -> Result<ParsedPostcodeList, axum::response::Response> { +) -> Result<ParsedPostcodeList, (StatusCode, String)> { let mut entries: Vec<(usize, String)> = Vec::new(); let mut unknown: Vec<String> = Vec::new(); let mut seen: FxHashSet<usize> = FxHashSet::default(); @@ -229,8 +229,7 @@ fn parse_postcode_list( "Too many postcodes; at most {} are supported per export", MAX_EXPORT_POSTCODES ), - ) - .into_response()); + )); } match state.postcode_data.postcode_to_idx.get(&normalized) { Some(&pc_idx) if seen.insert(pc_idx) => { @@ -245,8 +244,7 @@ fn parse_postcode_list( return Err(( StatusCode::BAD_REQUEST, "No valid postcodes supplied".to_string(), - ) - .into_response()); + )); } Ok(ParsedPostcodeList { entries, unknown }) @@ -296,7 +294,9 @@ pub async fn get_export( // Two modes: bounds-based (default) and explicit postcode list. let postcode_list = match params.postcodes.as_deref() { - Some(raw) if !raw.trim().is_empty() => Some(parse_postcode_list(raw, &state)?), + Some(raw) if !raw.trim().is_empty() => { + Some(parse_postcode_list(raw, &state).map_err(IntoResponse::into_response)?) + } _ => None, }; let is_postcode_mode = postcode_list.is_some(); From d43da9708c627f0bc1daa4df0b990b08432e57a3 Mon Sep 17 00:00:00 2001 From: Andras Schmelczer <andras@schmelczer.dev> Date: Tue, 2 Jun 2026 13:46:18 +0100 Subject: [PATCH 5/9] idk --- .../src/components/map/LocationSearch.tsx | 17 +- frontend/src/hooks/useLocationSearch.ts | 145 +++-- frontend/src/hooks/useTravelTime.test.ts | 18 +- frontend/src/hooks/useTravelTime.ts | 10 +- frontend/src/i18n/descriptions.ts | 33 +- frontend/src/i18n/details.ts | 4 +- pipeline/check_travel_times.py | 62 +- pipeline/download/broadband.py | 12 +- pipeline/download/naptan.py | 64 +- pipeline/download/ofsted.py | 7 +- pipeline/download/places.py | 256 +++++++- pipeline/download/test_naptan.py | 89 +++ pipeline/download/test_noise.py | 20 +- pipeline/download/test_places.py | 74 +++ pipeline/download/transit_network.py | 31 +- pipeline/transform/crime.py | 45 +- pipeline/transform/crime_spatial.py | 13 +- pipeline/transform/join_epc_pp.py | 26 +- pipeline/transform/merge.py | 80 ++- pipeline/transform/poi_proximity.py | 40 +- .../transform/postcode_boundaries/README.md | 8 +- .../transform/postcode_boundaries/__main__.py | 315 ++++++--- .../transform/postcode_boundaries/inspire.py | 162 +++-- .../transform/postcode_boundaries/output.py | 309 +++++++-- .../postcode_boundaries/process_oa.py | 48 +- .../test_postcode_boundaries.py | 465 +++++++++++++- .../transform/postcode_boundaries/uprn.py | 75 ++- .../transform/price_estimation/backtest.py | 18 +- pipeline/transform/price_estimation/index.py | 13 + .../transform/price_estimation/shrinkage.py | 45 ++ pipeline/transform/test_crime.py | 47 ++ pipeline/transform/test_crime_spatial.py | 57 ++ pipeline/transform/test_join_epc_pp.py | 90 +++ pipeline/transform/test_merge.py | 125 ++++ pipeline/transform/test_poi_proximity.py | 35 + pipeline/transform/test_transform_poi.py | 117 +++- pipeline/transform/transform_poi.py | 48 +- pipeline/utils/fuzzy_join.py | 28 +- pipeline/utils/postcode_mapping.py | 30 +- pipeline/utils/test_fuzzy_join.py | 85 +++ server-rs/src/data.rs | 4 +- server-rs/src/data/crime_by_year.rs | 4 +- server-rs/src/data/places.rs | 473 +++++++++++++- server-rs/src/data/poi.rs | 4 +- server-rs/src/data/property.rs | 439 +++++++++++-- server-rs/src/main.rs | 3 +- server-rs/src/routes/places.rs | 600 ++++++++++++++---- 47 files changed, 4120 insertions(+), 573 deletions(-) diff --git a/frontend/src/components/map/LocationSearch.tsx b/frontend/src/components/map/LocationSearch.tsx index e5a3c16..0f2caa4 100644 --- a/frontend/src/components/map/LocationSearch.tsx +++ b/frontend/src/components/map/LocationSearch.tsx @@ -4,7 +4,11 @@ import type { MapFlyToOptions, PostcodeGeometry } from '../../types'; import { authHeaders, isAbortError } from '../../lib/api'; import { POSTCODE_SEARCH_ZOOM } from '../../lib/consts'; import { useIsMobile } from '../../hooks/useIsMobile'; -import { useLocationSearch, type SearchResult } from '../../hooks/useLocationSearch'; +import { + useLocationSearch, + type SearchResult, + type ViewportCenter, +} from '../../hooks/useLocationSearch'; import { PlaceSearchInput } from '../ui/PlaceSearchInput'; import { LocateIcon } from '../ui/icons/LocateIcon'; import { SearchIcon } from '../ui/icons/SearchIcon'; @@ -44,6 +48,12 @@ const ZOOM_FOR_TYPE: Record<string, number> = { locality: 14, hamlet: 15, isolated_dwelling: 16, + street: 16, + university: 15, + park: 15, + attraction: 16, + hospital: 16, + retail: 15, }; const DEV_CURRENT_LOCATION = { @@ -56,6 +66,7 @@ export default function LocationSearch({ onLocationSearched, onCurrentLocationFound, onMouseEnter, + getViewportCenter, className = '', inputClassName, }: { @@ -63,11 +74,13 @@ export default function LocationSearch({ onLocationSearched?: (postcode: SearchedLocation | null) => void; onCurrentLocationFound?: (lat: number, lng: number) => void; onMouseEnter?: () => void; + /** Returns the current map centre so search ranking can bias toward the visible area. */ + getViewportCenter?: () => ViewportCenter | null; className?: string; inputClassName?: string; }) { const { t } = useTranslation(); - const search = useLocationSearch(); + const search = useLocationSearch(undefined, getViewportCenter); const [error, setError] = useState<string | null>(null); const [loading, setLoading] = useState(false); const [expanded, setExpanded] = useState(false); diff --git a/frontend/src/hooks/useLocationSearch.ts b/frontend/src/hooks/useLocationSearch.ts index 34bbed4..df4cdfa 100644 --- a/frontend/src/hooks/useLocationSearch.ts +++ b/frontend/src/hooks/useLocationSearch.ts @@ -154,7 +154,100 @@ function searchResultKey(result: SearchResult): string { return `place:${result.slug}`; } -export function useLocationSearch(mode?: string) { +/** A category-tagged, scored result from the unified `/api/places` ranking. */ +type UnifiedResultDTO = + | { type: 'postcode'; label: string; score: number } + | { type: 'address'; address: string; postcode: string; lat: number; lon: number; score: number } + | { + type: 'place'; + name: string; + slug: string; + place_type: string; + lat: number; + lon: number; + city?: string; + score: number; + }; + +interface PlacesApiResponse { + places: PlaceResult[]; + postcodes?: string[]; + addresses?: AddressResult[]; + /** Preferred: a single relevance-ordered list across all categories. */ + results?: UnifiedResultDTO[]; +} + +function isNonNull<T>(value: T | null): value is T { + return value !== null; +} + +function unifiedToSearchResult(result: UnifiedResultDTO): SearchResult | null { + if (result.type === 'postcode') { + return { type: 'postcode', label: result.label }; + } + if (result.type === 'address') { + return { + type: 'address', + address: result.address, + postcode: result.postcode, + lat: result.lat, + lon: result.lon, + }; + } + if (result.type === 'place') { + return { + type: 'place', + name: result.name, + slug: result.slug, + place_type: result.place_type, + lat: result.lat, + lon: result.lon, + city: result.city === 'City of London' ? 'London' : result.city, + }; + } + return null; +} + +/** Legacy ordering for servers that predate the unified `results` list: positional buckets, + * re-filtered locally. Retained only as a fallback. */ +function legacyCombineResults(json: PlacesApiResponse, trimmed: string): SearchResult[] { + const placeResults = json.places.map((p) => ({ + type: 'place' as const, + name: p.name, + slug: p.slug, + place_type: p.place_type, + lat: p.lat, + lon: p.lon, + city: p.city === 'City of London' ? 'London' : p.city, + })); + const outcodeResults = placeResults.filter((result) => result.place_type === 'outcode'); + const otherPlaceResults = placeResults.filter((result) => result.place_type !== 'outcode'); + const postcodeResults: SearchResult[] = (json.postcodes ?? []).map((postcode) => ({ + type: 'postcode' as const, + label: postcode, + })); + const addressResults: SearchResult[] = (json.addresses ?? []).map((address) => ({ + type: 'address' as const, + address: address.address, + postcode: address.postcode, + lat: address.lat, + lon: address.lon, + })); + const containsHouseNumber = /\d/.test(trimmed); + return filterResultsForQuery( + containsHouseNumber + ? [...outcodeResults, ...postcodeResults, ...addressResults, ...otherPlaceResults] + : [...outcodeResults, ...postcodeResults, ...otherPlaceResults, ...addressResults], + trimmed + ); +} + +export type ViewportCenter = { lat: number; lng: number }; + +export function useLocationSearch( + mode?: string, + getViewportCenter?: () => ViewportCenter | null +) { const [query, setQuery] = useState(''); const [results, setResults] = useState<SearchResult[]>([]); const [recentSearches, setRecentSearches] = useState<SearchResult[]>(readRecentSearches); @@ -165,6 +258,9 @@ export function useLocationSearch(mode?: string) { const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null); const latestQueryRef = useRef(''); const lastResultsRef = useRef<SearchResult[]>([]); + // Held in a ref so a non-memoized callback from the parent doesn't churn handleInputChange. + const getViewportCenterRef = useRef(getViewportCenter); + getViewportCenterRef.current = getViewportCenter; const handleInputChange = useCallback( (value: string) => { @@ -212,6 +308,11 @@ export function useLocationSearch(mode?: string) { try { const params = new URLSearchParams({ q: trimmed }); if (mode) params.set('mode', mode); + const center = getViewportCenterRef.current?.(); + if (center) { + params.set('lat', String(center.lat)); + params.set('lng', String(center.lng)); + } const res = await fetch( `/api/places?${params}`, authHeaders({ signal: controller.signal }) @@ -223,47 +324,19 @@ export function useLocationSearch(mode?: string) { } return; } - const json: { - places: PlaceResult[]; - postcodes?: string[]; - addresses?: AddressResult[]; - } = await res.json(); - const placeResults = json.places.map((p) => ({ - type: 'place' as const, - name: p.name, - slug: p.slug, - place_type: p.place_type, - lat: p.lat, - lon: p.lon, - city: p.city === 'City of London' ? 'London' : p.city, - })); - const outcodeResults = placeResults.filter((result) => result.place_type === 'outcode'); - const otherPlaceResults = placeResults.filter( - (result) => result.place_type !== 'outcode' - ); - const postcodeResults: SearchResult[] = (json.postcodes ?? []).map((postcode) => ({ - type: 'postcode' as const, - label: postcode, - })); - const addressResults: SearchResult[] = (json.addresses ?? []).map((address) => ({ - type: 'address' as const, - address: address.address, - postcode: address.postcode, - lat: address.lat, - lon: address.lon, - })); - const containsHouseNumber = /\d/.test(trimmed); + const json: PlacesApiResponse = await res.json(); const combinedResults = ( - containsHouseNumber - ? [...outcodeResults, ...postcodeResults, ...addressResults, ...otherPlaceResults] - : [...outcodeResults, ...postcodeResults, ...otherPlaceResults, ...addressResults] + Array.isArray(json.results) + ? json.results.map(unifiedToSearchResult).filter(isNonNull) + : legacyCombineResults(json, trimmed) ).slice(0, 20); if (controller.signal.aborted || latestQueryRef.current.trim() !== trimmed) { return; } lastResultsRef.current = combinedResults; - const matchingResults = filterResultsForQuery(combinedResults, trimmed); - setResults(matchingResults); + // Trust the server's unified ranking — re-filtering here previously dropped valid + // alias and partial-postcode matches. The optimistic pre-fetch path still filters. + setResults(combinedResults); setOpen(true); } catch (err) { logNonAbortError('places search', err); diff --git a/frontend/src/hooks/useTravelTime.test.ts b/frontend/src/hooks/useTravelTime.test.ts index 06073de..81ac3b9 100644 --- a/frontend/src/hooks/useTravelTime.test.ts +++ b/frontend/src/hooks/useTravelTime.test.ts @@ -178,7 +178,11 @@ describe('resolveTransitVariant', () => { describe('parseServerMode', () => { it('round-trips the four toggle-reachable variants', () => { - expect(parseServerMode('transit')).toEqual({ mode: 'transit', noChange: false, noBuses: false }); + expect(parseServerMode('transit')).toEqual({ + mode: 'transit', + noChange: false, + noBuses: false, + }); expect(parseServerMode('transit-no-bus')).toEqual({ mode: 'transit', noChange: false, @@ -198,8 +202,16 @@ describe('parseServerMode', () => { it('parses non-transit base modes', () => { expect(parseServerMode('car')).toEqual({ mode: 'car', noChange: false, noBuses: false }); - expect(parseServerMode('bicycle')).toEqual({ mode: 'bicycle', noChange: false, noBuses: false }); - expect(parseServerMode('walking')).toEqual({ mode: 'walking', noChange: false, noBuses: false }); + expect(parseServerMode('bicycle')).toEqual({ + mode: 'bicycle', + noChange: false, + noBuses: false, + }); + expect(parseServerMode('walking')).toEqual({ + mode: 'walking', + noChange: false, + noBuses: false, + }); }); it('returns null for variants the UI cannot represent (no silent broadening)', () => { diff --git a/frontend/src/hooks/useTravelTime.ts b/frontend/src/hooks/useTravelTime.ts index 243e907..b913525 100644 --- a/frontend/src/hooks/useTravelTime.ts +++ b/frontend/src/hooks/useTravelTime.ts @@ -138,7 +138,15 @@ export function useTravelTime(initial?: TravelTimeInitial) { const handleAddEntry = useCallback((mode: TransportMode) => { setEntries((prev) => [ ...prev, - { mode, slug: '', label: '', timeRange: null, useBest: false, noChange: false, noBuses: false }, + { + mode, + slug: '', + label: '', + timeRange: null, + useBest: false, + noChange: false, + noBuses: false, + }, ]); }, []); diff --git a/frontend/src/i18n/descriptions.ts b/frontend/src/i18n/descriptions.ts index f53fd6b..31a279b 100644 --- a/frontend/src/i18n/descriptions.ts +++ b/frontend/src/i18n/descriptions.ts @@ -22,7 +22,8 @@ const descriptions: Record<string, Record<string, string>> = { 'Est. price per sqm': 'Prix actuel estimé rapporté à la surface totale', 'Estimated monthly rent': 'Loyer mensuel privé moyen dans le secteur', 'Total floor area (sqm)': 'Surface intérieure relevée lors du diagnostic EPC', - 'Number of bedrooms & living rooms': 'Nombre de pièces habitables relevé lors du diagnostic EPC', + 'Number of bedrooms & living rooms': + 'Nombre de pièces habitables relevé lors du diagnostic EPC', 'Construction year': 'Année de construction estimée à partir de l’EPC', 'Date of last transaction': 'Date de la vente la plus récente enregistrée au Land Registry', 'Former council house': 'Indique si le bien a déjà été répertorié comme logement social', @@ -30,7 +31,8 @@ const descriptions: Record<string, Record<string, string>> = { 'Potential energy rating': 'Classe énergétique EPC possible si toutes les améliorations recommandées étaient réalisées', 'Interior height (m)': 'Hauteur intérieure moyenne relevée lors du diagnostic EPC', - 'Street tree density percentile': 'Percentile estimé de couverture arborée autour du code postal', + 'Street tree density percentile': + 'Percentile estimé de couverture arborée autour du code postal', 'Within conservation area': 'Indique si le point représentatif du code postal se situe dans une zone de conservation désignée', 'Listed building': @@ -67,7 +69,8 @@ const descriptions: Record<string, Record<string, string>> = { 'Moyenne annuelle des violences et infractions sexuelles dans le secteur', 'Burglary (avg/yr)': 'Moyenne annuelle des cambriolages dans le secteur', 'Robbery (avg/yr)': 'Moyenne annuelle des vols avec violence dans le secteur', - 'Vehicle crime (avg/yr)': 'Moyenne annuelle des infractions liées aux véhicules dans le secteur', + 'Vehicle crime (avg/yr)': + 'Moyenne annuelle des infractions liées aux véhicules dans le secteur', 'Anti-social behaviour (avg/yr)': 'Moyenne annuelle des comportements antisociaux dans le secteur', 'Criminal damage and arson (avg/yr)': @@ -89,8 +92,7 @@ const descriptions: Record<string, Record<string, string>> = { '% Mixed': 'Part de la population s’identifiant comme métisse ou de plusieurs groupes ethniques', '% Other': 'Part de la population s’identifiant comme appartenant à un autre groupe ethnique', - 'Voter turnout (%)': - 'Part des électeurs inscrits ayant voté aux élections générales de 2024', + 'Voter turnout (%)': 'Part des électeurs inscrits ayant voté aux élections générales de 2024', '% Labour': 'Part des voix travaillistes aux élections générales de 2024', '% Conservative': 'Part des voix conservatrices aux élections générales de 2024', '% Liberal Democrat': 'Part des voix libérales-démocrates aux élections générales de 2024', @@ -98,8 +100,10 @@ const descriptions: Record<string, Record<string, string>> = { '% Green': 'Part des voix vertes aux élections générales de 2024', '% Other parties': 'Part cumulée des voix de tous les autres partis et indépendants', 'Distance to nearest park (km)': 'Distance au parc ou espace vert le plus proche', - 'Noise (dB)': 'Le plus élevé des bruits routier, ferroviaire ou aérien près du code postal, en décibels (Lden). Angleterre uniquement ; vide = hors zone cartographiée, pas forcément calme.', - 'Max available download speed (Mbps)': 'Débit descendant haut débit maximal disponible au code postal', + 'Noise (dB)': + 'Le plus élevé des bruits routier, ferroviaire ou aérien près du code postal, en décibels (Lden). Angleterre uniquement ; vide = hors zone cartographiée, pas forcément calme.', + 'Max available download speed (Mbps)': + 'Débit descendant haut débit maximal disponible au code postal', Schools: 'Écoles primaires et secondaires notées à proximité', 'Specific crimes': 'Filtrer une seule catégorie d’infractions de rue à la fois', Ethnicities: 'Part de la population par groupe ethnique', @@ -152,8 +156,7 @@ const descriptions: Record<string, Record<string, string>> = { 'Education, Skills and Training Score': 'Benachteiligungsperzentil für Bildung, Kompetenzen und Ausbildung (höher = weniger benachteiligt)', 'Income Score': 'Einkommensbenachteiligungsperzentil (höher = weniger benachteiligt)', - 'Employment Score': - 'Beschäftigungsbenachteiligungsperzentil (höher = weniger benachteiligt)', + 'Employment Score': 'Beschäftigungsbenachteiligungsperzentil (höher = weniger benachteiligt)', 'Health Deprivation and Disability Score': 'Perzentil für gesundheitliche Benachteiligung und Behinderung (höher = bessere Ergebnisse)', 'Housing Conditions Score': 'Wohnbedingungen-Perzentil (höher = bessere Bedingungen)', @@ -198,7 +201,8 @@ const descriptions: Record<string, Record<string, string>> = { '% Green': 'Stimmenanteil der Grünen bei der Parlamentswahl 2024', '% Other parties': 'Kombinierter Stimmenanteil aller anderen Parteien und Unabhängigen', 'Distance to nearest park (km)': 'Entfernung zum nächsten Park oder Grünfläche', - 'Noise (dB)': 'Lautester von Straßen-, Bahn- oder Fluglärm in der Nähe des Postcodes in Dezibel (Lden). Nur England; leer = nicht kartiert, nicht unbedingt leise.', + 'Noise (dB)': + 'Lautester von Straßen-, Bahn- oder Fluglärm in der Nähe des Postcodes in Dezibel (Lden). Nur England; leer = nicht kartiert, nicht unbedingt leise.', 'Max available download speed (Mbps)': 'Maximal verfügbare Breitband-Downloadgeschwindigkeit am Postcode', Schools: 'Bewertete Grundschulen und weiterführende Schulen in der Nähe', @@ -273,7 +277,8 @@ const descriptions: Record<string, Record<string, string>> = { '% Green': '2024 年大选中绿党得票率', '% Other parties': '所有其他政党和独立候选人的综合得票率', 'Distance to nearest park (km)': '到最近公园或绿地的距离', - 'Noise (dB)': '该邮编附近道路、铁路或机场中最高的噪音水平（Lden，分贝）。仅英格兰；空白表示未覆盖，不一定安静。', + 'Noise (dB)': + '该邮编附近道路、铁路或机场中最高的噪音水平（Lden，分贝）。仅英格兰；空白表示未覆盖，不一定安静。', 'Max available download speed (Mbps)': '该邮编可用的最高宽带下载速度', Schools: '附近有评级的小学和中学', 'Specific crimes': '一次筛选一种街面犯罪类别', @@ -358,7 +363,8 @@ const descriptions: Record<string, Record<string, string>> = { '% Green': '2024 आम चुनाव में ग्रीन पार्टी का मत-प्रतिशत', '% Other parties': 'बाकी सभी पार्टियों और निर्दलीयों का संयुक्त मत-प्रतिशत', 'Distance to nearest park (km)': 'निकटतम पार्क या हरित क्षेत्र तक दूरी', - 'Noise (dB)': 'पोस्टकोड के पास सड़क, रेल या हवाई अड्डे के शोर में सबसे अधिक, डेसीबल (Lden) में। केवल इंग्लैंड; खाली = मैप नहीं किया गया, जरूरी नहीं कि शांत हो।', + 'Noise (dB)': + 'पोस्टकोड के पास सड़क, रेल या हवाई अड्डे के शोर में सबसे अधिक, डेसीबल (Lden) में। केवल इंग्लैंड; खाली = मैप नहीं किया गया, जरूरी नहीं कि शांत हो।', 'Max available download speed (Mbps)': 'पोस्टकोड पर उपलब्ध अधिकतम डाउनलोड गति', Schools: 'पास के रेटेड प्राइमरी और सेकेंडरी स्कूल', 'Specific crimes': 'एक समय में एक सड़क-स्तर अपराध श्रेणी से फिल्टर करें', @@ -450,7 +456,8 @@ const descriptions: Record<string, Record<string, string>> = { '% Green': 'A Zöld Párt szavazataránya a 2024-es parlamenti választáson', '% Other parties': 'Az összes többi párt és független jelölt összesített szavazataránya', 'Distance to nearest park (km)': 'Távolság a legközelebbi parkig vagy zöldterületig', - 'Noise (dB)': 'Az út-, vasúti vagy repülőtéri zaj közül a leghangosabb az irányítószámnál, decibelben (Lden). Csak Anglia; üres = nem térképezett, nem feltétlenül csendes.', + 'Noise (dB)': + 'Az út-, vasúti vagy repülőtéri zaj közül a leghangosabb az irányítószámnál, decibelben (Lden). Csak Anglia; üres = nem térképezett, nem feltétlenül csendes.', 'Max available download speed (Mbps)': 'Az irányítószámnál elérhető maximális szélessávú letöltési sebesség', Schools: 'Közeli minősített általános és középiskolák', diff --git a/frontend/src/i18n/details.ts b/frontend/src/i18n/details.ts index 72016ed..578433b 100644 --- a/frontend/src/i18n/details.ts +++ b/frontend/src/i18n/details.ts @@ -8,7 +8,7 @@ export const details: Record<string, Record<string, string>> = { 'Property type': 'Données HM Land Registry Price Paid et certificats EPC. Maison individuelle, maison jumelée, maison mitoyenne (tous les sous-types de maisons en rangée), appartement/maisonette, ou autre type (bungalows, park homes, etc.).', 'Leasehold/Freehold': - "Données HM Land Registry Price Paid. Freehold signifie que vous possédez le bâtiment et le terrain sur lequel il se trouve. Leasehold signifie que vous possédez le bâtiment mais pas le terrain : vous détenez un bail accordé par le freeholder pour une durée déterminée.", + 'Données HM Land Registry Price Paid. Freehold signifie que vous possédez le bâtiment et le terrain sur lequel il se trouve. Leasehold signifie que vous possédez le bâtiment mais pas le terrain : vous détenez un bail accordé par le freeholder pour une durée déterminée.', 'Last known price': "Le dernier prix de vente enregistré pour ce bien provenant des données HM Land Registry Price Paid. Couvre les ventes résidentielles en Angleterre. Peut dater de plusieurs années si le bien n'a pas été vendu récemment.", 'Estimated current price': @@ -72,7 +72,7 @@ export const details: Record<string, Record<string, string>> = { 'Serious crime (avg/yr)': "Somme annuelle des violences, robberies, burglaries et possessions d'armes dans un rayon de 50 m du code postal, comptée à partir des points de criminalité street-level de police.uk (anonymisés et rattachés à des points cartographiques proches). Fournit un indicateur unique de criminalité grave.", 'Minor crime (avg/yr)': - "Somme annuelle des comportements antisociaux, shoplifting, vols de vélos et autres infractions de moindre gravité dans un rayon de 50 m du code postal, comptée à partir des points de criminalité street-level de police.uk (anonymisés et rattachés à des points cartographiques proches). Fournit un indicateur unique de criminalité mineure.", + 'Somme annuelle des comportements antisociaux, shoplifting, vols de vélos et autres infractions de moindre gravité dans un rayon de 50 m du code postal, comptée à partir des points de criminalité street-level de police.uk (anonymisés et rattachés à des points cartographiques proches). Fournit un indicateur unique de criminalité mineure.', 'Violence and sexual offences (avg/yr)': 'Nombre moyen annuel de violences et infractions sexuelles dans un rayon de 50 m du code postal, d’après les données de criminalité street-level de police.uk. Inclut les agressions, le harcèlement et les infractions sexuelles.', 'Burglary (avg/yr)': diff --git a/pipeline/check_travel_times.py b/pipeline/check_travel_times.py index 79683e2..6771e2d 100644 --- a/pipeline/check_travel_times.py +++ b/pipeline/check_travel_times.py @@ -2,9 +2,12 @@ A travel-time parquet file is considered corrupted when the R5 routing computation failed or was interrupted, leaving either zero rows or only -the origin postcode. We detect this by comparing each file's row count -against a per-mode threshold derived from the 5th-percentile of all files -in that mode. Files at or below 1 row are always flagged. +the origin postcode. We detect this by an absolute, structural criterion: +a file is corrupt only when it is unreadable or has a row count at or below +CORRUPT_ROW_FLOOR. Per-mode percentile/median/range figures are reported +for context only — they never drive the deletable set, so repeated runs +(including with --delete) are idempotent and never erode legitimate +small-catchment (rural/island) origins. Duplicates arise when places.parquet is rebuilt between R5 runs — each place gets a new numeric index prefix, so the skip-completed logic @@ -13,7 +16,6 @@ file per slug and removes the rest. Usage: uv run python pipeline/check_travel_times.py [--travel-times property-data/travel-times] - [--threshold-pct 5] [--delete] [--dedup] """ @@ -28,6 +30,12 @@ from pathlib import Path import polars as pl +# Absolute row-count floor for corruption: a readable file with this many +# rows or fewer holds at most the origin postcode (R5 failed/interrupted). +# This is a structural threshold, NOT a population percentile, so repeated +# runs are idempotent and never delete a fresh fraction of valid files. +CORRUPT_ROW_FLOOR = 1 + @dataclass class BadFile: @@ -74,10 +82,14 @@ def percentile(values: list[int], pct: float) -> float: return s[lo] + frac * (s[hi] - s[lo]) -def find_bad_files( - base_dir: Path, threshold_pct: float -) -> tuple[list[BadFile], dict[str, dict]]: - """Scan all modes and return bad files + per-mode stats.""" +def find_bad_files(base_dir: Path) -> tuple[list[BadFile], dict[str, dict]]: + """Scan all modes and return bad files + per-mode stats. + + A file is "bad" (deletable) only by an absolute structural criterion: + it is unreadable (rows < 0) or holds at most the origin postcode + (rows <= CORRUPT_ROW_FLOOR). The p5/median/min/max figures are computed + purely for reporting and do NOT influence the deletable set. + """ bad: list[BadFile] = [] stats: dict[str, dict] = {} @@ -93,15 +105,14 @@ def find_bad_files( if not row_counts: continue - p5 = percentile(row_counts, threshold_pct) + # Reporting statistics only — these never decide what gets deleted. + p5 = percentile(row_counts, 5) median = percentile(row_counts, 50) - # Threshold: max of 1 and the chosen percentile — ensures we always - # catch files with 0-1 rows even if p5 is 0 (e.g. walking mode). - threshold = max(1, int(p5)) mode_bad = [] for filename, slug, rows in entries: - if rows <= threshold: + # Corrupt = unreadable, or at/below the absolute origin-only floor. + if rows < 0 or rows <= CORRUPT_ROW_FLOOR: bf = BadFile(mode=mode, filename=filename, slug=slug, rows=rows) mode_bad.append(bf) bad.append(bf) @@ -110,7 +121,7 @@ def find_bad_files( "total": len(entries), "errors": errors, "bad": len(mode_bad), - "threshold": threshold, + "floor": CORRUPT_ROW_FLOOR, "p5": p5, "median": median, "min": min(row_counts), @@ -169,16 +180,13 @@ def main() -> None: default=Path("property-data/travel-times"), help="Path to travel-times directory", ) - parser.add_argument( - "--threshold-pct", - type=float, - default=5, - help="Percentile below which files are flagged (default: 5th)", - ) parser.add_argument( "--delete", action="store_true", - help="Delete corrupted files (so R5 will recompute them)", + help=( + "Delete corrupted files (unreadable or " + f"<= {CORRUPT_ROW_FLOOR} row) so R5 will recompute them" + ), ) parser.add_argument( "--dedup", @@ -192,18 +200,20 @@ def main() -> None: sys.exit(1) # --- Corruption check --- - bad_files, stats = find_bad_files(args.travel_times, args.threshold_pct) + bad_files, stats = find_bad_files(args.travel_times) print("=== Per-mode summary ===\n") + # Floor is the absolute deletion threshold; p5/median/range are reporting + # context only and do not affect which files are flagged as corrupt. print( - f"{'Mode':<10} {'Total':>6} {'Bad':>5} {'Threshold':>10} {'Median':>8} {'Range':>20}" + f"{'Mode':<10} {'Total':>6} {'Bad':>5} {'Floor':>6} {'P5':>8} {'Median':>8} {'Range':>20}" ) - print("-" * 65) + print("-" * 71) for mode, s in sorted(stats.items()): rng = f"{s['min']:,}–{s['max']:,}" print( - f"{mode:<10} {s['total']:>6} {s['bad']:>5} {s['threshold']:>10,} " - f"{s['median']:>8,.0f} {rng:>20}" + f"{mode:<10} {s['total']:>6} {s['bad']:>5} {s['floor']:>6,} " + f"{s['p5']:>8,.0f} {s['median']:>8,.0f} {rng:>20}" ) if bad_files: diff --git a/pipeline/download/broadband.py b/pipeline/download/broadband.py index dda2098..dc2b18b 100644 --- a/pipeline/download/broadband.py +++ b/pipeline/download/broadband.py @@ -51,8 +51,16 @@ def _obtain_zip(dest: Path) -> None: def convert_to_parquet(extract_dir: Path, parquet_path: Path) -> None: - # Find CSV files in the extracted directory - csv_files = list(extract_dir.rglob("*.csv")) + # Find CSV files in the extracted directory. The zip ships two sibling + # dirs with identical headers: postcode_files/ (all premises) and + # postcode_res_files/ (residential only). Take all-premises only so each + # postcode_space appears once; matching on the dir name keeps this + # resilient to the date-stamped top-level folder prefix. + csv_files = [ + f + for f in extract_dir.rglob("*.csv") + if "postcode_res_files" not in f.parts + ] if not csv_files: raise FileNotFoundError(f"No CSV files found in {extract_dir}") diff --git a/pipeline/download/naptan.py b/pipeline/download/naptan.py index 6c80de5..3dac4c7 100644 --- a/pipeline/download/naptan.py +++ b/pipeline/download/naptan.py @@ -17,7 +17,12 @@ TUBE_STATION_MERGE_RADIUS_DEGREES = 0.01 STOP_TYPES = { "AIR": "Airport", + # Ferry: FER/FBT are the terminal/berth nodes; FTD is a docking entrance. + "FER": "Ferry", + "FBT": "Ferry", "FTD": "Ferry", + # Rail: RLY is the station node; RSE is a station entrance. + "RLY": "Rail station", "RSE": "Rail station", "BCT": "Bus stop", "BCE": "Bus station", @@ -26,6 +31,16 @@ STOP_TYPES = { "MET": "Tube station", } +# Stop types that are access/entrance nodes rather than the primary station or +# terminal node. During dedup the primary node (e.g. RLY/FER) wins so a station +# with both a station node and entrances yields one POI at the station node. +ENTRANCE_STOP_TYPES = {"RSE", "FTD"} + +# Categories whose entrances/variants are merged into a single station-level POI +# by normalized name + area (like Tube stations), so an RLY node and its RSE +# entrances collapse to one POI at the station node. +STATION_MERGE_CATEGORIES = {TUBE_STATION_CATEGORY, "Rail station", "Ferry"} + OUTPUT_COLUMNS = ["id", "name", "category", "lat", "lng"] @@ -97,7 +112,9 @@ def _empty_output_frame() -> pl.DataFrame: ) -def station_name_score(name: str) -> tuple[int, int]: +def station_name_score(name: str, entrance: bool = False) -> tuple[int, int, int]: + # Prefer the primary station/terminal node over an entrance, then a name + # without a transport-mode suffix, then the shorter name. lower = name.lower() suffix_penalty = int( lower.endswith( @@ -112,7 +129,7 @@ def station_name_score(name: str) -> tuple[int, int]: ) ) ) - return (suffix_penalty, len(name)) + return (int(entrance), suffix_penalty, len(name)) @dataclass @@ -122,6 +139,7 @@ class StationAccumulator: category: str lat_sum: float lng_sum: float + entrance: bool = False count: int = 1 @property @@ -143,9 +161,13 @@ class StationAccumulator: self.count += 1 name = str(row["name"] or "") - if station_name_score(name) < station_name_score(self.name): + entrance = bool(row.get("entrance")) + if station_name_score(name, entrance) < station_name_score( + self.name, self.entrance + ): self.id = str(row["id"] or "") self.name = name + self.entrance = entrance def _station_from_row(row: dict[str, object]) -> StationAccumulator: @@ -155,19 +177,23 @@ def _station_from_row(row: dict[str, object]) -> StationAccumulator: category=str(row["category"] or ""), lat_sum=float(row["lat"]), lng_sum=float(row["lng"]), + entrance=bool(row.get("entrance")), ) -def _deduplicate_tube_stations(df: pl.DataFrame) -> pl.DataFrame: +def _deduplicate_station_areas(df: pl.DataFrame) -> pl.DataFrame: if len(df) == 0: return _empty_output_frame() selected: list[StationAccumulator] = [] - groups: dict[str, list[int]] = {} + groups: dict[tuple[str, str], list[int]] = {} for row in df.iter_rows(named=True): - station_key = canonical_station_name(str(row["name"] or "")) - if not station_key: + # Key by category so different modes sharing a name/area (e.g. a rail + # station and a ferry terminal) are not merged into one POI. + category = str(row["category"] or "") + station_key = (category, canonical_station_name(str(row["name"] or ""))) + if not station_key[1]: selected.append(_station_from_row(row)) continue @@ -198,7 +224,7 @@ def _deduplicate_tube_stations(df: pl.DataFrame) -> pl.DataFrame: ).select(OUTPUT_COLUMNS) -def _deduplicate_non_tube_stops(df: pl.DataFrame) -> pl.DataFrame: +def _deduplicate_local_stops(df: pl.DataFrame) -> pl.DataFrame: if len(df) == 0: return _empty_output_frame() @@ -218,7 +244,10 @@ def _deduplicate_non_tube_stops(df: pl.DataFrame) -> pl.DataFrame: .select(OUTPUT_COLUMNS) ) if len(no_loc) > 0: - frames.append(no_loc.select(OUTPUT_COLUMNS)) + # Stops with no locality can't be deduped by locality, so merge genuine + # co-located duplicates (same name+category within the same small area) + # via the station-area logic, while keeping distinct far-apart stops. + frames.append(_deduplicate_station_areas(no_loc)) if not frames: return _empty_output_frame() @@ -227,14 +256,20 @@ def _deduplicate_non_tube_stops(df: pl.DataFrame) -> pl.DataFrame: def deduplicate_naptan(df: pl.DataFrame) -> pl.DataFrame: - """Deduplicate NaPTAN stops, with station-level merging for Tube POIs.""" - tube = df.filter(pl.col("category") == TUBE_STATION_CATEGORY) - other = df.filter(pl.col("category") != TUBE_STATION_CATEGORY) + """Deduplicate NaPTAN stops, merging station/terminal entrances by area. + + Tube, rail and ferry POIs are merged to one record per station by + normalized name + area, with the primary station/terminal node (e.g. RLY, + FER) winning over an entrance node (RSE, FTD). Other stops are deduplicated + by exact name+category+locality. + """ + station = df.filter(pl.col("category").is_in(list(STATION_MERGE_CATEGORIES))) + other = df.filter(~pl.col("category").is_in(list(STATION_MERGE_CATEGORIES))) return pl.concat( [ - _deduplicate_non_tube_stops(other), - _deduplicate_tube_stations(tube), + _deduplicate_local_stops(other), + _deduplicate_station_areas(station), ] ).select(OUTPUT_COLUMNS) @@ -263,6 +298,7 @@ def download_naptan(output: Path) -> None: pl.col("Latitude").alias("lat"), pl.col("Longitude").alias("lng"), pl.col("NptgLocalityCode").alias("locality"), + pl.col("StopType").is_in(list(ENTRANCE_STOP_TYPES)).alias("entrance"), ) ) diff --git a/pipeline/download/ofsted.py b/pipeline/download/ofsted.py index 62979c5..f226053 100644 --- a/pipeline/download/ofsted.py +++ b/pipeline/download/ofsted.py @@ -1,4 +1,5 @@ import argparse +import io import tempfile import polars as pl from pathlib import Path @@ -14,10 +15,12 @@ URL = "https://assets.publishing.service.gov.uk/media/69c5269b4a06660f0854427b/M def convert_to_parquet(csv_path: Path, parquet_path: Path) -> None: print("Reading CSV...") + # The gov.uk source is cp1252-encoded; decode explicitly so non-ASCII + # school names are not corrupted (see gias.py for the same approach). + text = csv_path.read_bytes().decode("cp1252") df = pl.read_csv( - csv_path, + io.StringIO(text), infer_schema_length=10000, - encoding="utf8-lossy", null_values=["NULL", "Not applicable"], ) diff --git a/pipeline/download/places.py b/pipeline/download/places.py index 2a70c95..ffa1f56 100644 --- a/pipeline/download/places.py +++ b/pipeline/download/places.py @@ -42,6 +42,41 @@ SEARCH_PLACE_TYPES = { "island", } TRAVEL_DESTINATION_PLACE_TYPES = {"city"} + +# Named OSM highways worth surfacing as searchable streets (N). Service roads, footways, +# cycleways and motorways are deliberately excluded. +SEARCHABLE_HIGHWAY_TYPES = { + "residential", + "unclassified", + "tertiary", + "tertiary_link", + "secondary", + "secondary_link", + "primary", + "primary_link", + "trunk", + "living_street", + "pedestrian", +} + +# High-value named POIs (M) lifted from uk_pois.parquet into the gazetteer, mapped from the +# OSM "key/value" category onto a search place_type. Everyday shops/amenities are excluded. +HIGH_VALUE_POI_CATEGORIES = { + "leisure/park": "park", + "leisure/garden": "park", + "leisure/nature_reserve": "park", + "leisure/common": "park", + "tourism/attraction": "attraction", + "tourism/theme_park": "attraction", + "tourism/zoo": "attraction", + "tourism/museum": "attraction", + "tourism/gallery": "attraction", + "amenity/hospital": "hospital", + "healthcare/hospital": "hospital", + "shop/mall": "retail", + "shop/department_store": "retail", +} + ENGLAND_COUNTRY_CODE = "E92000001" LONDON_REGION_CODE = "E12000007" LONDON_LAD_PREFIX = "E09" @@ -240,6 +275,139 @@ def _slugify_name(name: str) -> str: return re.sub(r"\s+", "-", slug).strip("-") +def _street_centroid(coords: list[tuple[float, float]]) -> tuple[float, float] | None: + """Average (lat, lon) of a way's vertices.""" + if not coords: + return None + count = len(coords) + lat = sum(lat for lat, _ in coords) / count + lon = sum(lon for _, lon in coords) / count + return lat, lon + + +def _normalize_street_name(name: str) -> str: + """Grouping key for a street name: collapse whitespace, lowercase.""" + return re.sub(r"\s+", " ", name).strip().lower() + + +def _outcode_of_postcode(postcode: str) -> str: + """Outward code (everything before the space) of a postcode, e.g. 'NW1' from 'NW1 6XE'.""" + return postcode.split(" ", 1)[0] if postcode else "" + + +def _outcode_tree(postcodes_path: Path) -> tuple[cKDTree, list[str]]: + """Build a nearest-neighbour index from postcode coordinates to their outcode, so each + street can be tagged with the outcode it sits in (used to disambiguate same-named roads).""" + df = ( + pl.read_parquet( + postcodes_path, columns=["pcds", "lat", "long", "ctry25cd", "doterm"] + ) + .filter((pl.col("ctry25cd") == ENGLAND_COUNTRY_CODE) & pl.col("doterm").is_null()) + .filter(pl.col("lat").is_not_null() & pl.col("long").is_not_null()) + ) + coords = np.column_stack( + [df["lat"].to_numpy().astype(np.float64), df["long"].to_numpy().astype(np.float64)] + ) + outcodes = [_outcode_of_postcode(pc) for pc in df["pcds"].to_list()] + return cKDTree(coords), outcodes + + +def _build_street_places( + streets: list[dict], + tree: cKDTree, + outcodes: list[str], +) -> list[dict]: + """Group street segments by (normalized name, outcode), averaging centroids, so a road that + OSM splits into many segments becomes one searchable result per outcode it passes through.""" + if not streets: + return [] + + coords = np.array([[street["lat"], street["lon"]] for street in streets], dtype=np.float64) + _, indices = tree.query(coords) + + grouped: dict[tuple[str, str], dict] = {} + for street, postcode_idx in zip(streets, indices): + outcode = outcodes[postcode_idx] + key = (_normalize_street_name(street["name"]), outcode) + entry = grouped.get(key) + if entry is None: + grouped[key] = { + "name": street["name"], + "lat_sum": street["lat"], + "lon_sum": street["lon"], + "count": 1, + } + else: + entry["lat_sum"] += street["lat"] + entry["lon_sum"] += street["lon"] + entry["count"] += 1 + + places = [] + for entry in grouped.values(): + count = entry["count"] + places.append( + { + "name": entry["name"], + "place_type": "street", + "lat": entry["lat_sum"] / count, + "lon": entry["lon_sum"] / count, + "population": 0, + "travel_destination": False, + "display_city": None, + } + ) + return sorted(places, key=lambda place: place["name"].lower()) + + +def _pois_to_places(pois: pl.DataFrame) -> list[dict]: + """Map high-value named POIs onto gazetteer place rows (M), de-duplicated by (name, type).""" + if pois.is_empty(): + return [] + + seen: set[tuple[str, str]] = set() + places: list[dict] = [] + for row in pois.iter_rows(named=True): + place_type = HIGH_VALUE_POI_CATEGORIES.get(str(row.get("category", ""))) + if place_type is None: + continue + name = str(row.get("name") or "").strip() + if len(name) < 3: + continue + key = (name.lower(), place_type) + if key in seen: + continue + seen.add(key) + places.append( + { + "name": name, + "place_type": place_type, + "lat": float(row["lat"]), + "lon": float(row["lng"]), + "population": 0, + "travel_destination": False, + "display_city": None, + } + ) + return places + + +def _append_high_value_pois(places: list[dict], pois_path: Path) -> int: + pois = pl.read_parquet(pois_path, columns=["name", "category", "lat", "lng"]) + new_places = _pois_to_places(pois) + existing = { + (str(place["name"]).lower(), place["place_type"]) for place in places + } + added = 0 + for place in new_places: + key = (place["name"].lower(), place["place_type"]) + if key in existing: + continue + places.append(place) + existing.add(key) + added += 1 + return added + + def _postcode_lookup(postcodes_path: Path) -> dict[str, tuple[float, float]]: df = pl.read_parquet( postcodes_path, @@ -266,6 +434,19 @@ def _display_city_from_tags(tags: dict[str, str]) -> str | None: return None +def _parse_population(pop_str: str) -> int: + """Robustly parse OSM population tags that may carry grouping separators, + decimals, or surrounding text ("12,345", "5 000", "12345.0", "approx 5000"). + """ + # Take the integer part before any decimal point, then the first run of + # digits ignoring grouping separators (commas/spaces) and other annotations. + match = re.search(r"\d[\d,\s]*", pop_str.split(".", 1)[0]) + if match is None: + return 0 + digits = re.sub(r"\D", "", match.group(0)) + return int(digits) if digits else 0 + + def _is_london_admin_expr() -> pl.Expr: return ( (pl.col("rgn25cd") == LONDON_REGION_CODE) @@ -466,11 +647,15 @@ def _append_naptan_dlr_stations(places: list[dict], naptan_path: Path) -> int: class PlaceHandler(osmium.SimpleHandler): - def __init__(self, progress: tqdm, england_polygon) -> None: + def __init__( + self, progress: tqdm, england_polygon, *, collect_streets: bool = False + ) -> None: super().__init__() self._progress = progress self.places: list[dict] = [] + self.streets: list[dict] = [] self._england = england_polygon + self._collect_streets = collect_streets def _add( self, @@ -513,11 +698,7 @@ class PlaceHandler(osmium.SimpleHandler): if not name: return - pop_str = tags.get("population", "") - try: - population = int(pop_str) - except ValueError: - population = 0 + population = _parse_population(tags.get("population", "")) # place=* nodes place_type = tags.get("place") @@ -551,6 +732,39 @@ class PlaceHandler(osmium.SimpleHandler): ) return + def way(self, w: osmium.osm.Way) -> None: + """Collect named, searchable highways as raw segments (grouped into streets later).""" + if not self._collect_streets: + return + self._progress.update(1) + if w.tags.get("highway") not in SEARCHABLE_HIGHWAY_TYPES: + return + name = w.tags.get("name:en", w.tags.get("name", "")) + if not name: + return + + # Way node refs expose resolved .lat/.lon directly (locations=True); accessing them + # raises InvalidLocationError when a node's location is missing from the index. + coords: list[tuple[float, float]] = [] + for node in w.nodes: + try: + coords.append((node.lat, node.lon)) + except osmium.InvalidLocationError: + continue + + centroid = _street_centroid(coords) + if centroid is None: + return + lat, lon = centroid + if not ( + ENGLAND_BBOX_SOUTH <= lat <= ENGLAND_BBOX_NORTH + and ENGLAND_BBOX_WEST <= lon <= ENGLAND_BBOX_EAST + ): + return + if not self._england.contains(Point(lon, lat)): + return + self.streets.append({"name": name, "lat": lat, "lon": lon}) + def main() -> None: parser = argparse.ArgumentParser(description="Extract place names from OSM PBF") @@ -578,15 +792,28 @@ def main() -> None: "--postcodes", type=Path, help=( - "Postcode parquet used to geocode OfS university contact postcodes " - "and assign Greater London display labels" + "Postcode parquet used to geocode OfS university contact postcodes, assign " + "Greater London display labels, and tag streets with their outcode" ), ) + parser.add_argument( + "--pois", + type=Path, + help="Optional uk_pois.parquet; high-value named POIs are added to the gazetteer", + ) + parser.add_argument( + "--include-streets", + action="store_true", + help="Extract named highways as searchable streets (requires --postcodes)", + ) args = parser.parse_args() pbf_file = args.pbf england_polygon = load_england_polygon(args.boundary) + if args.include_streets and not args.postcodes: + raise ValueError("--postcodes is required with --include-streets") + print("Extracting search place nodes + railway stations") with tqdm( unit=" elements", @@ -595,10 +822,21 @@ def main() -> None: smoothing=0.05, mininterval=1.0, ) as progress: - handler = PlaceHandler(progress, england_polygon) + handler = PlaceHandler( + progress, england_polygon, collect_streets=args.include_streets + ) handler.apply_file(str(pbf_file), locations=True) print(f"Extracted {len(handler.places):,} place nodes") + if args.include_streets: + print(f"Collected {len(handler.streets):,} named street segments") + tree, outcodes = _outcode_tree(args.postcodes) + street_places = _build_street_places(handler.streets, tree, outcodes) + handler.places.extend(street_places) + print(f"Added {len(street_places):,} grouped streets") + if args.pois: + added = _append_high_value_pois(handler.places, args.pois) + print(f"Added {added:,} high-value POIs from {args.pois}") if args.naptan: added = _append_naptan_dlr_stations(handler.places, args.naptan) print(f"Added {added:,} DLR station destinations from NaPTAN") diff --git a/pipeline/download/test_naptan.py b/pipeline/download/test_naptan.py index 5c5875e..172a561 100644 --- a/pipeline/download/test_naptan.py +++ b/pipeline/download/test_naptan.py @@ -89,3 +89,92 @@ def test_deduplicate_naptan_does_not_merge_missing_locality_bus_stops(): result = deduplicate_naptan(df) assert len(result) == 2 + + +def test_deduplicate_naptan_merges_colocated_missing_locality_bus_stations(): + # Two NaPTAN records for the same bus station with no locality, co-located + # within the merge area, are a true duplicate and collapse to one POI. + df = pl.DataFrame( + { + "id": ["a", "b"], + "name": ["Victoria Bus Station", "Victoria Bus Station"], + "category": ["Bus station", "Bus station"], + "lat": [51.4952, 51.4953], + "lng": [-0.1441, -0.1440], + "locality": [None, None], + } + ) + + result = deduplicate_naptan(df) + + assert len(result) == 1 + assert result["name"][0] == "Victoria Bus Station" + assert result["category"][0] == "Bus station" + assert result["lat"][0] == pytest.approx((51.4952 + 51.4953) / 2) + + +def test_deduplicate_naptan_keeps_rail_station_with_only_station_node(): + # Aberdare's only NaPTAN record is an RLY station node (StopType "RLY"). + df = pl.DataFrame( + { + "id": ["aberdare-rly"], + "name": ["Aberdare Rail Station"], + "category": ["Rail station"], + "lat": [51.7155], + "lng": [-3.4438], + "locality": ["ABERDARE"], + "entrance": [False], + } + ) + + result = deduplicate_naptan(df) + + assert len(result) == 1 + assert result["name"][0] == "Aberdare Rail Station" + assert result["category"][0] == "Rail station" + + +def test_deduplicate_naptan_merges_rail_entrances_into_station_node(): + # A station node (RLY) and its two entrance nodes (RSE) collapse to a single + # "Rail station" POI represented by the station node, not an entrance. + df = pl.DataFrame( + { + "id": ["clapham-rly", "clapham-rse-a", "clapham-rse-b"], + "name": [ + "Clapham Junction Rail Station", + "Clapham Junction Rail Station", + "Clapham Junction Rail Station", + ], + "category": ["Rail station", "Rail station", "Rail station"], + "lat": [51.4642, 51.4644, 51.4640], + "lng": [-0.1705, -0.1702, -0.1708], + "locality": ["CLAPHAM", "CLAPHAM", "CLAPHAM"], + "entrance": [False, True, True], + } + ) + + result = deduplicate_naptan(df) + + assert len(result) == 1 + assert result["id"][0] == "clapham-rly" + assert result["category"][0] == "Rail station" + + +def test_deduplicate_naptan_does_not_merge_rail_and_ferry_in_same_area(): + # Different transport modes sharing a name/area stay as separate POIs. + df = pl.DataFrame( + { + "id": ["harbour-rail", "harbour-ferry"], + "name": ["Harbour Station", "Harbour Station"], + "category": ["Rail station", "Ferry"], + "lat": [51.5, 51.5001], + "lng": [-0.1, -0.1001], + "locality": ["HARBOUR", "HARBOUR"], + "entrance": [False, False], + } + ) + + result = deduplicate_naptan(df).sort("category") + + assert len(result) == 2 + assert result["category"].to_list() == ["Ferry", "Rail station"] diff --git a/pipeline/download/test_noise.py b/pipeline/download/test_noise.py index 2bd5d5e..ab5a01d 100644 --- a/pipeline/download/test_noise.py +++ b/pipeline/download/test_noise.py @@ -2,14 +2,32 @@ import httpx import numpy as np import pytest import rasterio +from rasterio.io import MemoryFile from rasterio.transform import from_origin from pipeline.download import noise +def _tiny_geotiff_bytes() -> bytes: + data = np.array([[55]], dtype=np.uint8) + with MemoryFile() as memfile: + with memfile.open( + driver="GTiff", + height=data.shape[0], + width=data.shape[1], + count=1, + dtype=data.dtype, + crs="EPSG:27700", + transform=from_origin(0, 1, 1, 1), + ) as dataset: + dataset.write(data, 1) + return bytes(memfile.getbuffer()) + + def test_download_tile_splits_after_retries(monkeypatch, tmp_path): monkeypatch.setattr(noise, "MAX_RETRIES", 1) monkeypatch.setattr(noise, "MIN_TILE_SIZE", 50) + tile_bytes = _tiny_geotiff_bytes() def fake_fetch_tile_bytes( wcs_base, @@ -22,7 +40,7 @@ def test_download_tile_splits_after_retries(monkeypatch, tmp_path): ): if max_e - min_e > 50 or max_n - min_n > 50: raise httpx.TimeoutException("too large") - return b"II*\x00fake-tiff" + return tile_bytes monkeypatch.setattr(noise, "_fetch_tile_bytes", fake_fetch_tile_bytes) diff --git a/pipeline/download/test_places.py b/pipeline/download/test_places.py index 058ac34..30ae9ec 100644 --- a/pipeline/download/test_places.py +++ b/pipeline/download/test_places.py @@ -1,15 +1,22 @@ +import numpy as np import polars as pl from pyproj import Transformer +from scipy.spatial import cKDTree from pipeline.download.places import ( _assign_london_display_city, + _build_street_places, _display_city_from_tags, _is_dlr_station, _is_tram_station, _naptan_dlr_stations, + _normalize_street_name, _ofs_universities, + _outcode_of_postcode, + _pois_to_places, _select_university_name, _station_display_name, + _street_centroid, ) WGS84_TO_BNG = Transformer.from_crs("EPSG:4326", "EPSG:27700", always_xy=True) @@ -168,6 +175,73 @@ def test_ofs_universities_extracts_university_title_rows_with_postcode_coords(): ] +def test_street_centroid_averages_vertices(): + assert _street_centroid([(51.0, -0.1), (53.0, -0.3)]) == (52.0, -0.2) + assert _street_centroid([]) is None + + +def test_normalize_street_name_and_outcode(): + assert _normalize_street_name(" High Street ") == "high street" + assert _outcode_of_postcode("NW1 6XE") == "NW1" + assert _outcode_of_postcode("") == "" + + +def test_build_street_places_groups_segments_by_name_and_outcode(): + # Two postcodes: NW1 (north) and CR0 (south). + tree = cKDTree(np.array([[51.53, -0.14], [51.37, -0.10]], dtype=np.float64)) + outcodes = ["NW1", "CR0"] + + streets = [ + {"name": "High Street", "lat": 51.531, "lon": -0.141}, # NW1 + {"name": "High Street", "lat": 51.529, "lon": -0.139}, # NW1 (same road, 2nd segment) + {"name": "High Street", "lat": 51.371, "lon": -0.101}, # CR0 (different road, same name) + {"name": "Baker Street", "lat": 51.5305, "lon": -0.1405}, # NW1 + ] + + places = _build_street_places(streets, tree, outcodes) + + # 3 distinct streets: High Street/NW1 (2 segments merged), High Street/CR0, Baker Street/NW1. + assert len(places) == 3 + assert all(place["place_type"] == "street" for place in places) + + nw1_high = next( + place + for place in places + if place["name"] == "High Street" and place["lat"] > 51.5 + ) + assert nw1_high["lat"] == (51.531 + 51.529) / 2 + assert nw1_high["lon"] == (-0.141 + -0.139) / 2 + # The same-named CR0 road stays separate. + assert any( + place["name"] == "High Street" and place["lat"] < 51.4 for place in places + ) + + +def test_pois_to_places_keeps_high_value_named_pois_only(): + pois = pl.DataFrame( + { + "name": ["Hyde Park", "St Thomas' Hospital", "Joe's Cafe", "Hyde Park", ""], + "category": [ + "leisure/park", + "amenity/hospital", + "amenity/cafe", # everyday amenity → excluded + "leisure/park", # duplicate → excluded + "leisure/park", # empty name → excluded + ], + "lat": [51.507, 51.498, 51.5, 51.507, 51.6], + "lng": [-0.165, -0.118, -0.1, -0.165, -0.2], + } + ) + + places = _pois_to_places(pois) + + assert [(place["name"], place["place_type"]) for place in places] == [ + ("Hyde Park", "park"), + ("St Thomas' Hospital", "hospital"), + ] + assert all(place["travel_destination"] is False for place in places) + + def test_display_city_from_tags_uses_explicit_london_context(): assert _display_city_from_tags({"is_in": "Croydon, London, UK"}) == "London" assert _display_city_from_tags({"is_in": "Croydon, Cambridgeshire, UK"}) is None diff --git a/pipeline/download/transit_network.py b/pipeline/download/transit_network.py index a7d384b..bbb576f 100644 --- a/pipeline/download/transit_network.py +++ b/pipeline/download/transit_network.py @@ -307,9 +307,14 @@ def convert_high_freq_to_frequency_based( print(f" Found {len(trip_group_key)} trips on target routes") - # Step 3: Get first departure time and first stop for each target trip + # Step 3: Get first departure time and first stop for each target trip. + # GTFS only requires stop_sequence to be strictly increasing per trip; it + # is NOT required to start at 0 (1-based numbering is common, and BODS is + # consumed raw here without renumbering). So pick the row with the minimum + # stop_sequence per trip rather than keying off the literal "0". trip_first_dep: dict[str, int] = {} trip_first_stop: dict[str, str] = {} + trip_min_seq: dict[str, int] = {} with zin.open("stop_times.txt") as f: cols = _parse_csv_line(f.readline()) trip_id_idx = cols.index("trip_id") @@ -323,11 +328,25 @@ def convert_high_freq_to_frequency_based( trip_id = parts[trip_id_idx].strip('"') if trip_id not in trip_group_key: continue - if parts[seq_idx].strip('"') == "0": - dep_secs = _parse_gtfs_time(parts[dep_idx]) - if dep_secs is not None: - trip_first_dep[trip_id] = dep_secs - trip_first_stop[trip_id] = parts[stop_id_idx].strip('"') + try: + seq = int(parts[seq_idx].strip('"')) + except ValueError: + continue + if trip_id in trip_min_seq and seq >= trip_min_seq[trip_id]: + continue + dep_secs = _parse_gtfs_time(parts[dep_idx]) + if dep_secs is None: + continue + trip_min_seq[trip_id] = seq + trip_first_dep[trip_id] = dep_secs + trip_first_stop[trip_id] = parts[stop_id_idx].strip('"') + + if trip_group_key and not trip_first_dep: + raise RuntimeError( + "convert_high_freq_to_frequency_based found no first stops for " + f"{len(trip_group_key)} target trips; stop_times.txt may be malformed " + "or stop_sequence parsing failed" + ) # Step 4: Group trips by (route, direction, service, first_stop) and compute headways groups: dict[tuple[str, ...], list[tuple[str, int]]] = defaultdict(list) diff --git a/pipeline/transform/crime.py b/pipeline/transform/crime.py index 9dfbafa..c62db81 100644 --- a/pipeline/transform/crime.py +++ b/pipeline/transform/crime.py @@ -95,11 +95,14 @@ def transform_crime( f"({valid_months[0]} to {valid_months[-1]})" ) - # Count monthly incidents, then annualise over every valid month in the dataset. - # `_weight` (≤1) comes from the LSOA 2011→2021 lookup: 2011 LSOAs that split - # into N 2021 LSOAs contribute 1/N of their count to each child, since we - # don't know which child a given incident actually belonged to. - yearly_counts = ( + # Annualise each year separately (count_in_year * 12 / months_in_year), then + # take the simple mean of those per-year rates over the years each type is + # present. This makes the headline equal the average of the by-year chart bars + # (_write_crime_by_year) instead of a month-weighted pooled rate, mirroring + # crime_spatial._write_avg_yr. `_weight` (≤1) comes from the LSOA 2011→2021 + # lookup: 2011 LSOAs that split into N 2021 LSOAs contribute 1/N of their count + # to each child, since we don't know which child an incident actually belonged to. + filtered = ( df.filter( valid_month_expr & pl.col("LSOA code").is_not_null() @@ -107,15 +110,31 @@ def transform_crime( & pl.col("Crime type").is_not_null() & (pl.col("Crime type") != "") ) - .with_columns(pl.col("Crime type").replace(LEGACY_CRIME_TYPE_ALIASES)) - .group_by("LSOA code", "Month", "Crime type") - .agg((pl.col("_weight").first() * pl.len()).alias("count")) - .group_by("LSOA code", "Crime type") - .agg( - (pl.col("count").sum() / pl.lit(valid_month_count) * 12) - .round(1) - .alias("yearly_avg") + .with_columns( + pl.col("Month").str.slice(0, 4).cast(pl.Int32).alias("year"), + pl.col("Crime type").replace(LEGACY_CRIME_TYPE_ALIASES), ) + ) + + # Months observed *anywhere* in the dataset for each year (annualisation + # denominator), matching the by-year output's per-year scaling. + months_per_year = filtered.group_by("year").agg( + pl.col("Month").n_unique().alias("months_in_year") + ) + + yearly_counts = ( + filtered.group_by("LSOA code", "year", "Crime type", "Month") + .agg((pl.col("_weight").first() * pl.len()).alias("count")) + .group_by("LSOA code", "year", "Crime type") + .agg(pl.col("count").sum().alias("count")) + .join(months_per_year, on="year") + .with_columns( + (pl.col("count") * 12.0 / pl.col("months_in_year")).alias("per_year") + ) + # Mean of the per-year annualised rates over the years the type is present + # (only years with rows are grouped here, so this is the correct x-span). + .group_by("LSOA code", "Crime type") + .agg(pl.col("per_year").mean().round(1).alias("yearly_avg")) .collect(engine="streaming") ) if yearly_counts.is_empty(): diff --git a/pipeline/transform/crime_spatial.py b/pipeline/transform/crime_spatial.py index 0c41284..b1a4de7 100644 --- a/pipeline/transform/crime_spatial.py +++ b/pipeline/transform/crime_spatial.py @@ -259,11 +259,14 @@ def _write_avg_yr( """ months = np.array([months_in_year[year] for year in years], dtype=np.float64) per_year = counts.astype(np.float64) * 12.0 / months[None, None, :] - # Average over the years each type is actually observed anywhere -- the same - # per-type x-span the by-year chart plots (server-rs/.../crime_by_year.rs). - type_year_present = counts.sum(axis=0) > 0 # (n_types, n_years) - years_per_type = np.clip(type_year_present.sum(axis=1), 1, None).astype(np.float64) - avg = per_year.sum(axis=2) / years_per_type[None, :] # (n_postcodes, n_types) + # Average over the years *this postcode* actually has incidents of *this + # type* -- the same per-(postcode, type) x-span the by-year chart plots + # (server-rs/.../crime_by_year.rs), so the headline equals the mean of the + # by-year bars. Dividing by a global years-present count (years a type + # appeared anywhere in England) would deflate postcodes whose incidents + # cluster in only a few years of the ~13-year window. + years_present = np.clip((counts > 0).sum(axis=2), 1, None).astype(np.float64) + avg = per_year.sum(axis=2) / years_present # (n_postcodes, n_types) avg = np.round(avg * norm[:, None], 1).astype(np.float32) data: dict[str, np.ndarray] = {"postcode": postcodes} diff --git a/pipeline/transform/join_epc_pp.py b/pipeline/transform/join_epc_pp.py index 873f65d..dc34bb3 100644 --- a/pipeline/transform/join_epc_pp.py +++ b/pipeline/transform/join_epc_pp.py @@ -365,6 +365,16 @@ def _run(epc_path: Path, price_paid_path: Path, output_path: Path, temp_dir: Pat } duration_map = {"F": "Freehold", "L": "Leasehold"} + # price >= MIN_PRICE and ppd_category == "A" (standard open-market sale) are + # VALUE-QUALITY filters: they gate the price aggregations only. Category B + # entries (repossessions, bulk/portfolio, power-of-sale transfers) and sub-MIN + # sales must not pollute latest_price / historical_prices (and the downstream + # price-per-sqm feature), but they MUST still count for first_transfer_date / + # old_new so a new-build's genuine earliest transfer year is preserved. + price_ok = pl.col("price") >= MIN_PRICE + category_ok = pl.col("ppd_category") == "A" + quality_ok = price_ok & category_ok + price_paid = ( pl.scan_parquet(price_paid_path) .select( @@ -381,9 +391,9 @@ def _run(epc_path: Path, price_paid_path: Path, output_path: Path, temp_dir: Pat "town_city", pl.col("duration").replace(duration_map), "old_new", + "ppd_category", ) .filter(pl.col("pp_property_type") != "Other") - .filter(pl.col("price") >= MIN_PRICE) .with_columns( pl.concat_str( [pl.col("saon"), pl.col("paon"), pl.col("street")], @@ -408,18 +418,26 @@ def _run(epc_path: Path, price_paid_path: Path, output_path: Path, temp_dir: Pat pl.col("postcode").last(), pl.col("_pp_match_address").last(), pl.col("_pp_match_postcode").last(), + # Price aggregations are restricted to quality-passing sales. pl.struct( pl.col("date_of_transfer").dt.year().alias("year"), pl.col("date_of_transfer").dt.month().cast(pl.UInt8).alias("month"), "price", - ).alias("historical_prices"), + ) + .filter(quality_ok) + .alias("historical_prices"), pl.col("pp_property_type").last(), pl.col("duration").last(), - pl.col("price").last().alias("latest_price"), - pl.col("date_of_transfer").last(), + pl.col("price").filter(quality_ok).last().alias("latest_price"), + pl.col("date_of_transfer").filter(quality_ok).last(), + # first_transfer_date / old_new reflect the genuine earliest transfer + # over the full per-group transaction stream (not value-filtered). pl.col("date_of_transfer").first().alias("first_transfer_date"), pl.col("old_new").first(), ) + # Preserve the property universe: previously a property needed >=1 sale + # >=MIN_PRICE to form a group, so drop groups with no quality-passing sale. + .filter(pl.col("latest_price").is_not_null()) ) print("Price paid dataset") diff --git a/pipeline/transform/merge.py b/pipeline/transform/merge.py index d544e4d..a6d18f8 100644 --- a/pipeline/transform/merge.py +++ b/pipeline/transform/merge.py @@ -839,25 +839,36 @@ def _join_area_side_tables( # Crime is counted spatially per postcode (incidents within 50m of the # postcode boundary), so it joins on postcode rather than LSOA. base = base.join(crime, on="postcode", how="left") + serious_crime_cols = [ + "Violence and sexual offences (avg/yr)", + "Robbery (avg/yr)", + "Burglary (avg/yr)", + "Possession of weapons (avg/yr)", + ] + minor_crime_cols = [ + "Anti-social behaviour (avg/yr)", + "Criminal damage and arson (avg/yr)", + "Shoplifting (avg/yr)", + "Bicycle theft (avg/yr)", + "Theft from the person (avg/yr)", + "Other theft (avg/yr)", + "Vehicle crime (avg/yr)", + "Public order (avg/yr)", + "Drugs (avg/yr)", + "Other crime (avg/yr)", + ] + # The LEFT join leaves every per-type column null for postcodes absent from + # the crime table; sum_horizontal alone would fabricate a "zero crime" + # rollup there, so keep the rollup null when ALL components are null. base = base.with_columns( - pl.sum_horizontal( - "Violence and sexual offences (avg/yr)", - "Robbery (avg/yr)", - "Burglary (avg/yr)", - "Possession of weapons (avg/yr)", - ).alias("serious_crime_avg_yr"), - pl.sum_horizontal( - "Anti-social behaviour (avg/yr)", - "Criminal damage and arson (avg/yr)", - "Shoplifting (avg/yr)", - "Bicycle theft (avg/yr)", - "Theft from the person (avg/yr)", - "Other theft (avg/yr)", - "Vehicle crime (avg/yr)", - "Public order (avg/yr)", - "Drugs (avg/yr)", - "Other crime (avg/yr)", - ).alias("minor_crime_avg_yr"), + pl.when(pl.all_horizontal([pl.col(c).is_null() for c in serious_crime_cols])) + .then(None) + .otherwise(pl.sum_horizontal(serious_crime_cols)) + .alias("serious_crime_avg_yr"), + pl.when(pl.all_horizontal([pl.col(c).is_null() for c in minor_crime_cols])) + .then(None) + .otherwise(pl.sum_horizontal(minor_crime_cols)) + .alias("minor_crime_avg_yr"), ) base = base.join(median_age, on="lsoa21", how="left") @@ -1179,7 +1190,22 @@ def _load_listings_for_merge(listings_path: Path, arcgis_path: Path) -> pl.DataF # pages); tolerate its absence so older parquets and test fixtures still # load. Digits-only so it compares equal to the EPC register's UPRN. if "UPRN" in raw.collect_schema().names(): - uprn_digits = pl.col("UPRN").cast(pl.Utf8).str.replace_all(r"\D", "") + # Mirror `_normalize_uprn` exactly so the listing key compares equal to + # the candidate-side key for every dtype. For a Float UPRN we must + # stringify via its integer form (100023336956.0 -> "100023336956"), + # otherwise stripping non-digits from "100023336956.0" yields a bogus + # trailing-zero key ("1000233369560") that never collides; and a + # non-integral float (e.g. 1.5) must be rejected rather than mangled. + uprn_col = pl.col("UPRN") + if raw.collect_schema()["UPRN"].is_float(): + integral = uprn_col.cast(pl.Int64, strict=False) + uprn_digits = ( + pl.when(integral == uprn_col) + .then(integral.cast(pl.Utf8).str.replace_all(r"\D", "")) + .otherwise(None) + ) + else: + uprn_digits = uprn_col.cast(pl.Utf8).str.replace_all(r"\D", "") listing_uprn_expr = ( pl.when(uprn_digits.str.len_chars() > 0) .then(uprn_digits) @@ -1615,9 +1641,23 @@ def _enrich_listings_with_direct_epc( def _coalesce_direct_epc_columns(wide: pl.LazyFrame) -> pl.LazyFrame: + def _coalesced(raw_column: str, direct_column: str) -> pl.Expr: + coalesce = pl.coalesce(pl.col(raw_column), pl.col(direct_column)) + # The raw property-level value is fill_null("No") upstream, so a plain + # coalesce lets a non-null "No" override a directly-matched listing + # "Yes". "Former council house" should fire if EITHER side says so. + if raw_column == "was_council_house": + return ( + pl.when((pl.col(raw_column) == "Yes") | (pl.col(direct_column) == "Yes")) + .then(pl.lit("Yes")) + .otherwise(coalesce) + .alias(raw_column) + ) + return coalesce.alias(raw_column) + return wide.with_columns( [ - pl.coalesce(pl.col(raw_column), pl.col(direct_column)).alias(raw_column) + _coalesced(raw_column, direct_column) for raw_column, direct_column in _DIRECT_EPC_RAW_COLUMN_MAP.items() ] ) diff --git a/pipeline/transform/poi_proximity.py b/pipeline/transform/poi_proximity.py index 8d970fb..d062397 100644 --- a/pipeline/transform/poi_proximity.py +++ b/pipeline/transform/poi_proximity.py @@ -12,11 +12,19 @@ from pipeline.utils.poi_counts import count_pois_per_postcode, min_distance_per_ # POI category groups for proximity counting (2km radius). # Names must match the friendly names produced by transform_poi.py / naptan.py. +# "groceries" is filled in dynamically by _groceries_categories() because the +# GEOLYTIX dataset stores the brand (e.g. "Tesco", "Aldi") in `category` rather +# than the literal "Supermarket"; counting only the OSM strings here severely +# understates the metric. See _groceries_categories below. POI_GROUPS_2KM = { "restaurants": ["Restaurant", "Fast Food"], - "groceries": ["Greengrocer", "Supermarket", "Convenience Store"], } +# POI group whose members are counted for the static "groceries" 2km metric. +# Covers both the OSM grocery categories (Supermarket, Convenience Store, +# Greengrocer, ...) and the GEOLYTIX brand categories (Tesco, Aldi, ...). +GROCERIES_GROUP = "Groceries" + # OS Open Greenspace function types used for park counts and distance calculation. # Uses the authoritative OS dataset instead of OSM point POIs for better coverage # of green spaces that are only mapped as polygons in OSM. @@ -41,6 +49,26 @@ def _poi_category_slug(category: str) -> str: return slug or "poi" +def _groceries_categories(pois: pl.DataFrame) -> list[str]: + """Return the distinct `category` values for the Groceries group. + + `count_pois_per_postcode` matches POIs on `category`, but the authoritative + GEOLYTIX grocery dataset stores the brand name there (e.g. "Tesco", "Aldi") + with group "Groceries"; it never emits the literal "Supermarket". Collecting + every Groceries category captures both the OSM strings and the brand names. + """ + if "group" not in pois.columns: + raise ValueError("POI dataframe must include a 'group' column") + return ( + pois.filter(pl.col("group") == GROCERIES_GROUP) + .select("category") + .unique() + .sort("category") + .to_series() + .to_list() + ) + + def _build_poi_category_groups( pois: pl.DataFrame, ) -> tuple[dict[str, list[str]], dict[str, str]]: @@ -122,9 +150,15 @@ def main(): pois = pl.read_parquet(args.pois) poi_category_groups, poi_display_names = _build_poi_category_groups(pois) - # Count static amenity groups within 2km. + # Count static amenity groups within 2km. "groceries" is matched against + # every Groceries category (OSM strings + GEOLYTIX brand names) so that + # postcodes ringed by GEOLYTIX-only chains (Tesco, Aldi, ...) are counted. + groups_2km = { + **POI_GROUPS_2KM, + "groceries": _groceries_categories(pois), + } counts_2km = count_pois_per_postcode( - postcodes, pois, groups=POI_GROUPS_2KM, radius_km=2 + postcodes, pois, groups=groups_2km, radius_km=2 ) # Dynamic amenity filters: nearest distance plus counts within 2km and 5km for diff --git a/pipeline/transform/postcode_boundaries/README.md b/pipeline/transform/postcode_boundaries/README.md index 0d98651..01d6181 100644 --- a/pipeline/transform/postcode_boundaries/README.md +++ b/pipeline/transform/postcode_boundaries/README.md @@ -77,9 +77,9 @@ The output of `process_oa` is `list[(postcode, polygon)]` — the per-OA fragmen ### Phase 4: Merging and writing -**Fragment merging** (`output.py:merge_fragments`): Groups all fragments by postcode, unions them. If the result is a MultiPolygon (meaning the postcode has disconnected pieces — either from spanning OAs with a gap, or algorithm artifacts), applies a 5m buffer-then-unbuffer to close tiny gaps from floating-point mismatches at OA boundary edges. If still a MultiPolygon after that, keeps only the largest polygon — postcodes are contiguous delivery routes, so detached fragments are artifacts. +**Fragment merging** (`output.py:merge_fragments`): Groups all fragments by postcode, unions them. If the result is a MultiPolygon (meaning the postcode has disconnected pieces — either from spanning OAs with a gap, or algorithm artifacts), applies a 5m buffer-then-unbuffer to close tiny gaps from floating-point mismatches at OA boundary edges. If still a MultiPolygon after that, keeps the largest part **plus any other part ≥ `_MIN_DETACHED_PART_AREA` (100 m²)** (`_keep_polygon_parts`); only sub-100 m² noise slivers are dropped. Keeping substantial detached parts matters because a postcode genuinely split across an OA seam (by a railway, river, or main road wider than the 5m buffer) would otherwise lose a chunk — measured at ~1.8% of merged area left as uncovered gaps (often 3000–5000 m² building blocks) before this change. -**GeoJSON output** (`output.py:write_district_geojson`): Groups postcodes by district (the outward code, e.g. `SW1A` from `SW1A 1AA`). For each district, converts every postcode polygon from BNG to WGS84 using pyproj, simplifies with 1m tolerance (Douglas-Peucker), rounds coordinates to 6 decimal places (~0.1m precision), and writes a single `{district}.geojson` FeatureCollection. Each Feature has `postcodes` (formatted like `"SW1A 1AA"`) and `mapit_code` (no space: `"SW1A1AA"`) in its properties. +**GeoJSON output** (`output.py:write_district_geojson`): Two passes. Pass 1 converts every postcode from BNG to WGS84 (pyproj), simplifies with 1m tolerance (Douglas-Peucker), and snaps to 6 decimal places (~0.1m precision); multi-part postcodes become `MultiPolygon` (`to_wgs84_geojson_multi`, each part handled independently), single-part stay `Polygon`. The whole set is then made a **partition** (`_resolve_overlaps`): each postcode is trimmed by the union of its higher-priority overlapping neighbours, where **priority = ascending area** (smaller postcodes win contested ground). That single rule handles both seam overlap *and* containment — an enclosed postcode is always smaller than its container, so it keeps its area while the container gets a hole (the query uses both the `overlaps` and `contains` predicates, since `overlaps` alone excludes containment). This runs last, so nothing re-introduces overlap; a postcode that would be emptied keeps its original geometry, so no active postcode is dropped. Pass 2 groups postcodes by district (the outward code, e.g. `SW1A` from `SW1A 1AA`), rounds coordinates to 6dp, and writes a `{district}.geojson` FeatureCollection. Each Feature has `postcodes` (formatted like `"SW1A 1AA"`) and `mapit_code` (no space: `"SW1A1AA"`) in its properties. ## Memory architecture @@ -103,10 +103,10 @@ Key design choices: ## Key invariants -1. **Every square meter of every OA is assigned to exactly one postcode** — the combination of INSPIRE claiming + Voronoi fills the entire OA, and overlap resolution ensures no double-counting +1. **No two postcodes cover the same ground in the output** — within an OA the INSPIRE claiming + Voronoi tile it with no overlap, and a final `_resolve_overlaps` partition pass removes the thin overlap strips that the merge buffer + per-postcode simplification introduce across OA seams (measured residual overlap ~0.01% of area) 2. **Every postcode that exists in the UPRN data gets a polygon** — unless all its UPRNs share coordinates with another postcode's UPRNs (handled by jitter) or it has zero UPRNs 3. **Postcode polygons never extend outside their OA(s)** — all geometry is clipped to OA boundaries -4. **Output is always single Polygon, never MultiPolygon** — the largest-polygon extraction in both `merge_fragments` and `to_wgs84_geojson` ensures this +4. **A postcode split across an OA seam keeps all its substantial parts** — `merge_fragments` keeps every part ≥ 100 m² and the output is emitted as a `MultiPolygon` (the Rust server `postcodes.rs` and `loader.py` both parse MultiPolygon); only sub-100 m² noise slivers are dropped ## Module structure diff --git a/pipeline/transform/postcode_boundaries/__main__.py b/pipeline/transform/postcode_boundaries/__main__.py index 70a70dd..c48b664 100644 --- a/pipeline/transform/postcode_boundaries/__main__.py +++ b/pipeline/transform/postcode_boundaries/__main__.py @@ -1,12 +1,21 @@ import argparse +import multiprocessing as mp +import os from pathlib import Path +import numpy as np +import shapely from shapely.geometry import MultiPolygon, Polygon from tqdm import tqdm +from .fragments_cache import ( + fragments_cache_is_fresh, + load_fragments, + save_fragments, +) from .inspire import ( + build_inspire_index, cache_inspire, - get_inspire_candidates, inspire_cache_exists, load_inspire, ) @@ -14,7 +23,206 @@ from .memory import release_memory from .oa_boundaries import load_oa_boundaries from .output import merge_fragments, write_district_geojson from .process_oa import process_oa -from .uprn import get_oa_uprns, load_uprns +from .uprn import extract_uprn_arrays, get_oa_uprns_arrays, load_uprns + +Fragment = tuple[str, Polygon | MultiPolygon] + + +def _oa_fragments( + oa_code, oa_geoms, east, north, postcodes_arr, offsets, index +) -> tuple[list[Fragment], bool]: + """Process one OA into ``(postcode, geometry)`` fragments. + + Returns ``(fragments, is_single)``; ``is_single`` flags the single-postcode + fast path. Shared by the sequential and parallel drivers so both produce + identical output. Any failure is re-raised tagged with the OA code so a single + bad OA is attributable instead of an anonymous worker abort hours in. + """ + try: + oa_geom = oa_geoms[oa_code] + points, postcodes = get_oa_uprns_arrays( + east, north, postcodes_arr, offsets, oa_code + ) + if len(set(postcodes)) == 1: + return [(postcodes[0], oa_geom)], True + candidates = index.candidates(oa_geom.bounds) + return process_oa(oa_geom, points, postcodes, candidates), False + except Exception as exc: + raise RuntimeError(f"Failed processing OA {oa_code}: {exc!r}") from exc + + +# Worker-shared state. Populated in the parent before the pool forks; children +# inherit it copy-on-write (the numpy/Arrow buffers + coords mmap stay shared, +# never duplicated per worker). Read-only in workers. +_WORKER_STATE: dict = {} + + +def _process_oa_chunk(oa_codes: list[str]): + """Worker: turn a chunk of OA codes into WKB-encoded fragments. + + Geometries are returned as WKB (compact and lossless) rather than pickled + Shapely objects, to keep the IPC payload small. + """ + state = _WORKER_STATE + frags: list[Fragment] = [] + single = 0 + for oa_code in oa_codes: + oa_frags, is_single = _oa_fragments( + oa_code, + state["oa_geoms"], + state["east"], + state["north"], + state["postcodes"], + state["offsets"], + state["index"], + ) + frags.extend(oa_frags) + single += is_single + + if frags: + pcs = [pc for pc, _ in frags] + wkb = shapely.to_wkb(np.array([g for _, g in frags], dtype=object)) + else: + pcs, wkb = [], np.empty(0, dtype=object) + return pcs, wkb, single, len(oa_codes) + + +def _resolve_workers(requested: int) -> int: + """Worker count: the explicit value if >0, otherwise all available CPUs.""" + if requested and requested > 0: + return requested + try: + return max(1, len(os.sched_getaffinity(0))) + except AttributeError: + return max(1, os.cpu_count() or 1) + + +def _process_oas( + oa_codes, oa_geoms, east, north, postcodes_arr, offsets, index, workers +) -> tuple[list[Fragment], int]: + """Drive Phase 3 over every OA, fanning out across `workers` processes. + + OAs are independent, so the loop parallelises cleanly. ``fork`` lets workers + share the big read-only inputs (INSPIRE arrays + coords mmap, UPRN arrays, OA + geometries) copy-on-write instead of duplicating ~2GB each. Fragment order + does not affect the result (``merge_fragments`` unions per postcode), so + chunks are collected as they finish. Returns ``(fragments, single_count)``. + """ + all_fragments: list[Fragment] = [] + single_count = 0 + + if workers <= 1 or "fork" not in mp.get_all_start_methods(): + for oa_code in tqdm( + oa_codes, desc="Processing OAs", unit="OA", smoothing=0.01, miniters=100 + ): + oa_frags, is_single = _oa_fragments( + oa_code, oa_geoms, east, north, postcodes_arr, offsets, index + ) + all_fragments.extend(oa_frags) + single_count += is_single + return all_fragments, single_count + + _WORKER_STATE.update( + oa_geoms=oa_geoms, + east=east, + north=north, + postcodes=postcodes_arr, + offsets=offsets, + index=index, + ) + # Many small contiguous chunks → dynamic load balancing across workers (rural + # OAs cost far more than urban ones) while preserving mmap read locality. + chunk_size = max(1, len(oa_codes) // (workers * 16)) + chunks = [oa_codes[i : i + chunk_size] for i in range(0, len(oa_codes), chunk_size)] + print(f" Parallel: {workers} workers, {len(chunks)} chunks of ~{chunk_size} OAs") + + ctx = mp.get_context("fork") + try: + with ctx.Pool(processes=workers) as pool: + with tqdm( + total=len(oa_codes), desc="Processing OAs", unit="OA", smoothing=0.01 + ) as bar: + for pcs, wkb, single, n_oas in pool.imap_unordered( + _process_oa_chunk, chunks + ): + if len(wkb): + all_fragments.extend(zip(pcs, shapely.from_wkb(wkb))) + single_count += single + bar.update(n_oas) + finally: + # Drop references so Phase 4 doesn't keep the big inputs alive. + _WORKER_STATE.clear() + return all_fragments, single_count + + +def build_fragments(args: argparse.Namespace) -> list[Fragment]: + """Run Phases 1-3: load data, parse INSPIRE, process every OA into fragments. + + Returns the full ``(postcode, geometry)`` fragment list. The large + intermediate structures (OA/UPRN/INSPIRE arrays) are locals here, so they are + freed as soon as this function returns -- before the fragments are cached or + merged. + """ + # Phase 1: Load all data + print("=" * 60) + print("Phase 1: Loading data") + print("=" * 60) + + oa_geoms = load_oa_boundaries(args.oa_boundaries) + uprn_df, uprn_offsets = load_uprns(args.uprn, args.arcgis) + # Convert UPRNs to fork-shareable numpy/Arrow arrays so parallel workers never + # call polars (avoids the fork-after-threads hazard of its rayon pool). + uprn_east, uprn_north, uprn_postcodes = extract_uprn_arrays(uprn_df) + + # Phase 2: Parse/load INSPIRE + print() + print("=" * 60) + print("Phase 2: INSPIRE data") + print("=" * 60) + + inspire_cache_dir = args.output / "inspire_cache" + if not inspire_cache_exists(inspire_cache_dir): + cache_inspire(args.inspire, inspire_cache_dir) + inspire_bboxes, inspire_offsets, inspire_coords = load_inspire(inspire_cache_dir) + inspire_index = build_inspire_index(inspire_bboxes, inspire_offsets, inspire_coords) + + # Phase 3: Process OAs + print() + print("=" * 60) + print("Phase 3: Processing OAs") + print("=" * 60) + + # Build work list — precompute which OAs are single vs multi-postcode + oa_codes_with_data = sorted(set(oa_geoms.keys()) & set(uprn_offsets.keys())) + skipped_no_uprn = len(oa_geoms) - len(oa_codes_with_data) + skipped_no_boundary = len(uprn_offsets) - len(oa_codes_with_data) + + if args.limit > 0: + oa_codes_with_data = oa_codes_with_data[: args.limit] + + print(f" OAs with UPRNs + boundaries: {len(oa_codes_with_data)}") + print(f" Skipped (no UPRNs): {skipped_no_uprn}") + print(f" Skipped (no boundary): {skipped_no_boundary}") + + # --limit is a debug mode → force deterministic single-process. + workers = 1 if args.limit > 0 else _resolve_workers(args.workers) + all_fragments, single_count = _process_oas( + oa_codes_with_data, + oa_geoms, + uprn_east, + uprn_north, + uprn_postcodes, + uprn_offsets, + inspire_index, + workers, + ) + multi_count = len(oa_codes_with_data) - single_count + + print(f"\n Single-postcode OAs (fast path): {single_count}") + print(f" Multi-postcode OAs (INSPIRE+Voronoi): {multi_count}") + print(f" Total fragments: {len(all_fragments)}") + + return all_fragments def main() -> None: @@ -38,6 +246,12 @@ def main() -> None: parser.add_argument( "--limit", type=int, default=0, help="Process only first N OAs (0=all)" ) + parser.add_argument( + "--workers", + type=int, + default=0, + help="Parallel worker processes for OA processing (0=all CPUs, 1=sequential)", + ) parser.add_argument( "--greenspace", type=Path, @@ -46,79 +260,30 @@ def main() -> None: ) args = parser.parse_args() - # Phase 1: Load all data - print("=" * 60) - print("Phase 1: Loading data") - print("=" * 60) + fragments_cache = args.output / "fragments_cache.parquet" + # Phase 3 depends only on these inputs; greenspace is applied later (Phase 4), + # so a greenspace change must not invalidate the fragment cache. + fragment_inputs = [args.uprn, args.arcgis, args.oa_boundaries, args.inspire] + # --limit yields a partial fragment set; never read or write the shared cache. + use_cache = args.limit == 0 - oa_geoms = load_oa_boundaries(args.oa_boundaries) - uprn_df, uprn_offsets = load_uprns(args.uprn, args.arcgis) - - # Phase 2: Parse/load INSPIRE - print() - print("=" * 60) - print("Phase 2: INSPIRE data") - print("=" * 60) - - inspire_cache_dir = args.output / "inspire_cache" - if not inspire_cache_exists(inspire_cache_dir): - cache_inspire(args.inspire, inspire_cache_dir) - inspire_bboxes, inspire_offsets, inspire_coords = load_inspire(inspire_cache_dir) - - # Phase 3: Process OAs - print() - print("=" * 60) - print("Phase 3: Processing OAs") - print("=" * 60) - - # Build work list — precompute which OAs are single vs multi-postcode - oa_codes_with_data = sorted(set(oa_geoms.keys()) & set(uprn_offsets.keys())) - skipped_no_uprn = len(oa_geoms) - len(oa_codes_with_data) - skipped_no_boundary = len(uprn_offsets) - len(oa_codes_with_data) - - if args.limit > 0: - oa_codes_with_data = oa_codes_with_data[: args.limit] - - print(f" OAs with UPRNs + boundaries: {len(oa_codes_with_data)}") - print(f" Skipped (no UPRNs): {skipped_no_uprn}") - print(f" Skipped (no boundary): {skipped_no_boundary}") - - all_fragments: list[tuple[str, Polygon | MultiPolygon]] = [] - single_count = 0 - multi_count = 0 - - for oa_code in tqdm( - oa_codes_with_data, - desc="Processing OAs", - unit="OA", - smoothing=0.01, - miniters=100, - ): - oa_geom = oa_geoms[oa_code] - points, postcodes = get_oa_uprns(uprn_df, uprn_offsets, oa_code) - - if len(set(postcodes)) == 1: - # Fast path: entire OA = one postcode - all_fragments.append((postcodes[0], oa_geom)) - single_count += 1 - continue - - # Get INSPIRE candidates via bbox pre-filter - candidates = get_inspire_candidates( - oa_geom.bounds, inspire_bboxes, inspire_offsets, inspire_coords + if use_cache and fragments_cache_is_fresh(fragments_cache, fragment_inputs): + print("=" * 60) + print("Phase 3 cache hit — loading fragments (skipping Phases 1-3)") + print("=" * 60) + all_fragments = load_fragments(fragments_cache) + print( + f" Loaded {len(all_fragments):,} cached fragments from {fragments_cache}" ) + else: + all_fragments = build_fragments(args) + if use_cache: + # Persist the expensive Phase-3 output before the cheap-but-fragile + # merge/write so any failure there resumes in seconds, not ~10 hours. + save_fragments(fragments_cache, all_fragments) + print(f" Cached {len(all_fragments):,} fragments to {fragments_cache}") - fragments = process_oa(oa_geom, points, postcodes, candidates) - all_fragments.extend(fragments) - multi_count += 1 - - print(f"\n Single-postcode OAs (fast path): {single_count}") - print(f" Multi-postcode OAs (INSPIRE+Voronoi): {multi_count}") - print(f" Total fragments: {len(all_fragments)}") - - # Free data no longer needed - del oa_geoms, uprn_df, uprn_offsets - del inspire_bboxes, inspire_offsets, inspire_coords + # Free Phase-1-3 intermediates (build_fragments' locals) back to the OS. release_memory() # Phase 4: Merge and write @@ -145,6 +310,12 @@ def main() -> None: file_count = write_district_geojson(merged, args.output) print(f"\n Wrote {file_count} district GeoJSON files to {args.output / 'units'}") + + # The cache exists only to survive a crash between Phase 3 and a clean write. + # Now that the output is complete, drop it so a later input change can never + # be served from a stale cache. + if use_cache: + fragments_cache.unlink(missing_ok=True) print("Done!") diff --git a/pipeline/transform/postcode_boundaries/inspire.py b/pipeline/transform/postcode_boundaries/inspire.py index 515fa8c..ae2bf67 100644 --- a/pipeline/transform/postcode_boundaries/inspire.py +++ b/pipeline/transform/postcode_boundaries/inspire.py @@ -112,44 +112,130 @@ def load_inspire( return bboxes, offsets, coords_mmap -def get_inspire_candidates( - oa_bounds: tuple[float, float, float, float], +# Grid cell size (m) for the parcel spatial index. The median parcel is ~25 m +# and the 99th percentile ~540 m, so almost every parcel fits inside a single +# 1 km cell; the ~0.4% larger than a cell go to an overflow list tested on every +# query. +_GRID_CELL_SIZE = 1000.0 + + +class InspireIndex: + """Uniform-grid spatial index over INSPIRE parcel bounding boxes. + + The per-OA candidate lookup used to linear-scan all ~24M bboxes (O(N) per + OA, ~4 h total over the country). This indexes parcels by grid cell so each + lookup is O(cells_spanned + candidates). Parcels no larger than one cell are + bucketed by their bbox min-corner cell in a CSR layout (parcel indices sorted + by cell id, located with ``searchsorted``); the few parcels larger than a + cell are kept in an overflow array tested directly on every query. An exact + bbox test then runs on the gathered subset and the result is sorted, so the + candidate set -- and its order -- is byte-for-byte identical to the old scan. + """ + + def __init__( + self, + bboxes: np.ndarray, + offsets: np.ndarray, + coords_mmap: np.memmap, + cell_size: float = _GRID_CELL_SIZE, + ) -> None: + self._bboxes = bboxes + self._offsets = offsets + self._coords = coords_mmap + self._cell_size = cell_size + self._origin_x = float(bboxes[:, 0].min()) + self._origin_y = float(bboxes[:, 1].min()) + # Flattened cell id is ``cx * _ny + cy``; +2 leaves a guard row so the + # query's one-cell low-edge widening can never collide with cx-1. + self._ny = int((bboxes[:, 1].max() - self._origin_y) // cell_size) + 2 + + width = bboxes[:, 2] - bboxes[:, 0] + height = bboxes[:, 3] - bboxes[:, 1] + small = np.where((width <= cell_size) & (height <= cell_size))[0] + self._oversized = np.where((width > cell_size) | (height > cell_size))[0] + self._oversized_bb = bboxes[self._oversized] + + cx = ((bboxes[small, 0] - self._origin_x) // cell_size).astype(np.int64) + cy = ((bboxes[small, 1] - self._origin_y) // cell_size).astype(np.int64) + cell_id = cx * self._ny + cy + order = np.argsort(cell_id, kind="stable") + self._sorted_cells = cell_id[order] + self._cell_parcels = small[order] + + def candidate_indices(self, oa_bounds: tuple[float, float, float, float]) -> np.ndarray: + """Parcel indices whose bbox overlaps ``oa_bounds`` (ascending order).""" + min_e, min_n, max_e, max_n = oa_bounds + cs = self._cell_size + # A small parcel (<= one cell) overlapping the OA has its min-corner no + # more than one cell below/left of the OA bbox, so widen the low edges by + # a cell. This keeps the lookup free of false negatives. + gx0 = int((min_e - cs - self._origin_x) // cs) + gx1 = int((max_e - self._origin_x) // cs) + gy_lo = int((min_n - cs - self._origin_y) // cs) + gy_hi = int((max_n - self._origin_y) // cs) + + parts = [] + ob = self._oversized_bb + if len(ob): + mo = ( + (ob[:, 2] >= min_e) + & (ob[:, 0] <= max_e) + & (ob[:, 3] >= min_n) + & (ob[:, 1] <= max_n) + ) + if mo.any(): + parts.append(self._oversized[mo]) + + for gx in range(gx0, gx1 + 1): + base = gx * self._ny + lo = np.searchsorted(self._sorted_cells, base + gy_lo, "left") + hi = np.searchsorted(self._sorted_cells, base + gy_hi, "right") + if hi > lo: + parts.append(self._cell_parcels[lo:hi]) + + if not parts: + return np.empty(0, dtype=np.int64) + cand = np.concatenate(parts) + cb = self._bboxes[cand] + mask = ( + (cb[:, 2] >= min_e) + & (cb[:, 0] <= max_e) + & (cb[:, 3] >= min_n) + & (cb[:, 1] <= max_n) + ) + # Sort so the candidate order matches the old full np.where scan exactly. + return np.sort(cand[mask]) + + def candidates( + self, oa_bounds: tuple[float, float, float, float] + ) -> list[Polygon]: + """INSPIRE polygons overlapping an OA, built from the mmap on demand. + + Builds Shapely objects only for matches (typically 10-500 per OA). + """ + candidates = [] + for i in self.candidate_indices(oa_bounds): + byte_offset = self._offsets[i, 0] + n_pts = self._offsets[i, 1] + float_offset = byte_offset // 8 # float64 = 8 bytes + coords = self._coords[float_offset : float_offset + n_pts * 2].reshape(-1, 2) + poly = Polygon(coords) + if not poly.is_valid: + poly = make_valid(poly) + if poly.geom_type == "MultiPolygon": + poly = max(poly.geoms, key=lambda g: g.area) + elif poly.geom_type != "Polygon": + continue + if not poly.is_empty: + candidates.append(poly) + return candidates + + +def build_inspire_index( bboxes: np.ndarray, offsets: np.ndarray, coords_mmap: np.memmap, -) -> list[Polygon]: - """Get INSPIRE polygons overlapping an OA via bbox pre-filter. - - Builds Shapely objects only for matches (typically 10-500 per OA). - Reads coordinate data on-demand from memory-mapped file. - """ - min_e, min_n, max_e, max_n = oa_bounds - - # Vectorized bbox overlap test - mask = ( - (bboxes[:, 2] >= min_e) - & (bboxes[:, 0] <= max_e) - & (bboxes[:, 3] >= min_n) - & (bboxes[:, 1] <= max_n) - ) - idxs = np.where(mask)[0] - if len(idxs) == 0: - return [] - - # Build Shapely polygons only for candidates (coords from mmap) - candidates = [] - for i in idxs: - byte_offset = offsets[i, 0] - n_pts = offsets[i, 1] - float_offset = byte_offset // 8 # float64 = 8 bytes - coords = coords_mmap[float_offset : float_offset + n_pts * 2].reshape(-1, 2) - poly = Polygon(coords) - if not poly.is_valid: - poly = make_valid(poly) - if poly.geom_type == "MultiPolygon": - poly = max(poly.geoms, key=lambda g: g.area) - elif poly.geom_type != "Polygon": - continue - if not poly.is_empty: - candidates.append(poly) - return candidates + cell_size: float = _GRID_CELL_SIZE, +) -> InspireIndex: + """Build the grid spatial index used for per-OA candidate retrieval.""" + return InspireIndex(bboxes, offsets, coords_mmap, cell_size) diff --git a/pipeline/transform/postcode_boundaries/output.py b/pipeline/transform/postcode_boundaries/output.py index ecd3d1c..d65a261 100644 --- a/pipeline/transform/postcode_boundaries/output.py +++ b/pipeline/transform/postcode_boundaries/output.py @@ -3,8 +3,9 @@ import shutil from collections import defaultdict from pathlib import Path +import numpy as np from pyproj import Transformer -from shapely import make_valid, set_precision +from shapely import STRtree, make_valid, set_precision from shapely.errors import GEOSException from shapely.geometry import MultiPolygon, Polygon, mapping, shape from shapely.ops import transform as transform_geometry @@ -41,30 +42,30 @@ def _largest_polygonal(geom) -> Polygon | None: return None -def to_wgs84_geojson( - geom: Polygon | MultiPolygon, tolerance: float = 1.0 -) -> dict | None: - """Simplify geometry in BNG, convert to WGS84, return a valid GeoJSON dict. +# Output coordinate grid (~0.11 m at UK latitudes). Polygons whose extent is +# below this in any direction snap to empty during serialization. +_OUTPUT_PRECISION_DEG = 0.000001 +# Minimal BNG buffer used to rescue sub-grid slivers into a representable +# footprint. A near-zero-area Voronoi/INSPIRE spike (e.g. three almost-collinear +# vertices) would otherwise vanish at output precision; since every *active* +# postcode must keep a boundary (validate_outputs enforces this with zero +# tolerance), we fatten it just enough to survive snapping rather than drop it. +_MIN_FOOTPRINT_BUFFER_M = 0.5 + + +def _snap_to_wgs84_geojson(geom_bng: Polygon | MultiPolygon) -> dict | None: + """Transform a BNG polygon to WGS84, snap to output precision, validate. Validates the *serialized* GeoJSON dict (via a ``shape()`` round-trip), not just the intermediate Shapely object: coordinate snapping during serialization can otherwise leave a self-intersecting ring that only shows up - once the feature is read back from disk. Any such geometry is repaired with - ``make_valid`` before returning so written features are always valid. + once the feature is read back from disk. Returns ``None`` if the geometry + collapses to empty (a sub-grid sliver). """ - geom = _largest_polygonal(geom) - if geom is None: - return None - - simplified = geom.simplify(tolerance, preserve_topology=True) - simplified = _largest_polygonal(simplified) - if simplified is None: - return None - transformer = _get_to_wgs84() - wgs84 = transform_geometry(transformer.transform, simplified) + wgs84 = transform_geometry(transformer.transform, geom_bng) try: - wgs84 = set_precision(wgs84, 0.000001, mode="valid_output") + wgs84 = set_precision(wgs84, _OUTPUT_PRECISION_DEG, mode="valid_output") except GEOSException: # Precision snapping can fail on pathological geometries; fall back to a # plain validity repair without coordinate snapping. @@ -87,20 +88,105 @@ def to_wgs84_geojson( return geojson_dict +def _rescue_footprint(geom_bng) -> dict | None: + """Fatten a degenerate BNG geometry into a representable footprint and snap.""" + footprint = _largest_polygonal(geom_bng.buffer(_MIN_FOOTPRINT_BUFFER_M)) + if footprint is None: + return None + return _snap_to_wgs84_geojson(footprint) + + +def to_wgs84_geojson( + geom: Polygon | MultiPolygon, tolerance: float = 1.0 +) -> dict | None: + """Simplify geometry in BNG, convert to WGS84, return a valid GeoJSON dict. + + A few thousand postcodes reduce to a sub-grid sliver that snaps to empty at + output precision. Dropping them would leave an active postcode with no + boundary (validate_outputs rejects that with zero tolerance), so instead they + are fattened into a minimal footprint at the right location: first by buffering + the (often elongated) sliver itself, then -- for fully-degenerate input -- a + small disc around ``representative_point()``, which lies inside any non-empty + geometry. ``None`` is returned only for a genuinely empty input. + """ + if geom is None or geom.is_empty: + return None + + cleaned = _largest_polygonal(geom) + if cleaned is not None: + simplified = _largest_polygonal( + cleaned.simplify(tolerance, preserve_topology=True) + ) + if simplified is None: + simplified = cleaned + # Normal path; if snapping erases a thin sliver, fatten its real shape. + result = _snap_to_wgs84_geojson(simplified) + if result is None: + result = _rescue_footprint(simplified) + if result is not None: + return result + + # Universal fallback for input too degenerate to clean or fatten in place. + return _rescue_footprint(geom.representative_point()) + + +def to_wgs84_geojson_multi( + geom: Polygon | MultiPolygon, tolerance: float = 1.0 +) -> dict | None: + """Convert a (possibly multi-part) postcode geometry to a GeoJSON dict, + preserving every part. Each part is simplified/snapped/rescued independently + via :func:`to_wgs84_geojson`; the result is a ``Polygon`` for a single part or + a ``MultiPolygon`` for several. ``None`` only if every part is degenerate. + """ + parts = list(geom.geoms) if geom.geom_type == "MultiPolygon" else [geom] + part_dicts = [d for part in parts if (d := to_wgs84_geojson(part, tolerance))] + if not part_dicts: + return None + if len(part_dicts) == 1: + return part_dicts[0] + return { + "type": "MultiPolygon", + "coordinates": [pd["coordinates"] for pd in part_dicts], + } + + +# Interior holes from the INSPIRE+Voronoi+make_valid chain are small artifacts and +# get filled. A hole at least this large is likely a genuinely enclosed postcode +# (kept, so we never solidify over a neighbour); the de-overlap pass is the real +# guarantee, this is defence-in-depth. +_MAX_ARTIFACT_HOLE_AREA = 1000.0 + + +def _fill_small_holes(poly: Polygon) -> Polygon: + kept = [r for r in poly.interiors if Polygon(r).area >= _MAX_ARTIFACT_HOLE_AREA] + return Polygon(poly.exterior, kept) + + def _fill_holes(geom): - """Remove all interior rings (holes) from a polygon or multipolygon.""" + """Fill small artifact interior rings; keep large (real-enclosed) holes.""" if geom.geom_type == "Polygon": - return Polygon(geom.exterior) + return _fill_small_holes(geom) elif geom.geom_type == "MultiPolygon": - return MultiPolygon([Polygon(p.exterior) for p in geom.geoms]) + return MultiPolygon([_fill_small_holes(p) for p in geom.geoms]) return geom -def _largest_polygon(geom): - """Extract the largest polygon from a MultiPolygon.""" - if geom.geom_type == "MultiPolygon": - return max(geom.geoms, key=lambda g: g.area) - return geom +# A postcode genuinely split across an OA seam (by a railway, river, or main road +# wider than the merge buffer) arrives here as a MultiPolygon. Keeping only the +# largest part used to discard the rest, leaving ~1.8% of merged area as uncovered +# gaps (often 3000-5000 m² building blocks). Keep every part at least this big; +# smaller detached bits are Voronoi/clipping noise and are still dropped. +_MIN_DETACHED_PART_AREA = 100.0 + + +def _keep_polygon_parts(geom): + """Keep all MultiPolygon parts >= _MIN_DETACHED_PART_AREA (largest if none).""" + if geom.geom_type != "MultiPolygon": + return geom + parts = [g for g in geom.geoms if g.area >= _MIN_DETACHED_PART_AREA] + if not parts: + parts = [max(geom.geoms, key=lambda g: g.area)] + return parts[0] if len(parts) == 1 else MultiPolygon(parts) def merge_fragments( @@ -126,14 +212,19 @@ def merge_fragments( continue if not combined.is_valid: combined = make_valid(combined) - # Close tiny gaps between adjacent OA boundary edges (float mismatches) + # Close tiny gaps between adjacent OA boundary edges (float mismatches). + # The closing can erode a tiny MultiPolygon (e.g. a postcode with only a + # sliver fragment) to nothing, which would leave the postcode with no + # geometry at all — keep the un-closed shape if that happens. if combined.geom_type == "MultiPolygon": - combined = combined.buffer(5.0).buffer(-5.0) - if not combined.is_valid: - combined = make_valid(combined) - # Postcodes are contiguous delivery routes — keep only the largest - # polygon; small detached fragments are algorithm artifacts - combined = _largest_polygon(combined) + closed = combined.buffer(5.0).buffer(-5.0) + if not closed.is_valid: + closed = make_valid(closed) + if not closed.is_empty: + combined = closed + # Keep the postcode whole: the largest part plus any other substantial + # part (a genuine railway/river split), dropping only tiny noise slivers. + combined = _keep_polygon_parts(combined) # Remove artifact interior holes from INSPIRE+Voronoi+make_valid chain combined = _fill_holes(combined) # Subtract parks/water if provided @@ -142,7 +233,7 @@ def merge_fragments( pre_green = combined combined = subtract_greenspace(combined, greenspace_tree, greenspace_geoms) - combined = _largest_polygon(combined) + combined = _keep_polygon_parts(combined) # Do NOT _fill_holes here: interior holes carved by the greenspace # subtraction (lakes, enclosed parks) are intentional, not artifacts. # Filling them would re-add the removed area and negate the @@ -155,10 +246,114 @@ def merge_fragments( return merged +def _polygonal(geom): + """Return only the polygonal part(s) of a geometry, or None if none remain.""" + if geom is None or geom.is_empty: + return None + if geom.geom_type in ("Polygon", "MultiPolygon"): + return geom + if geom.geom_type == "GeometryCollection": + polys = [ + g + for g in geom.geoms + if g.geom_type in ("Polygon", "MultiPolygon") and not g.is_empty + ] + if not polys: + return None + merged = unary_union(polys) + return merged if not merged.is_empty else None + return None + + +def _resolve_overlaps( + items: list[tuple[str, Polygon | MultiPolygon]], +) -> list[tuple[str, Polygon | MultiPolygon]]: + """Make the postcode polygons a partition: no two cover the same ground. + + Overlap appears at OA seams (the 5m merge buffer expands each postcode + independently), from simplifying each postcode on its own, and as genuine + containment (a postcode fully enclosed by another). Each postcode is trimmed + by the union of its higher-priority overlapping neighbours, where **priority = + ascending area**: a smaller postcode wins contested ground. That single rule + handles both cases correctly — an enclosed postcode is always smaller than its + container, so it keeps its area while the container gets a hole (a `overlaps` + query alone would miss containment entirely). Run last, on the final output + geometries, so nothing re-introduces overlap afterwards. A postcode that would + be emptied keeps its original geometry, so an active postcode is never dropped. + """ + geoms = [g for _, g in items] + n = len(geoms) + if n < 2: + return items + + # rank[i]: 0 = highest priority (smallest area). Postcode string breaks ties + # for determinism. + rank = { + idx: r + for r, idx in enumerate( + sorted(range(n), key=lambda i: (geoms[i].area, items[i][0])) + ) + } + + tree = STRtree(geoms) + arr = np.array(geoms, dtype=object) + pairs: set[tuple[int, int]] = set() + # "overlaps" gives partial overlaps; "contains" gives containment (which + # "overlaps" excludes) — together they cover every 2-D overlap without the + # edge-touch explosion a plain "intersects" query would add. + for predicate in ("overlaps", "contains"): + qsrc, qtgt = tree.query(arr, predicate=predicate) + for s, t in zip(qsrc.tolist(), qtgt.tolist()): + if s != t: + pairs.add((s, t) if s < t else (t, s)) + + # For each loser (lower priority) the higher-priority neighbours to subtract. + higher: dict[int, list[int]] = defaultdict(list) + for a, b in pairs: + winner, loser = (a, b) if rank[a] < rank[b] else (b, a) + higher[loser].append(winner) + + out = list(geoms) + # Process losers from highest priority down, so every subtracted neighbour is + # already finalised. + for i in sorted(higher, key=lambda idx: rank[idx]): + cut = unary_union([out[j] for j in higher[i]]) + trimmed = out[i].difference(cut) + if not trimmed.is_valid: + trimmed = make_valid(trimmed) + # Keep all polygonal parts: these geometries are in WGS84 degrees, so an + # area threshold here would wrongly drop everything but the largest part + # and re-open the very gaps the seam fix closed. + trimmed = _polygonal(trimmed) + if trimmed is not None and not trimmed.is_empty: + out[i] = trimmed + return [(pc, out[i]) for i, (pc, _) in enumerate(items)] + + +def _round_coords(coords, ndigits=6): + if coords and isinstance(coords[0], (int, float)): + return [round(coords[0], ndigits), round(coords[1], ndigits)] + return [_round_coords(c, ndigits) for c in coords] + + +def _geojson_geometry(geom) -> dict | None: + """Serialize a WGS84 polygon/multipolygon to a 6dp GeoJSON dict, or None.""" + geom = _polygonal(geom if geom.is_valid else make_valid(geom)) + if geom is None or geom.is_empty: + return None + gj = mapping(geom) + return {"type": gj["type"], "coordinates": _round_coords(gj["coordinates"])} + + def write_district_geojson( postcodes: dict[str, Polygon | MultiPolygon], output_dir: Path ) -> int: - """Group postcodes by district, write GeoJSON files. Returns file count.""" + """Group postcodes by district, write GeoJSON files. Returns file count. + + Before writing, the postcode polygons are converted to their final WGS84 form + and made a partition (overlaps removed) so the output never has two postcodes + covering the same ground. + """ units_dir = output_dir / "units" tmp_units_dir = output_dir / "units.tmp" output_dir.mkdir(parents=True, exist_ok=True) @@ -166,38 +361,46 @@ def write_district_geojson( shutil.rmtree(tmp_units_dir) tmp_units_dir.mkdir(parents=True) + skipped: list[str] = [] + + # Pass 1: convert every postcode to its final WGS84 geometry (simplify, snap, + # sliver-rescue, multi-part preserved). Sorted → deterministic de-overlap + # priority. to_wgs84_geojson_multi returns None only for a genuinely empty + # input, which is skipped and reported rather than aborting a multi-hour run. + converted: list[tuple[str, Polygon | MultiPolygon]] = [] + for pc in sorted(postcodes): + gj = to_wgs84_geojson_multi(postcodes[pc]) + if gj is None: + skipped.append(pc) + continue + converted.append((pc, shape(gj))) + + # Remove overlap strips so the output is a clean partition. + converted = _resolve_overlaps(converted) + by_district: dict[str, list[tuple[str, Polygon | MultiPolygon]]] = defaultdict(list) - for pc, geom in postcodes.items(): + for pc, geom in converted: parts = pc.split() district = parts[0] if parts else pc[:4] by_district[district].append((pc, geom)) file_count = 0 - seen_postcodes: set[str] = set() for district, entries in tqdm( sorted(by_district.items()), desc="Writing GeoJSON", unit="file" ): features = [] for pc, geom in sorted(entries, key=lambda x: x[0]): - if pc in seen_postcodes: - raise ValueError(f"Duplicate postcode boundary feature: {pc}") - seen_postcodes.add(pc) - geojson_geom = to_wgs84_geojson(geom) + geojson_geom = _geojson_geometry(geom) if geojson_geom is None: - raise ValueError(f"Postcode boundary collapsed to empty geometry: {pc}") - written_geom = shape(geojson_geom) - if written_geom.is_empty or not written_geom.is_valid: - raise ValueError( - f"Invalid postcode boundary geometry after output: {pc}" - ) - mapit_code = pc.replace(" ", "") + skipped.append(pc) + continue features.append( { "type": "Feature", "geometry": geojson_geom, "properties": { "postcodes": pc, - "mapit_code": mapit_code, + "mapit_code": pc.replace(" ", ""), }, } ) @@ -211,6 +414,14 @@ def write_district_geojson( json.dump(collection, f, separators=(",", ":")) file_count += 1 + if skipped: + preview = ", ".join(skipped[:10]) + suffix = " …" if len(skipped) > 10 else "" + print( + f" Skipped {len(skipped)} postcode(s) with degenerate (sub-grid) " + f"geometry: {preview}{suffix}" + ) + if units_dir.exists(): shutil.rmtree(units_dir) tmp_units_dir.replace(units_dir) diff --git a/pipeline/transform/postcode_boundaries/process_oa.py b/pipeline/transform/postcode_boundaries/process_oa.py index 14aae67..ecdab5f 100644 --- a/pipeline/transform/postcode_boundaries/process_oa.py +++ b/pipeline/transform/postcode_boundaries/process_oa.py @@ -85,19 +85,42 @@ def _claim_inspire_parcels( uprn_pts = shp_points(points) pt_idx, cand_idx = cand_tree.query(uprn_pts, predicate="within") - # First priority: parcels that physically contain UPRNs. Majority vote - # resolves blocks of flats or overlapping parcel data. + # First priority: parcels that physically contain UPRNs. A parcel holding + # UPRNs from a single postcode goes wholly to that postcode. A parcel shared + # by several postcodes (a block of flats spanning postcodes, or overlapping + # parcel data) is split between them via a sub-Voronoi over their own UPRNs + # clipped to the parcel — so EVERY contained postcode keeps part of the + # parcel. A bare majority vote would hand the whole parcel to one winner and + # leave the losers' UPRNs trapped inside claimed land, dropping them from + # both this claim and the `remaining` polygon handed to Voronoi downstream. cand_postcodes: dict[int, list[str]] = defaultdict(list) + cand_point_idx: dict[int, list[int]] = defaultdict(list) for pi, ci in zip(pt_idx, cand_idx): cand_postcodes[ci].append(postcodes[pi]) + cand_point_idx[ci].append(pi) + points_f64 = points.astype(np.float64, copy=False) contained_parts: dict[str, list] = defaultdict(list) contained_scores: Counter[str] = Counter() for ci, pc_list in cand_postcodes.items(): pc_counts = Counter(pc_list) - winner, votes = pc_counts.most_common(1)[0] - contained_parts[winner].append(parcels[ci]) - contained_scores[winner] += votes + if len(pc_counts) == 1: + winner = next(iter(pc_counts)) + contained_parts[winner].append(parcels[ci]) + contained_scores[winner] += pc_counts[winner] + continue + # Shared parcel: sub-Voronoi over the contained UPRNs so each postcode + # present keeps a fragment instead of being absorbed by the winner. + sub_idx = cand_point_idx[ci] + sub_points = points_f64[sub_idx] + sub_postcodes = [postcodes[pi] for pi in sub_idx] + for pc, geom in compute_voronoi_regions( + sub_points, sub_postcodes, parcels[ci] + ).items(): + cleaned = _clean_polygonal(geom) + if cleaned is not None: + contained_parts[pc].append(cleaned) + contained_scores[pc] += pc_counts[pc] contained_claimed = _merge_parts_by_postcode(contained_parts) contained_claims = sorted( @@ -109,7 +132,6 @@ def _claim_inspire_parcels( # each to the nearest UPRN/postcode so parcel boundaries carry more of the # visible postcode shape; Voronoi is then limited to roads, parks, water, and # any other non-parcel gaps. - points_f64 = points.astype(np.float64, copy=False) contained_union = _union_claims(contained_claims) nearest_tree = cKDTree(points_f64) nearest_parts: dict[str, list] = defaultdict(list) @@ -235,11 +257,11 @@ def _extract_polygonal(geom) -> Polygon | MultiPolygon | None: return None if len(polys) == 1: return polys[0] - return MultiPolygon( - [ - p - for g in polys - for p in (g.geoms if g.geom_type == "MultiPolygon" else [g]) - ] - ) + # Union (not bare MultiPolygon construction): make_valid can emit + # overlapping polygonal parts, and a MultiPolygon of overlapping parts is + # invalid — it double-counts area and makes the next `.difference()` raise + # a TopologyException that aborts the OA (and, in parallel mode, the + # worker). unary_union merges them into a valid geometry. + merged = unary_union(polys) + return merged if not merged.is_empty else None return None diff --git a/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py b/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py index 02655e0..2c20d33 100644 --- a/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py +++ b/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py @@ -11,12 +11,20 @@ import pytest from shapely.geometry import MultiPolygon, Polygon, box from shapely.ops import unary_union +from .fragments_cache import ( + fragments_cache_is_fresh, + load_fragments, + save_fragments, +) +from .__main__ import _oa_fragments, _process_oas +from .inspire import build_inspire_index from .oa_boundaries import parse_gpkg_geometry from .greenspace import subtract_greenspace from .output import ( _fill_holes, merge_fragments, to_wgs84_geojson, + to_wgs84_geojson_multi, write_district_geojson, ) from .process_oa import _extract_polygonal, process_oa @@ -173,6 +181,52 @@ class TestWhitespacePostcodes: assert loaded_df["PCDS"].to_list() == ["AA1 1AB"] + def test_remapped_terminated_postcode_adopts_successor_oa(self, tmp_path): + """When a terminated postcode is remapped to its active successor, the + remapped seed point must carry the SUCCESSOR's OA (and coords), not the + terminated postcode's original OA. Pre-fix the row kept OA21CD of the + terminated postcode, seeding the successor into an OA it doesn't belong + to and splitting its boundary across OAs.""" + # Terminated AA1 1AA sits in OA E00000001. Its nearest active successor + # AA1 1AB lives in a DIFFERENT OA (E00000002) far away. + uprns = pl.DataFrame( + { + "GRIDGB1E": [500010], + "GRIDGB1N": [180010], + "PCDS": ["AA1 1AA"], + "OA21CD": ["E00000001"], + } + ) + uprn_path = tmp_path / "uprn.parquet" + uprns.write_parquet(uprn_path) + arcgis = pl.DataFrame( + { + "pcds": ["AA1 1AA", "AA1 1AB"], + "east1m": [500010, 500030], + "north1m": [180010, 180020], + # AA1 1AA terminated → only AA1 1AB is an active successor, and + # it belongs to a different OA than the terminated postcode. + "oa21cd": ["E00000001", "E00000002"], + "doterm": ["2020-01-01", None], + "ctry25cd": ["E92000001", "E92000001"], + } + ) + arcgis_path = tmp_path / "arcgis.parquet" + arcgis.write_parquet(arcgis_path) + + loaded_df, offsets = load_uprns(uprn_path, arcgis_path) + + # The remapped point must be grouped under the successor's OA, not the + # terminated postcode's OA. + assert "E00000002" in offsets, "Successor OA missing — remap kept old OA" + assert "E00000001" not in offsets, ( + "Remapped point still lives in the terminated postcode's OA" + ) + points, postcodes = get_oa_uprns(loaded_df, offsets, "E00000002") + assert postcodes == ["AA1 1AB"] + # It should also adopt the successor's authoritative coordinates. + assert points.tolist() == [[500030.0, 180020.0]] + def test_arcgis_filters_to_active_english_postcodes(self, tmp_path): uprns = pl.DataFrame( { @@ -617,6 +671,32 @@ class TestProcessOAInspireParcelAssignment: for _, geom in fragments: assert geom.difference(oa_geom).area < 0.01 + def test_shared_parcel_keeps_every_contained_postcode(self): + """A single parcel containing UPRNs for [A, A, B] must yield a fragment + for BOTH A and B. Pre-fix the majority winner (A) claimed the whole + parcel, excluding it from `remaining`, so B's UPRNs were trapped inside + claimed land and B vanished entirely (no fragment).""" + oa_geom = box(0, 0, 100, 100) + parcel = box(0, 0, 100, 100) # one parcel covering the whole OA + points = np.array( + [ + [20, 50], # postcode A + [30, 50], # postcode A (majority) + [80, 50], # postcode B (minority — would be dropped pre-fix) + ] + ) + postcodes = ["A", "A", "B"] + + fragments = process_oa(oa_geom, points, postcodes, inspire_candidates=[parcel]) + frag_dict = dict(fragments) + + assert "A" in frag_dict, "Majority postcode A must keep a fragment" + assert "B" in frag_dict, "Minority postcode B must not be dropped" + assert frag_dict["A"].area > 0 + assert frag_dict["B"].area > 0 + # The split must partition the parcel without overlap. + assert frag_dict["A"].intersection(frag_dict["B"]).area < 0.01 + # --------------------------------------------------------------------------- # _extract_polygonal helper @@ -656,6 +736,21 @@ class TestExtractPolygonal: assert _extract_polygonal(LineString([(0, 0), (1, 1)])) is None + def test_overlapping_collection_unioned_to_valid(self): + """A GeometryCollection with OVERLAPPING polygons must be unioned into a + VALID geometry (not a raw MultiPolygon, which would be invalid and crash + the next .difference()), and must not double-count the overlap area.""" + from shapely.geometry import GeometryCollection + + a = box(0, 0, 100, 100) + b = box(50, 50, 150, 150) # overlaps a by 50x50 + result = _extract_polygonal(GeometryCollection([a, b])) + assert result is not None + assert result.is_valid + assert result.area == pytest.approx(unary_union([a, b]).area) + # And the formerly-crashing op now works: + assert result.difference(box(0, 0, 10, 10)).is_valid + # --------------------------------------------------------------------------- # Edge case: merge_fragments handles single-OA postcodes @@ -763,12 +858,12 @@ class TestParseGpkgGeometry: class TestFillHoles: - """_fill_holes must remove all interior holes from polygons.""" + """_fill_holes fills small artifact holes but keeps large (real-enclosed) ones.""" - def test_polygon_with_hole(self): - """A polygon with an interior ring should become a solid polygon.""" + def test_small_artifact_hole_filled(self): + """A small (<1000 m²) interior ring is an artifact and gets filled.""" outer = [(0, 0), (100, 0), (100, 100), (0, 100), (0, 0)] - hole = [(30, 30), (70, 30), (70, 70), (30, 70), (30, 30)] + hole = [(40, 40), (60, 40), (60, 60), (40, 60), (40, 40)] # 20x20 = 400 m² poly_with_hole = Polygon(outer, [hole]) assert len(list(poly_with_hole.interiors)) == 1 result = _fill_holes(poly_with_hole) @@ -776,6 +871,15 @@ class TestFillHoles: assert len(list(result.interiors)) == 0 assert result.area == pytest.approx(Polygon(outer).area) + def test_large_hole_kept(self): + """A large (>=1000 m²) hole is likely a real enclosed postcode — keep it.""" + outer = [(0, 0), (100, 0), (100, 100), (0, 100), (0, 0)] + hole = [(20, 20), (80, 20), (80, 80), (20, 80), (20, 20)] # 60x60 = 3600 m² + poly_with_hole = Polygon(outer, [hole]) + result = _fill_holes(poly_with_hole) + assert len(list(result.interiors)) == 1 + assert result.area == pytest.approx(10000 - 3600) + def test_multipolygon_with_holes(self): """A MultiPolygon where each part has holes should have all holes removed.""" outer1 = [(0, 0), (50, 0), (50, 50), (0, 50), (0, 0)] @@ -944,3 +1048,356 @@ class TestGreenspaceHolePreserved: merged = result["TEST1"] assert len(list(merged.interiors)) == 1 assert merged.area == pytest.approx(10000 - 1600, rel=0.05) + + +# --------------------------------------------------------------------------- +# merge_fragments keeps substantial detached parts (no OA-seam coverage gaps) +# --------------------------------------------------------------------------- + + +class TestKeepDetachedParts: + """A postcode split across an OA seam (railway/river) must keep both parts + instead of dropping all but the largest, which left ~1.8% uncovered gaps.""" + + def test_far_apart_parts_both_kept(self): + # Two 50x50m blocks 30m apart — wider than the 10m merge buffer. + a = box(0, 0, 50, 50) # 2500 m² + b = box(80, 0, 130, 50) # 2500 m², 30m gap + geom = merge_fragments([("AA1 1AA", a), ("AA1 1AA", b)])["AA1 1AA"] + assert geom.geom_type == "MultiPolygon" + assert len(geom.geoms) == 2 + assert geom.area == pytest.approx(5000, rel=0.01) + + def test_tiny_noise_part_dropped(self): + main = box(0, 0, 100, 100) # 10000 m² + noise = box(200, 200, 205, 205) # 25 m² < 100 m² threshold + geom = merge_fragments([("AA1 1AA", main), ("AA1 1AA", noise)])["AA1 1AA"] + assert geom.geom_type == "Polygon" + assert geom.area == pytest.approx(10000, rel=0.01) + + +class TestMultiPolygonOutput: + """to_wgs84_geojson_multi / the writer must emit MultiPolygon for split + postcodes (the Rust server + loader already parse MultiPolygon).""" + + def test_multipolygon_preserves_all_parts(self): + from shapely.geometry import shape + + mp = MultiPolygon( + [ + box(530000, 180000, 530100, 180100), + box(531000, 180000, 531100, 180100), + ] + ) + gj = to_wgs84_geojson_multi(mp) + assert gj["type"] == "MultiPolygon" + assert len(gj["coordinates"]) == 2 + rt = shape(gj) + assert rt.is_valid and not rt.is_empty + assert len(rt.geoms) == 2 + + def test_single_part_stays_polygon(self): + gj = to_wgs84_geojson_multi(box(530000, 180000, 530100, 180100)) + assert gj["type"] == "Polygon" + + def test_writer_emits_multipolygon_feature(self, tmp_path): + mp = MultiPolygon( + [ + box(530000, 180000, 530100, 180100), + box(531000, 180000, 531100, 180100), + ] + ) + assert write_district_geojson({"AA1 1AA": mp}, tmp_path) == 1 + coll = json.loads((tmp_path / "units" / "AA1.geojson").read_text()) + assert coll["features"][0]["geometry"]["type"] == "MultiPolygon" + + +class TestOutputPartition: + """The writer must emit a partition: overlapping postcodes are made disjoint + (no two cover the same ground) without dropping an active postcode.""" + + def test_overlapping_postcodes_made_disjoint(self, tmp_path): + from shapely.geometry import shape + + a = box(530000, 180000, 530100, 180100) + b = box(530090, 180000, 530200, 180100) # overlaps `a` in a 10m strip + assert a.intersection(b).area > 0 # precondition: they overlap + + write_district_geojson({"AA1 1AA": a, "AA1 1AB": b}, tmp_path) + coll = json.loads((tmp_path / "units" / "AA1.geojson").read_text()) + geoms = { + f["properties"]["postcodes"]: shape(f["geometry"]) + for f in coll["features"] + } + assert set(geoms) == {"AA1 1AA", "AA1 1AB"} # neither dropped + # Disjoint interiors (share at most an edge). + assert geoms["AA1 1AA"].intersection(geoms["AA1 1AB"]).area == pytest.approx( + 0.0, abs=1e-12 + ) + assert all(g.area > 0 for g in geoms.values()) + + def test_enclosed_postcode_makes_container_a_donut(self, tmp_path): + """A postcode fully INSIDE another must stay disjoint: the smaller (inner) + keeps its area, the container gets a hole. A plain `overlaps` query misses + containment, so this is the regression guard for that fix.""" + from shapely.geometry import shape + + outer = box(530000, 180000, 530300, 180300) # 90,000 m² + inner = box(530100, 180100, 530200, 180200) # 10,000 m², fully inside outer + assert outer.contains(inner) # precondition + + write_district_geojson({"AA1 1AA": outer, "AA1 1AB": inner}, tmp_path) + coll = json.loads((tmp_path / "units" / "AA1.geojson").read_text()) + geoms = { + f["properties"]["postcodes"]: shape(f["geometry"]) + for f in coll["features"] + } + assert set(geoms) == {"AA1 1AA", "AA1 1AB"} # neither dropped + assert geoms["AA1 1AA"].intersection(geoms["AA1 1AB"]).area == pytest.approx( + 0.0, abs=1e-12 + ) + # Container is now a donut around the enclosed postcode. + assert geoms["AA1 1AA"].geom_type == "Polygon" + assert len(list(geoms["AA1 1AA"].interiors)) == 1 + assert geoms["AA1 1AB"].area > 0 + + +# --------------------------------------------------------------------------- +# InspireIndex must return the same candidates as a brute-force bbox scan +# --------------------------------------------------------------------------- + + +class TestInspireIndex: + """The grid index replaces a per-OA linear scan of all parcel bboxes; it must + return an identical candidate set (and order) so Phase 3 output is unchanged.""" + + @staticmethod + def _brute(bboxes, box): + e0, n0, e1, n1 = box + mask = ( + (bboxes[:, 2] >= e0) + & (bboxes[:, 0] <= e1) + & (bboxes[:, 3] >= n0) + & (bboxes[:, 1] <= n1) + ) + return np.where(mask)[0] + + def test_matches_brute_force_over_random_queries(self): + rng = np.random.default_rng(0) + x = rng.uniform(0, 10000, 5000) + y = rng.uniform(0, 10000, 5000) + w = rng.uniform(1, 60, 5000) # all <= 500m cell → CSR path + h = rng.uniform(1, 60, 5000) + bboxes = np.column_stack([x, y, x + w, y + h]).astype(np.float64) + idx = build_inspire_index(bboxes, None, None, cell_size=500.0) + + for _ in range(400): + cx, cy = rng.uniform(0, 10000), rng.uniform(0, 10000) + sz = float(rng.choice([30.0, 200.0, 1000.0, 3000.0])) + box = (cx, cy, cx + sz, cy + sz) + got = idx.candidate_indices(box) + expected = np.sort(self._brute(bboxes, box)) + assert np.array_equal(got, expected) + + def test_oversized_parcel_is_found(self): + # A parcel larger than a cell goes to the overflow list, not the grid; + # a query deep inside it (away from the small parcels) must still find it. + bboxes = np.array( + [ + [0.0, 0.0, 5000.0, 5000.0], # 5km parcel >> 500m cell + [100.0, 100.0, 120.0, 120.0], + [4000.0, 4000.0, 4020.0, 4020.0], + ] + ) + idx = build_inspire_index(bboxes, None, None, cell_size=500.0) + box = (2000.0, 2000.0, 2050.0, 2050.0) + got = idx.candidate_indices(box) + assert 0 in got + assert np.array_equal(got, np.sort(self._brute(bboxes, box))) + + def test_no_overlap_returns_empty(self): + bboxes = np.array([[0.0, 0.0, 10.0, 10.0], [20.0, 20.0, 30.0, 30.0]]) + idx = build_inspire_index(bboxes, None, None, cell_size=500.0) + assert len(idx.candidate_indices((100.0, 100.0, 110.0, 110.0))) == 0 + + +# --------------------------------------------------------------------------- +# Parallel OA processing must match the sequential result exactly +# --------------------------------------------------------------------------- + + +class TestParallelProcessing: + """_process_oas across workers must produce the same fragments as workers=1. + Uses single-postcode OAs (fast path), so it exercises the chunking + WKB + round-trip + fork machinery without needing INSPIRE data.""" + + @staticmethod + def _inputs(n_oas=60): + import pyarrow as pa + + oa_geoms = { + f"E{i:08d}": box(i * 100.0, 0.0, i * 100.0 + 50.0, 50.0) + for i in range(n_oas) + } + codes = sorted(oa_geoms) + east, north, pcs = [], [], [] + offsets = {} + pos = 0 + for i, code in enumerate(codes): + east += [i * 100.0 + 10.0, i * 100.0 + 20.0] + north += [10.0, 20.0] + pcs += [f"AA{i % 5} {i % 9}AA"] * 2 # one postcode per OA → fast path + offsets[code] = (pos, pos + 2) + pos += 2 + return ( + codes, + oa_geoms, + np.array(east), + np.array(north), + pa.array(pcs, type=pa.large_string()), + offsets, + ) + + @staticmethod + def _norm(frags): + return sorted((pc, geom.wkb_hex) for pc, geom in frags) + + def test_parallel_matches_sequential(self): + codes, oa, east, north, pcs, offs = self._inputs() + seq, s1 = _process_oas(codes, oa, east, north, pcs, offs, None, workers=1) + par, s2 = _process_oas(codes, oa, east, north, pcs, offs, None, workers=3) + assert len(seq) == len(codes) # one fragment per single-postcode OA + assert s1 == s2 == len(codes) + assert self._norm(seq) == self._norm(par) + + def test_oa_failure_is_tagged_with_oa_code(self): + """A failure inside per-OA processing must re-raise with the OA code, so a + single bad OA is attributable instead of an anonymous worker abort.""" + # Missing OA in the geoms dict → KeyError, wrapped with the OA code. + with pytest.raises(RuntimeError, match="E00099999"): + _oa_fragments("E00099999", {}, None, None, None, {}, None) + + +class TestDegenerateGeometryHandling: + """Every active postcode must keep a boundary (validate_outputs is strict), + so a sub-grid sliver is fattened rather than dropped. A genuinely empty + geometry is skipped without aborting the whole write (the 10h regression).""" + + # Three near-collinear vertices in BNG: bbox ~28m x 7m but area ~0.04 m², + # i.e. AL10 0TU. Without the rescue it snaps to empty at output precision. + SLIVER = Polygon( + [(523045.34, 209625.56), (523040.47, 209624.33), (523017.0, 209618.42)] + ) + + def test_sliver_is_rescued_to_valid_geometry(self): + from shapely.geometry import shape + + result = to_wgs84_geojson(self.SLIVER) + assert result is not None, "sliver must be rescued, not dropped" + rt = shape(result) + assert not rt.is_empty + assert rt.is_valid + + def test_collinear_zero_area_input_is_rescued(self): + """A zero-area collinear 'polygon' (can't be cleaned to a polygon) must + still be rescued via the representative-point fallback, not dropped.""" + from shapely.geometry import shape + + degenerate = Polygon( + [(523000, 209600), (523010, 209600), (523020, 209600), (523000, 209600)] + ) + assert degenerate.area == 0.0 + result = to_wgs84_geojson(degenerate) + assert result is not None, "degenerate input must be rescued, not dropped" + rt = shape(result) + assert not rt.is_empty + assert rt.is_valid + + def test_sliver_postcode_present_in_output(self, tmp_path): + postcodes = { + "AA1 1AA": box(530000, 180000, 530100, 180100), + "AA1 1AB": self.SLIVER, # must survive + } + file_count = write_district_geojson(postcodes, tmp_path) + assert file_count == 1 + collection = json.loads((tmp_path / "units" / "AA1.geojson").read_text()) + written = {f["properties"]["postcodes"] for f in collection["features"]} + assert written == {"AA1 1AA", "AA1 1AB"} + + def test_empty_geometry_skipped_not_raised(self, tmp_path): + # The last-resort safety net: an unrescuable (empty) geometry is skipped + # so one bad postcode can never abort a multi-hour run. + postcodes = { + "AA1 1AA": box(530000, 180000, 530100, 180100), + "AA1 1AB": Polygon(), # genuinely empty + } + file_count = write_district_geojson(postcodes, tmp_path) + assert file_count == 1 + collection = json.loads((tmp_path / "units" / "AA1.geojson").read_text()) + written = {f["properties"]["postcodes"] for f in collection["features"]} + assert written == {"AA1 1AA"} + + +# --------------------------------------------------------------------------- +# fragments_cache round-trips Phase 3 output and validates freshness +# --------------------------------------------------------------------------- + + +class TestFragmentsCache: + """Persisting Phase 3 lets a crashed run resume without the ~10h OA loop.""" + + def test_round_trip_preserves_postcodes_and_geometry(self, tmp_path): + fragments = [ + ("AA1 1AA", box(0, 0, 100, 100)), + ("AA1 1AB", box(200, 200, 250, 260)), + # A postcode spanning multiple OAs appears as repeated entries. + ("AA1 1AA", box(100, 0, 150, 100)), + ("AA1 1AC", MultiPolygon([box(0, 0, 10, 10), box(20, 20, 30, 30)])), + ] + cache = tmp_path / "fragments_cache.parquet" + save_fragments(cache, fragments) + loaded = load_fragments(cache) + + assert [pc for pc, _ in loaded] == [pc for pc, _ in fragments] + for (_, original), (_, restored) in zip(fragments, loaded): + assert restored.equals(original) + + def test_save_is_atomic_no_tmp_left_behind(self, tmp_path): + cache = tmp_path / "fragments_cache.parquet" + save_fragments(cache, [("AA1 1AA", box(0, 0, 1, 1))]) + assert cache.exists() + assert not (tmp_path / "fragments_cache.parquet.tmp").exists() + + def test_missing_cache_is_not_fresh(self, tmp_path): + cache = tmp_path / "fragments_cache.parquet" + inp = tmp_path / "uprn.parquet" + inp.write_text("x") + assert fragments_cache_is_fresh(cache, [inp]) is False + + def test_cache_newer_than_inputs_is_fresh(self, tmp_path): + import os + + inp = tmp_path / "uprn.parquet" + inp.write_text("x") + cache = tmp_path / "fragments_cache.parquet" + cache.write_text("c") + os.utime(inp, (1_000, 1_000)) + os.utime(cache, (2_000, 2_000)) + assert fragments_cache_is_fresh(cache, [inp, None]) is True + + def test_cache_older_than_any_input_is_stale(self, tmp_path): + import os + + inp = tmp_path / "oa.gpkg" + inp.write_text("x") + cache = tmp_path / "fragments_cache.parquet" + cache.write_text("c") + os.utime(cache, (1_000, 1_000)) + os.utime(inp, (2_000, 2_000)) # input touched after the cache + assert fragments_cache_is_fresh(cache, [inp]) is False + + def test_missing_input_is_ignored(self, tmp_path): + cache = tmp_path / "fragments_cache.parquet" + cache.write_text("c") + # arcgis is optional/absent — it cannot have invalidated the cache. + assert fragments_cache_is_fresh(cache, [tmp_path / "absent.parquet"]) is True diff --git a/pipeline/transform/postcode_boundaries/uprn.py b/pipeline/transform/postcode_boundaries/uprn.py index 180f68f..d7d19b8 100644 --- a/pipeline/transform/postcode_boundaries/uprn.py +++ b/pipeline/transform/postcode_boundaries/uprn.py @@ -79,13 +79,42 @@ def load_uprns( ) if mapping is not None and mapping.height > 0: - uprns = ( - uprns.join( - mapping.lazy(), left_on="PCDS", right_on="old_postcode", how="left" + # Remap terminated postcodes to their nearest active successor. The + # successor generally lives in a DIFFERENT OA (and at different grid + # coordinates), so the remapped point must adopt the successor's + # authoritative OA/coords — keeping the terminated postcode's original + # OA would seed the successor into an OA it doesn't belong to, splitting + # its boundary across OAs. Genuine (non-remapped) UPRN rows keep their + # own OA, since a live postcode can legitimately span several OAs. + uprns = uprns.join( + mapping.lazy(), left_on="PCDS", right_on="old_postcode", how="left" + ).with_columns(pl.col("new_postcode").is_not_null().alias("_remapped")) + if active_postcode_points is not None: + successor_oa = active_postcode_points.rename( + { + "PCDS": "new_postcode", + "GRIDGB1E": "_succ_e", + "GRIDGB1N": "_succ_n", + "OA21CD": "_succ_oa", + } ) - .with_columns(pl.coalesce("new_postcode", "PCDS").alias("PCDS")) - .select("GRIDGB1E", "GRIDGB1N", "PCDS", "OA21CD") - ) + uprns = uprns.join(successor_oa, on="new_postcode", how="left").with_columns( + pl.when("_remapped") + .then(pl.col("_succ_e")) + .otherwise(pl.col("GRIDGB1E")) + .alias("GRIDGB1E"), + pl.when("_remapped") + .then(pl.col("_succ_n")) + .otherwise(pl.col("GRIDGB1N")) + .alias("GRIDGB1N"), + pl.when("_remapped") + .then(pl.col("_succ_oa")) + .otherwise(pl.col("OA21CD")) + .alias("OA21CD"), + ) + uprns = uprns.with_columns( + pl.coalesce("new_postcode", "PCDS").alias("PCDS") + ).select("GRIDGB1E", "GRIDGB1N", "PCDS", "OA21CD") if active_postcode_points is not None: active_postcodes = active_postcode_points.select("PCDS").unique() @@ -149,3 +178,37 @@ def get_oa_uprns( ) postcodes = sub["PCDS"].to_list() return points, postcodes + + +def extract_uprn_arrays(df: pl.DataFrame): + """Convert the UPRN DataFrame to fork-shareable numpy/Arrow arrays. + + Returns ``(east, north, postcodes)``: two float64 ndarrays and a contiguous + pyarrow string Array. Multiprocessing workers slice these per OA via + :func:`get_oa_uprns_arrays` **without touching polars**, which avoids the + fork-after-threads deadlock hazard of polars' rayon pool. Being plain + numpy/Arrow buffers (not millions of Python objects), they are shared by + ``fork`` copy-on-write rather than duplicated ~1GB per worker. + """ + import pyarrow as pa + + east = np.ascontiguousarray(df["GRIDGB1E"].to_numpy(), dtype=np.float64) + north = np.ascontiguousarray(df["GRIDGB1N"].to_numpy(), dtype=np.float64) + postcodes = df["PCDS"].to_arrow() + if isinstance(postcodes, pa.ChunkedArray): + postcodes = postcodes.combine_chunks() + return east, north, postcodes + + +def get_oa_uprns_arrays( + east: np.ndarray, + north: np.ndarray, + postcodes, + offsets: dict[str, tuple[int, int]], + oa_code: str, +) -> tuple[np.ndarray, list[str]]: + """Like :func:`get_oa_uprns`, but slices the fork-shareable arrays from + :func:`extract_uprn_arrays` (no polars), so it is safe to call in workers.""" + s, e = offsets[oa_code] + points = np.column_stack([east[s:e], north[s:e]]) + return points, postcodes.slice(s, e - s).to_pylist() diff --git a/pipeline/transform/price_estimation/backtest.py b/pipeline/transform/price_estimation/backtest.py index 4860bb8..7ac68fc 100644 --- a/pipeline/transform/price_estimation/backtest.py +++ b/pipeline/transform/price_estimation/backtest.py @@ -11,9 +11,9 @@ from pathlib import Path import numpy as np import polars as pl +from pipeline.transform.price_estimation.estimate import guarded_blend_estimates from pipeline.transform.price_estimation.index import build_index from pipeline.transform.price_estimation.knn import ( - KNN_BLEND_WEIGHT, build_knn_pool, knn_median_psm, ) @@ -115,7 +115,10 @@ def predict(test: pl.DataFrame, index: pl.DataFrame) -> pl.DataFrame: .clip(-MAX_LOG_ADJUSTMENT, MAX_LOG_ADJUSTMENT) .exp() ) - .fill_null(pl.col("input_price").cast(pl.Float64)) + # Keep null when the index can't be interpolated, matching production + # (estimate.py ships null there). compute_metrics filters to finite + # positive predictions, so these rows correctly drop from the Index n + # rather than silently degrading to the Naive prediction. .alias("predicted"), ) return test @@ -265,13 +268,12 @@ def main(): f" kNN estimates: {n_knn:,} of {len(test):,} ({n_knn / len(test) * 100:.1f}%)" ) - # Blend: (1-w)*index + w*kNN where both available + # Blend with the exact shipped estimator (stability gate + last-price cap + + # null-when-no-index) so the "Blended" stage reflects production accuracy. + # input_price is the backtest equivalent of production's "Last known price". index_est = test["predicted"].to_numpy().astype(np.float64) - knn_valid = np.isfinite(knn_est) & (knn_est > 0) - blended = np.where( - knn_valid & np.isfinite(index_est), - (1 - KNN_BLEND_WEIGHT) * index_est + KNN_BLEND_WEIGHT * knn_est, - np.where(np.isfinite(index_est), index_est, knn_est), + blended = guarded_blend_estimates( + index_est, knn_est, test["input_price"].cast(pl.Float64).to_numpy() ) actual = test["actual_price"].to_numpy().astype(np.float64) diff --git a/pipeline/transform/price_estimation/index.py b/pipeline/transform/price_estimation/index.py index 0f4665f..676c0b8 100644 --- a/pipeline/transform/price_estimation/index.py +++ b/pipeline/transform/price_estimation/index.py @@ -19,6 +19,8 @@ from tqdm import tqdm from pipeline.transform.price_estimation.shrinkage import ( blend_dicts, hierarchical_shrinkage, + reanchor_dict, + reanchor_dicts, shrink_dicts, spatial_smooth, ) @@ -431,6 +433,17 @@ def build_index( f" {len(area_idx)} areas, {len(district_idx)} districts, {len(sector_idx)} sectors" ) + # Re-anchor every repeat-sales dict to the global base year before any + # shrinkage/smoothing/blending. solve_robust_index anchors each cell to + # log-index 0 at its OWN earliest year, so cells with shorter histories + # are measured from a later origin; combining them key-by-key would + # otherwise average level-incompatible numbers. The hedonic fallback is + # already anchored at min_year, so we align everything to min_year. + national_idx = reanchor_dict(national_idx, min_year) + area_idx = reanchor_dicts(area_idx, min_year) + district_idx = reanchor_dicts(district_idx, min_year) + sector_idx = reanchor_dicts(sector_idx, min_year) + # Shrinkage: national -> hedonic first, then hierarchical print(" Applying shrinkage...") national_shrunk = shrink_dicts(national_idx, hedonic_idx, national_n) diff --git a/pipeline/transform/price_estimation/shrinkage.py b/pipeline/transform/price_estimation/shrinkage.py index 7f3410d..51101fe 100644 --- a/pipeline/transform/price_estimation/shrinkage.py +++ b/pipeline/transform/price_estimation/shrinkage.py @@ -13,6 +13,51 @@ SPATIAL_NEIGHBORS = 5 SPATIAL_BLEND_K = 30 +def _base_value(index: dict[int, float], base_year: int) -> float: + """Value of an index dict at `base_year`, with forward/back-fill for gaps. + + Each repeat-sales dict is anchored to 0 at its OWN earliest year, so its + values are log-levels relative to that origin. To express it on a common + origin we need its value at the shared `base_year`: + - exact hit: use it directly; + - base_year before the dict's history: back-fill, i.e. the earliest known + value (which is 0.0 by construction). We cannot observe the level move + between the global base and a later-starting cell, so we assume none, + matching forward_fill's back-fill convention; + - base_year inside a gap / after history: forward-fill the most recent + prior value. + """ + if base_year in index: + return index[base_year] + years = sorted(index) + if not years or base_year < years[0]: + return index[years[0]] if years else 0.0 + prior = [y for y in years if y <= base_year] + return index[prior[-1]] + + +def reanchor_dict(index: dict[int, float], base_year: int) -> dict[int, float]: + """Re-anchor an index dict so index[base_year] == 0 (pure constant shift). + + Subtracting the same constant from every year preserves all within-dict + year-to-year differences, so estimate.py's (current - sale) semantics are + unchanged; it only fixes the cross-dict level mismatch before blending. + """ + if not index: + return index + shift = _base_value(index, base_year) + if shift == 0.0: + return index + return {y: v - shift for y, v in index.items()} + + +def reanchor_dicts( + indices: dict[str, dict[int, float]], base_year: int +) -> dict[str, dict[int, float]]: + """Re-anchor every index dict in a mapping to the common `base_year`.""" + return {key: reanchor_dict(idx, base_year) for key, idx in indices.items()} + + def shrink_dicts(raw: dict, parent: dict, n: int) -> dict: """Shrink dict values toward parent using n/(n+k) weighting. diff --git a/pipeline/transform/test_crime.py b/pipeline/transform/test_crime.py index 17acde7..90f83b6 100644 --- a/pipeline/transform/test_crime.py +++ b/pipeline/transform/test_crime.py @@ -158,6 +158,53 @@ def test_transform_crime_writes_by_year_output(tmp_path): assert serious[2024] == 12.0 +def test_transform_crime_headline_is_mean_of_per_year_bars(tmp_path): + """The avg/yr headline must equal the average of the by-year chart bars, i.e. + the simple mean of each year's annualised count -- NOT a month-weighted pooled + rate. They diverge when years have uneven partial-month coverage.""" + crime_dir = tmp_path / "crime" + jan23 = crime_dir / "2023-01" + jan24 = crime_dir / "2024-01" + feb24 = crime_dir / "2024-02" + for d in (jan23, jan24, feb24): + d.mkdir(parents=True) + + header = "Crime ID,Month,Reported by,Falls within,Longitude,Latitude,Location,LSOA code,LSOA name,Crime type,Last outcome category,Context" + # 2023: 6 burglaries in 1 month -> 6 * 12 / 1 = 72/yr. + (jan23 / "2023-01-test-force-street.csv").write_text( + "\n".join( + [header] + + [ + f"{i},2023-01,F,F,-0.1,51.5,X,E01000001,L,Burglary,U," + for i in range(1, 7) + ] + ) + + "\n" + ) + # 2024: 2 burglaries across 2 months -> 2 * 12 / 2 = 12/yr. + (jan24 / "2024-01-test-force-street.csv").write_text( + "\n".join([header, "7,2024-01,F,F,-0.1,51.5,X,E01000001,L,Burglary,U,"]) + "\n" + ) + (feb24 / "2024-02-test-force-street.csv").write_text( + "\n".join([header, "8,2024-02,F,F,-0.1,51.5,X,E01000001,L,Burglary,U,"]) + "\n" + ) + + output = tmp_path / "crime.parquet" + by_year_output = tmp_path / "crime_by_year.parquet" + transform_crime(crime_dir, output, by_year_output) + + # Mean of per-year bars = (72 + 12) / 2 = 42.0. + # The old pooled rate (8 incidents / 3 months * 12 = 32.0) would be wrong. + avg = pl.read_parquet(output).to_dicts()[0] + assert avg["Burglary (avg/yr)"] == 42.0 + + by_year = pl.read_parquet(by_year_output).row(0, named=True) + burglary = {p["year"]: p["count"] for p in by_year["Burglary (by year)"]} + assert burglary == {2023: 72.0, 2024: 12.0} + # Headline equals the mean of the bars it summarises. + assert avg["Burglary (avg/yr)"] == sum(burglary.values()) / len(burglary) + + def test_transform_crime_fails_without_valid_months(tmp_path): crime_dir = tmp_path / "crime" month_dir = crime_dir / "2024-01" diff --git a/pipeline/transform/test_crime_spatial.py b/pipeline/transform/test_crime_spatial.py index 4ce8204..fe9af06 100644 --- a/pipeline/transform/test_crime_spatial.py +++ b/pipeline/transform/test_crime_spatial.py @@ -252,6 +252,63 @@ def test_avg_yr_is_simple_mean_of_year_bars(tmp_path): assert bars == {2023: pytest.approx(24.0, abs=0.05), 2024: pytest.approx(12.0, abs=0.05)} +def test_avg_yr_denominator_is_per_postcode_not_global(tmp_path): + # P (AB1 1AA) has burglaries only in its single most-recent year (2024); Q + # (AB1 1AB), far away, has a burglary in 2014. The type therefore spans TWO + # distinct years across all postcodes, but only ONE year for P. The headline + # must divide by P's own years-present (1), equalling its single by-year bar + # (24/yr) -- not by the global span (2), which would deflate it to 12/yr. + # The two squares are equal-area, so area normalisation leaves counts as-is. + units = tmp_path / "units" + _write_boundaries( + units, + { + "AB1": [ + _square_feature("AB1 1AA", 1000, 1000, 1010, 1010), + _square_feature("AB1 1AB", 5000, 5000, 5010, 5010), + ] + }, + ) + + crime = tmp_path / "crime" + # P: 2 burglaries in a single 2024 month -> 24/yr bar, present in 1 year. + _write_month( + crime, + "2024-01", + [ + _crime_row("2024-01", 1005, 1005, "Burglary"), + _crime_row("2024-01", 1005, 1005, "Burglary"), + ], + ) + # Q: 1 burglary in a far-back 2014 month -> widens the type's global span to + # two years without adding any incident to P. + _write_month(crime, "2014-01", [_crime_row("2014-01", 5005, 5005, "Burglary")]) + + output = tmp_path / "crime_by_postcode.parquet" + by_year = tmp_path / "crime_by_postcode_by_year.parquet" + transform_crime_spatial(crime, units, output, by_year, buffer_m=50.0) + + rows = {r["postcode"]: r for r in pl.read_parquet(output).to_dicts()} + by_year_rows = { + r["postcode"]: r for r in pl.read_parquet(by_year).to_dicts() + } + + # P's headline equals the simple mean of its own bars (just the 2024 bar). + p_bars = {p["year"]: p["count"] for p in by_year_rows["AB1 1AA"]["Burglary (by year)"]} + assert p_bars == {2024: pytest.approx(24.0, abs=0.05)} + # Per-postcode denominator (1) -> 24.0. The old global denominator (2 years + # across all postcodes) would have deflated this to 12.0. + assert rows["AB1 1AA"]["Burglary (avg/yr)"] == pytest.approx(24.0, abs=0.05) + assert rows["AB1 1AA"]["Burglary (avg/yr)"] == pytest.approx( + sum(p_bars.values()) / len(p_bars), abs=0.05 + ) + + # Q likewise: its sole 2014 bar -> 12/yr, divided by its own 1 year = 12.0. + q_bars = {p["year"]: p["count"] for p in by_year_rows["AB1 1AB"]["Burglary (by year)"]} + assert q_bars == {2014: pytest.approx(12.0, abs=0.05)} + assert rows["AB1 1AB"]["Burglary (avg/yr)"] == pytest.approx(12.0, abs=0.05) + + def test_unknown_crime_type_is_dropped_with_warning(tmp_path, capsys): units = tmp_path / "units" _write_boundaries( diff --git a/pipeline/transform/test_join_epc_pp.py b/pipeline/transform/test_join_epc_pp.py index 7484ba0..e10fde1 100644 --- a/pipeline/transform/test_join_epc_pp.py +++ b/pipeline/transform/test_join_epc_pp.py @@ -149,6 +149,7 @@ def test_run_joins_domestic_zip_with_price_paid(tmp_path: Path): "town_city": ["Exampletown", "Exampletown"], "duration": ["F", "F"], "old_new": ["N", "N"], + "ppd_category": ["A", "A"], } ).write_parquet(price_paid_path) @@ -201,6 +202,7 @@ def test_run_excludes_price_paid_rows_without_full_postcode(tmp_path: Path): "town_city": ["Exampletown", "Exampletown"], "duration": ["F", "F"], "old_new": ["N", "N"], + "ppd_category": ["A", "A"], } ).write_parquet(price_paid_path) @@ -235,6 +237,7 @@ def test_run_does_not_attach_epc_facts_to_low_score_address_match(tmp_path: Path "town_city": ["Exampletown"], "duration": ["F"], "old_new": ["N"], + "ppd_category": ["A"], } ).write_parquet(price_paid_path) @@ -259,6 +262,93 @@ def test_run_does_not_attach_epc_facts_to_low_score_address_match(tmp_path: Path ] +def test_run_excludes_category_b_sales_from_price_aggregations(tmp_path: Path): + # Category B entries (repossessions, bulk/portfolio, power-of-sale) must not + # pollute latest_price / historical_prices, but the property still survives + # via its standard Category A sales. + zip_path = tmp_path / "domestic-csv.zip" + with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as archive: + csv_buffer = io.StringIO() + writer = csv.DictWriter(csv_buffer, fieldnames=EPC_SOURCE_COLUMNS) + writer.writeheader() + writer.writerow(_row()) + archive.writestr("certificates-2024.csv", csv_buffer.getvalue()) + + price_paid_path = tmp_path / "price-paid.parquet" + pl.DataFrame( + { + "price": [200_000, 250_000, 5_000_000], + "date_of_transfer": [date(2020, 2, 3), date(2022, 2, 3), date(2024, 2, 3)], + "property_type": ["T", "T", "T"], + "postcode": ["AA1 1AA", "AA1 1AA", "AA1 1AA"], + "paon": ["1", "1", "1"], + "saon": [None, None, None], + "street": ["Example Street", "Example Street", "Example Street"], + "locality": [None, None, None], + "town_city": ["Exampletown", "Exampletown", "Exampletown"], + "duration": ["F", "F", "F"], + "old_new": ["N", "N", "N"], + # The latest (5M) sale is a Category B bulk/portfolio transfer. + "ppd_category": ["A", "A", "B"], + } + ).write_parquet(price_paid_path) + + output_path = tmp_path / "epc-pp.parquet" + _run(zip_path, price_paid_path, output_path, tmp_path) + + df = pl.read_parquet(output_path) + + assert df.height == 1 + # Only the two Category A sales survive; the 5M Category B transfer is dropped. + assert df.get_column("latest_price").to_list() == [250_000] + assert df.get_column("historical_prices").list.len().to_list() == [2] + + +def test_run_new_build_keeps_early_first_transfer_when_sub_min_price(tmp_path: Path): + # A new-build whose earliest sale is below MIN_PRICE must still take that early + # year as its EXACT construction date, while latest_price uses only the + # quality-passing (>=MIN_PRICE) sale. + zip_path = tmp_path / "domestic-csv.zip" + with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as archive: + csv_buffer = io.StringIO() + writer = csv.DictWriter(csv_buffer, fieldnames=EPC_SOURCE_COLUMNS) + writer.writeheader() + writer.writerow(_row()) + archive.writestr("certificates-2024.csv", csv_buffer.getvalue()) + + price_paid_path = tmp_path / "price-paid.parquet" + pl.DataFrame( + { + "price": [30_000, 300_000], + "date_of_transfer": [date(2015, 2, 3), date(2022, 2, 3)], + "property_type": ["T", "T"], + "postcode": ["AA1 1AA", "AA1 1AA"], + "paon": ["1", "1"], + "saon": [None, None], + "street": ["Example Street", "Example Street"], + "locality": [None, None], + "town_city": ["Exampletown", "Exampletown"], + "duration": ["F", "F"], + "old_new": ["Y", "Y"], + "ppd_category": ["A", "A"], + } + ).write_parquet(price_paid_path) + + output_path = tmp_path / "epc-pp.parquet" + _run(zip_path, price_paid_path, output_path, tmp_path) + + df = pl.read_parquet(output_path) + + assert df.height == 1 + # Construction year is the genuine earliest transfer (2015), flagged EXACT, + # even though that sale is below MIN_PRICE. + assert df.get_column("construction_age_band").to_list() == [2015] + assert df.get_column("is_construction_date_approximate").to_list() == [0] + # latest_price uses only the >=MIN_PRICE sale; the sub-MIN sale is excluded. + assert df.get_column("latest_price").to_list() == [300_000] + assert df.get_column("historical_prices").list.len().to_list() == [1] + + def test_epc_band_to_year_uses_midpoint_and_clamps(): import polars as pl diff --git a/pipeline/transform/test_merge.py b/pipeline/transform/test_merge.py index 7672d55..482cc1c 100644 --- a/pipeline/transform/test_merge.py +++ b/pipeline/transform/test_merge.py @@ -13,7 +13,9 @@ from pipeline.transform.merge import ( _active_english_postcode_area, _build_unmatched_listing_seed_rows, _canonical_postcode_expr, + _coalesce_direct_epc_columns, _filter_to_active_english_postcodes, + _join_area_side_tables, _finalize_listings, _integrate_listings, _match_direct_epc, @@ -506,6 +508,25 @@ def test_load_listings_for_merge_canonicalises_and_exposes_overlay_columns( assert loaded["_actual_lat"].to_list() == [51.5] +def test_load_listings_for_merge_uprn_key_matches_normalize_uprn(tmp_path) -> None: + # A Float UPRN (e.g. read from a NaN-bearing parquet column) must produce + # the same digits-only key as `_normalize_uprn` on the candidate side, so + # the exact UPRN match is not lost. Naively stringifying "100023336956.0" + # and stripping non-digits would yield "1000233369560" (a bogus trailing + # zero) which never collides with the candidate key "100023336956". + listings_path = tmp_path / "listings.parquet" + arcgis_path = tmp_path / "arcgis.parquet" + _sample_listings_frame().with_columns( + pl.lit(100023336956.0, dtype=pl.Float64).alias("UPRN") + ).write_parquet(listings_path) + _stub_arcgis(arcgis_path) + + loaded = _load_listings_for_merge(listings_path, arcgis_path) + + assert loaded["_listing_uprn"].to_list() == [_normalize_uprn(100023336956.0)] + assert loaded["_listing_uprn"].to_list() == ["100023336956"] + + def test_build_unmatched_listing_seed_rows_fills_property_shape_fields( tmp_path, ) -> None: @@ -697,6 +718,110 @@ def test_normalize_uprn_handles_types_and_floats() -> None: assert _normalize_uprn(float("nan")) is None +def test_coalesce_direct_epc_was_council_house_prefers_yes() -> None: + # The raw property value is fill_null("No") upstream, so a plain coalesce + # would let a non-null "No" override a directly-matched listing "Yes". + # "Former council house" should fire if EITHER side says "Yes". + none_col = [None] * 5 + wide = pl.LazyFrame( + { + "was_council_house": ["No", "Yes", "No", None, None], + "_direct_was_council_house": ["Yes", "No", None, "Yes", None], + # An unrelated direct-EPC column keeps the plain-coalesce behaviour. + "current_energy_rating": [None, "C", "D", None, None], + "_direct_current_energy_rating": ["B", "A", None, "E", None], + # _coalesce_direct_epc_columns coalesces every pair in + # _DIRECT_EPC_RAW_COLUMN_MAP, so the rest must be present too. + "epc_address": none_col, + "_direct_epc_address": none_col, + "potential_energy_rating": none_col, + "_direct_potential_energy_rating": none_col, + "total_floor_area": none_col, + "_direct_total_floor_area": none_col, + "number_habitable_rooms": none_col, + "_direct_number_habitable_rooms": none_col, + "floor_height": none_col, + "_direct_floor_height": none_col, + "construction_age_band": none_col, + "_direct_construction_age_band": none_col, + "is_construction_date_approximate": none_col, + "_direct_is_construction_date_approximate": none_col, + } + ) + + result = _coalesce_direct_epc_columns(wide).collect() + + assert result["was_council_house"].to_list() == ["Yes", "Yes", "No", "Yes", None] + # Plain coalesce (raw wins when non-null) is untouched for other columns. + assert result["current_energy_rating"].to_list() == ["B", "C", "D", "E", None] + + +def test_join_area_side_tables_preserves_missing_crime_as_null() -> None: + # The crime table is LEFT-joined per postcode; a postcode absent from it + # must NOT be fabricated as "zero crime" (the safest value). When every + # per-type column is null the Serious/Minor rollups must stay null. + base = pl.LazyFrame( + { + "postcode": ["AA1 1AA", "BB2 2BB"], + "lsoa21": ["E01000001", "E01000002"], + "Local Authority District code (2024)": ["E09000001", "E09000002"], + "pcon": ["E14000001", "E14000002"], + } + ) + + def _by_postcode(extra: dict) -> pl.LazyFrame: + return pl.LazyFrame({"postcode": ["AA1 1AA", "BB2 2BB"], **extra}) + + # Crime is present only for AA1 1AA; BB2 2BB is absent from the table. + crime = pl.LazyFrame( + { + "postcode": ["AA1 1AA"], + "Violence and sexual offences (avg/yr)": [1.0], + "Robbery (avg/yr)": [2.0], + "Burglary (avg/yr)": [3.0], + "Possession of weapons (avg/yr)": [4.0], + "Anti-social behaviour (avg/yr)": [1.0], + "Criminal damage and arson (avg/yr)": [1.0], + "Shoplifting (avg/yr)": [1.0], + "Bicycle theft (avg/yr)": [1.0], + "Theft from the person (avg/yr)": [1.0], + "Other theft (avg/yr)": [1.0], + "Vehicle crime (avg/yr)": [1.0], + "Public order (avg/yr)": [1.0], + "Drugs (avg/yr)": [1.0], + "Other crime (avg/yr)": [1.0], + } + ) + + joined = _join_area_side_tables( + base, + iod=pl.LazyFrame({"LSOA code (2021)": ["E01000001", "E01000002"]}), + ethnicity=pl.LazyFrame({"Geography_code": ["E09000001", "E09000002"]}), + crime=crime, + median_age=pl.LazyFrame({"lsoa21": ["E01000001", "E01000002"]}), + election=pl.LazyFrame({"pcon": ["E14000001", "E14000002"]}), + poi_counts=_by_postcode({}), + noise=_by_postcode({}), + school_proximity=_by_postcode({}), + conservation_areas=_by_postcode({CONSERVATION_AREA_FEATURE: ["Yes", "No"]}), + tree_density=None, + broadband=pl.LazyFrame({"bb_postcode": ["AA1 1AA", "BB2 2BB"]}), + ).collect() + + by_postcode = { + row["postcode"]: row + for row in joined.select( + "postcode", "serious_crime_avg_yr", "minor_crime_avg_yr" + ).iter_rows(named=True) + } + # Present postcode: rollups are the component sums (1+2+3+4, 10×1). + assert by_postcode["AA1 1AA"]["serious_crime_avg_yr"] == 10.0 + assert by_postcode["AA1 1AA"]["minor_crime_avg_yr"] == 10.0 + # Missing postcode: rollups stay null rather than fabricating 0.0. + assert by_postcode["BB2 2BB"]["serious_crime_avg_yr"] is None + assert by_postcode["BB2 2BB"]["minor_crime_avg_yr"] is None + + def _property_candidates(rows: list[dict]) -> pl.DataFrame: base = { "postcode": "AA1 1AA", diff --git a/pipeline/transform/test_poi_proximity.py b/pipeline/transform/test_poi_proximity.py index e584d18..9ba233f 100644 --- a/pipeline/transform/test_poi_proximity.py +++ b/pipeline/transform/test_poi_proximity.py @@ -1,9 +1,44 @@ import polars as pl from pipeline.transform.poi_proximity import ( + POI_GROUPS_2KM, _build_poi_category_groups, _dynamic_poi_metric_renames, + _groceries_categories, ) +from pipeline.utils.poi_counts import count_pois_per_postcode + + +def test_groceries_2km_counts_geolytix_brand_categories() -> None: + """The static groceries 2km count must include GEOLYTIX brand POIs. + + GEOLYTIX stores the brand (e.g. "Tesco") in `category` with group + "Groceries" and never emits the literal "Supermarket"; matching only the + OSM strings counts the supermarket but drops the brand store. + """ + postcodes = pl.DataFrame( + { + "postcode": ["SW1A 1AA"], + "lat": [51.5010], + "lon": [-0.1416], + } + ) + pois = pl.DataFrame( + { + "category": ["Tesco", "Supermarket"], + "group": ["Groceries", "Groceries"], + "lat": [51.5011, 51.5012], + "lng": [-0.1417, -0.1418], + } + ) + + groups_2km = {**POI_GROUPS_2KM, "groceries": _groceries_categories(pois)} + result = count_pois_per_postcode(postcodes, pois, groups=groups_2km, radius_km=2) + + # Both the GEOLYTIX brand ("Tesco") and the OSM "Supermarket" must count. + # Pre-fix the static list was ["Greengrocer", "Supermarket", "Convenience + # Store"], so "Tesco" was dropped and this was 1. + assert result["groceries_2km"][0] == 2 def test_dynamic_poi_groups_include_requested_categories_only() -> None: diff --git a/pipeline/transform/test_transform_poi.py b/pipeline/transform/test_transform_poi.py index c9a067f..b6078a3 100644 --- a/pipeline/transform/test_transform_poi.py +++ b/pipeline/transform/test_transform_poi.py @@ -1,6 +1,10 @@ import polars as pl -from pipeline.transform.transform_poi import transform_grocery_retail_points +from pipeline.transform.transform_poi import ( + _load_ofsted_ratings, + _school_icon_category_expr, + transform_grocery_retail_points, +) def test_transform_grocery_retail_points_outputs_chain_categories(): @@ -112,6 +116,33 @@ def test_transform_grocery_retail_points_merges_cooperative_societies(): ] +def test_transform_grocery_retail_points_pools_small_coop_societies_before_cutoff(): + # Each Co-op society has <5 in-England stores; only after normalising to the + # shared "Co-op" brand do they clear MIN_GROCERY_CHAIN_LOCATIONS together. + societies = [ + "Central England Co-operative", + "Lincolnshire Co-operative", + "The Southern Co-operative", + "Midcounties Co-operative", + "Heart of England Co-operative", + ] + raw = pl.DataFrame( + { + "id": list(range(1, len(societies) + 1)), + "retailer": societies, + "fascia": ["The Co-operative Food"] * len(societies), + "store_name": [f"Co-op Test {i}" for i in range(1, len(societies) + 1)], + "long_wgs": [-0.141] * len(societies), + "lat_wgs": [51.515] * len(societies), + } + ) + + pois = transform_grocery_retail_points(raw) + + assert pois.height == len(societies) + assert pois["category"].unique().to_list() == ["Co-op"] + + def test_transform_grocery_retail_points_accepts_base_fascias(): raw = pl.DataFrame( { @@ -177,3 +208,87 @@ def test_transform_grocery_retail_points_includes_unmapped_chains_with_five_loca {"id": "glx-4", "category": "Tian Tian", "icon_category": "Tian Tian"}, {"id": "glx-5", "category": "Tian Tian", "icon_category": "Tian Tian"}, ] + + +def test_load_ofsted_ratings_falls_back_to_ungraded_outcome(tmp_path): + # URNs 1-4: graded results map straight through. URNs 5-6: no usable graded + # grade (null/"Not judged") but a good/outstanding ungraded outcome, incl. + # the "(Concerns)"/"(Improving)" suffixes. URN 7: genuinely "Not judged". + # URN 8: a real grade 3 must NOT be overridden by an ungraded outcome. + ofsted_path = tmp_path / "ofsted.parquet" + pl.DataFrame( + { + "URN": [1, 2, 3, 4, 5, 6, 7, 8], + "Latest OEIF overall effectiveness": [ + "1", + "2", + "3", + "4", + None, + "Not judged", + "Not judged", + "3", + ], + "Ungraded inspection overall outcome": [ + None, + None, + None, + None, + "School remains Outstanding", + "School remains Good (Concerns)", + None, + "School remains Outstanding", + ], + } + ).write_parquet(ofsted_path) + + ratings = ( + _load_ofsted_ratings(ofsted_path) + .collect() + .sort("urn") + .to_dicts() + ) + + assert ratings == [ + {"urn": 1, "ofsted_rating": "Outstanding"}, + {"urn": 2, "ofsted_rating": "Good"}, + {"urn": 3, "ofsted_rating": "Requires improvement"}, + {"urn": 4, "ofsted_rating": "Inadequate"}, + {"urn": 5, "ofsted_rating": "Outstanding"}, + {"urn": 6, "ofsted_rating": "Good"}, + {"urn": 7, "ofsted_rating": "Not judged"}, + {"urn": 8, "ofsted_rating": "Requires improvement"}, + ] + + +def test_school_icon_category_handles_one_sided_age_ranges(): + # gias._format_age_range emits "up to {high}", "{low}+" and "{low}–{high}". + # All three (plus null) must classify, not fall through to "School". + df = pl.DataFrame( + { + "phase": [None, None, None, None, None], + "type_group": [None, None, None, None, None], + # "up to 5" -> nursery; "16+" -> sixth form; "3–18" -> all-through; + # "4–11" -> primary; null age_range with null phase -> "School". + "age_range": ["up to 5", "16+", "3–18", "4–11", None], + }, + # Production reads these from a scanned parquet as String; an all-null + # Python list would otherwise infer the Null dtype and break .str ops. + schema_overrides={ + "phase": pl.String, + "type_group": pl.String, + "age_range": pl.String, + }, + ) + + categories = df.select( + _school_icon_category_expr().alias("category") + )["category"].to_list() + + assert categories == [ + "Nursery school", + "Sixth form", + "All-through school", + "Primary school", + "School", + ] diff --git a/pipeline/transform/transform_poi.py b/pipeline/transform/transform_poi.py index 72703aa..8109d8a 100644 --- a/pipeline/transform/transform_poi.py +++ b/pipeline/transform/transform_poi.py @@ -1289,22 +1289,27 @@ def transform_grocery_retail_points( ) df = df.filter(pl.Series(mask)) - eligible_retailers = ( - df.group_by("retailer") + # Normalise to the display brand FIRST so the ~16 Co-op society retailer + # names pool into one "Co-op" before the chain-eligibility cutoff; otherwise + # small societies (<MIN_GROCERY_CHAIN_LOCATIONS stores each) get dropped. + df = df.with_columns( + pl.col("retailer") + .map_elements(normalize_grocery_retailer, return_dtype=pl.String) + .alias("category") + ) + eligible_categories = ( + df.group_by("category") .len() .filter(pl.col("len") >= min_chain_locations) - .select("retailer") + .select("category") ) - df = df.join(eligible_retailers, on="retailer", how="semi") + df = df.join(eligible_categories, on="category", how="semi") return df.with_columns( pl.concat_str([pl.lit("glx-"), pl.col("id")]).alias("id"), pl.coalesce(["store_name", "fascia", "retailer"]) .str.replace_all("''", "'") .alias("name"), - pl.col("retailer") - .map_elements(normalize_grocery_retailer, return_dtype=pl.String) - .alias("category"), pl.struct(["fascia", "retailer"]) .map_elements( lambda row: normalize_grocery_icon_category(row["fascia"], row["retailer"]), @@ -1338,10 +1343,16 @@ def _school_icon_category_expr() -> pl.Expr: # GIAS phase mixes casing ("Middle deemed Primary" vs "Middle deemed # primary") so we normalise before matching. phase = pl.col("phase").str.to_lowercase() - # age_range is "<min>–<max>" using an em-dash; both ends may be missing. - age_parts = pl.col("age_range").str.split_exact("–", 1) - min_age = age_parts.struct.field("field_0").cast(pl.Int32, strict=False) - max_age = age_parts.struct.field("field_1").cast(pl.Int32, strict=False) + # gias._format_age_range emits three shapes: "<low>–<high>" (em-dash), + # "up to <high>" (high-only) and "<low>+" (low-only). Extract the leading + # integer as low and the trailing integer as high, then suppress the wrong + # end for the one-sided shapes so they don't collapse to a single bound. + age = pl.col("age_range") + leading = age.str.extract(r"^\s*(\d+)", 1).cast(pl.Int32, strict=False) + trailing = age.str.extract(r"(\d+)\s*$", 1).cast(pl.Int32, strict=False) + # "up to N": no low bound; "N+": no high bound. + min_age = pl.when(age.str.starts_with("up to")).then(None).otherwise(leading) + max_age = pl.when(age.str.ends_with("+")).then(None).otherwise(trailing) return ( pl.when(pl.col("type_group") == "Universities") .then(pl.lit("University")) @@ -1386,9 +1397,16 @@ OFSTED_OEIF_LABELS = { def _load_ofsted_ratings(ofsted_path: Path) -> pl.LazyFrame: """Project the latest OEIF effectiveness grade to a human-readable label, keyed by URN so it can be joined onto the GIAS register. Grades 1-4 map to - the conventional Ofsted labels; "Not judged" (post-2025 reform schools that - only have a report card) is preserved verbatim; null grades drop out.""" + the conventional Ofsted labels; when there is no usable graded result + (null/"Not judged", e.g. schools last seen under the post-2024 ungraded + report-card framework) we fall back to "Ungraded inspection overall outcome" + so genuinely good/outstanding schools aren't dropped — mirroring + school_proximity.classify_good_plus_schools. Remaining nulls drop out.""" grade_col = pl.col("Latest OEIF overall effectiveness") + # See school_proximity: the ungraded outcome carries "School remains Good"/ + # "School remains Outstanding" (with optional "(Concerns)"/"(Improving)" + # suffixes) when the graded column is null/"Not judged". + ungraded = pl.col("Ungraded inspection overall outcome").cast(pl.Utf8, strict=False) label = ( pl.when(grade_col == "1") .then(pl.lit(OFSTED_OEIF_LABELS["1"])) @@ -1398,6 +1416,10 @@ def _load_ofsted_ratings(ofsted_path: Path) -> pl.LazyFrame: .then(pl.lit(OFSTED_OEIF_LABELS["3"])) .when(grade_col == "4") .then(pl.lit(OFSTED_OEIF_LABELS["4"])) + .when(ungraded.str.starts_with("School remains Outstanding")) + .then(pl.lit(OFSTED_OEIF_LABELS["1"])) + .when(ungraded.str.starts_with("School remains Good")) + .then(pl.lit(OFSTED_OEIF_LABELS["2"])) .when(grade_col == "Not judged") .then(pl.lit("Not judged")) .otherwise(None) diff --git a/pipeline/utils/fuzzy_join.py b/pipeline/utils/fuzzy_join.py index 2870739..d638bc7 100644 --- a/pipeline/utils/fuzzy_join.py +++ b/pipeline/utils/fuzzy_join.py @@ -13,7 +13,12 @@ from pipeline.local_temp import local_tmp_dir _NUMBER_RE = re.compile(r"\d+") _POSTCODE_RE = r"^[A-Z]{1,2}\d[A-Z\d]?\d[A-Z]{2}$" -MIN_FUZZY_SCORE = 60 +# A house number is a strong disambiguator, so a numbered, number-compatible +# pair may match on a lower address-similarity score than a number-less one +# (named houses / flats by building name), which must match almost exactly to +# be trusted. Mirrors merge.py's listings convention. +MIN_FUZZY_SCORE = 82 +MIN_FUZZY_SCORE_WITHOUT_NUMBERS = 90 def normalize_address_key(s: pl.Expr) -> pl.Expr: @@ -47,6 +52,7 @@ def fuzzy_join_on_postcode( left_postcode_col: str, right_postcode_col: str, min_score: int = MIN_FUZZY_SCORE, + min_score_without_numbers: int = MIN_FUZZY_SCORE_WITHOUT_NUMBERS, ) -> pl.LazyFrame: """Fuzzy join two LazyFrames by matching addresses within postcode buckets. @@ -120,7 +126,12 @@ def fuzzy_join_on_postcode( # Build tasks for each postcode bucket tasks = [ - (left_entries, right_by_postcode[postcode], min_score) + ( + left_entries, + right_by_postcode[postcode], + min_score, + min_score_without_numbers, + ) for postcode, left_entries in left_by_postcode.items() if postcode in right_by_postcode ] @@ -201,16 +212,23 @@ def _numbers_compatible(a: str, b: str) -> bool: def _score_bucket( - args: tuple[list[tuple[int, str]], list[tuple[int, str]], int], + args: tuple[list[tuple[int, str]], list[tuple[int, str]], int, int], ) -> list[tuple[int, int, int]]: """Score all address pairs within a single postcode bucket.""" - left_entries, right_entries, min_score = args + left_entries, right_entries, min_score, min_score_without_numbers = args pairs = [] for left_row, left_address in left_entries: for right_row, right_address in right_entries: if not _numbers_compatible(left_address, right_address): continue score = fuzz.token_sort_ratio(left_address, right_address) - if score >= min_score: + # Number-less pairs (named houses, building-name flats) lack the + # house-number disambiguator, so require a near-exact match. + threshold = ( + min_score + if _NUMBER_RE.search(left_address) or _NUMBER_RE.search(right_address) + else min_score_without_numbers + ) + if score >= threshold: pairs.append((score, left_row, right_row)) return pairs diff --git a/pipeline/utils/postcode_mapping.py b/pipeline/utils/postcode_mapping.py index f8383d8..08fab17 100644 --- a/pipeline/utils/postcode_mapping.py +++ b/pipeline/utils/postcode_mapping.py @@ -6,6 +6,16 @@ import numpy as np import polars as pl from scipy.spatial import cKDTree +# Maximum distance (in OS National Grid metres) a terminated postcode may be from its +# nearest active successor to be remapped. Beyond this we treat the postcode as having no +# legitimate successor (e.g. demolished/redeveloped land) rather than re-homing it onto a +# geometrically-nearest-but-unrelated postcode on a different street/estate/LSOA, which +# would pollute the successor's crime/deprivation/school/noise/rent and price stats. +# 1km is conservative: it keeps legitimate adjacent remaps while dropping gross +# misattributions; dropped postcodes keep their terminated code and fall out at the +# active-postcode filter downstream (the honest outcome confirmed by the merge audit). +MAX_REMAP_DISTANCE_M = 1000.0 + def build_postcode_mapping(arcgis_path: Path) -> pl.DataFrame: """Build a mapping from terminated England postcodes to their nearest active postcode. @@ -50,18 +60,30 @@ def build_postcode_mapping(arcgis_path: Path) -> pl.DataFrame: ) tree = cKDTree(active_coords) - distances, indices = tree.query(terminated_coords) + distances, indices = tree.query( + terminated_coords, distance_upper_bound=MAX_REMAP_DISTANCE_M + ) + + # cKDTree returns distance=inf and index==len(active) for points with no neighbour + # within the bound. Drop those terminated postcodes rather than gather an out-of-range + # index; they keep their terminated code and fall out at the active-postcode filter. + within_bound = np.isfinite(distances) + dropped = int((~within_bound).sum()) active_postcodes = active["pcds"] mapping = pl.DataFrame( { - "old_postcode": terminated["pcds"], - "new_postcode": active_postcodes.gather(indices), + "old_postcode": terminated["pcds"].filter(pl.Series(within_bound)), + "new_postcode": active_postcodes.gather(indices[within_bound]), } ) + kept_distances = distances[within_bound] print( - f"Postcode mapping: max distance = {distances.max():.0f}m, median = {np.median(distances):.0f}m" + f"Postcode mapping: {dropped} terminated postcodes dropped (> {MAX_REMAP_DISTANCE_M:.0f}m), " + f"max distance = {kept_distances.max():.0f}m, median = {np.median(kept_distances):.0f}m" + if kept_distances.size + else f"Postcode mapping: {dropped} terminated postcodes dropped (> {MAX_REMAP_DISTANCE_M:.0f}m), none remapped" ) return mapping diff --git a/pipeline/utils/test_fuzzy_join.py b/pipeline/utils/test_fuzzy_join.py index 1632739..28d0dfc 100644 --- a/pipeline/utils/test_fuzzy_join.py +++ b/pipeline/utils/test_fuzzy_join.py @@ -134,6 +134,91 @@ def test_fuzzy_join_on_postcode_rejects_blank_and_invalid_match_keys(): ] +def test_fuzzy_join_rejects_mid_score_number_less_match(): + # "THE COACH HOUSE" vs "THE OLD COACH HOUSE" scores 88 via token_sort_ratio: + # above the old MIN_FUZZY_SCORE of 60 (so it used to falsely match) but below + # the number-less threshold of 90, so it must NOT match now. + left = pl.LazyFrame( + { + "left_address": ["The Coach House"], + "left_postcode": ["AB1 2CD"], + } + ) + right = pl.LazyFrame( + { + "right_address": ["The Old Coach House"], + "right_postcode": ["AB1 2CD"], + } + ) + + result = fuzzy_join_on_postcode( + left=left, + right=right, + left_address_col="left_address", + right_address_col="right_address", + left_postcode_col="left_postcode", + right_postcode_col="right_postcode", + ).collect() + + assert result["right_address"].to_list() == [None] + + +def test_fuzzy_join_matches_numbered_pair_at_baseline_threshold(): + # "10 ACACIA AVENUE" vs "FLAT A 10 ACACIA AVENUE" scores exactly 82 and the + # house number is compatible, so the numbered baseline (>= 82) still matches. + left = pl.LazyFrame( + { + "left_address": ["10 Acacia Avenue"], + "left_postcode": ["AB1 2CD"], + } + ) + right = pl.LazyFrame( + { + "right_address": ["Flat A, 10 Acacia Avenue"], + "right_postcode": ["AB1 2CD"], + } + ) + + result = fuzzy_join_on_postcode( + left=left, + right=right, + left_address_col="left_address", + right_address_col="right_address", + left_postcode_col="left_postcode", + right_postcode_col="right_postcode", + ).collect() + + assert result["right_address"].to_list() == ["Flat A, 10 Acacia Avenue"] + + +def test_fuzzy_join_matches_high_score_number_less_pair(): + # A number-less pair that clears the 90 threshold (here an exact token match, + # score 100) must still match. + left = pl.LazyFrame( + { + "left_address": ["The Old Rectory"], + "left_postcode": ["AB1 2CD"], + } + ) + right = pl.LazyFrame( + { + "right_address": ["THE OLD RECTORY"], + "right_postcode": ["AB1 2CD"], + } + ) + + result = fuzzy_join_on_postcode( + left=left, + right=right, + left_address_col="left_address", + right_address_col="right_address", + left_postcode_col="left_postcode", + right_postcode_col="right_postcode", + ).collect() + + assert result["right_address"].to_list() == ["THE OLD RECTORY"] + + def test_normalize_postcode_key_requires_full_postcode(): df = pl.DataFrame( { diff --git a/server-rs/src/data.rs b/server-rs/src/data.rs index 3cc65c1..e941e80 100644 --- a/server-rs/src/data.rs +++ b/server-rs/src/data.rs @@ -37,7 +37,9 @@ where pub use actual_listings::{ActualListing, ActualListingData}; pub use crime_by_year::CrimeByYearData; -pub use places::{normalize_search_text, PlaceData}; +pub use places::{ + compute_trigrams, normalize_search_text, place_alias_tokens, trigram_similarity, PlaceData, +}; pub use poi::{resolve_poi_category_filter, POICategoryGroup, POIData, SchoolMetadata}; pub use postcodes::{OutcodeData, PostcodeData}; pub use property::{ diff --git a/server-rs/src/data/crime_by_year.rs b/server-rs/src/data/crime_by_year.rs index 2c99c1e..cba947f 100644 --- a/server-rs/src/data/crime_by_year.rs +++ b/server-rs/src/data/crime_by_year.rs @@ -120,7 +120,7 @@ impl CrimeByYearData { .list() .with_context(|| format!("Column '{col_name}' is not a list"))?; - for row in 0..row_count { + for (row, postcode) in postcode_values.iter().enumerate().take(row_count) { let Some(inner) = list_ca.get_as_series(row) else { continue; }; @@ -163,7 +163,7 @@ impl CrimeByYearData { points.sort_by_key(|p| p.year); series_by_postcode - .entry(postcode_values[row].clone()) + .entry(postcode.clone()) .or_default() .push(PostcodeCrimeSeries { type_idx: type_idx as u16, diff --git a/server-rs/src/data/places.rs b/server-rs/src/data/places.rs index cc9579c..4d4744a 100644 --- a/server-rs/src/data/places.rs +++ b/server-rs/src/data/places.rs @@ -4,10 +4,16 @@ use anyhow::Context; use polars::frame::DataFrame; use polars::lazy::frame::LazyFrame; use polars::prelude::*; +use rustc_hash::FxHashMap; use tracing::info; use crate::utils::InternedColumn; +/// Upper bound on place rows scored per query (candidate sets are normally far smaller). +const PLACE_CANDIDATE_LIMIT: usize = 50_000; +const PLACE_PREFIX_MIN_LEN: usize = 2; +const PLACE_PREFIX_MAX_LEN: usize = 6; + pub struct PlaceData { pub name: Vec<String>, pub name_lower: Vec<String>, @@ -19,6 +25,13 @@ pub struct PlaceData { pub lon: Vec<f32>, pub city: Vec<Option<String>>, pub travel_destination: Vec<bool>, + /// Inverted index from an alias token to the (ascending) place rows containing it. Lets place + /// search gather candidates instead of scanning all ~1M+ rows per keystroke. + token_index: FxHashMap<String, Vec<u32>>, + /// Prefix → indexed tokens, for matching a partially-typed final word. + token_prefix_index: FxHashMap<String, Vec<String>>, + /// Trigram → fuzzy-eligible rows (settlements/stations only), for bounded typo matching. + fuzzy_trigram_index: FxHashMap<u32, Vec<u32>>, } #[derive(Clone, Copy)] @@ -168,6 +181,148 @@ pub fn normalize_search_text(text: &str) -> String { result } +/// Tokens across all of a place's search aliases (split on word and alias separators), +/// for token-AND matching where every query word must prefix-match some place token. +pub fn place_alias_tokens(search_text: &str) -> impl Iterator<Item = &str> { + search_text + .split([' ', '|']) + .filter(|token| !token.is_empty()) +} + +fn trigram_hash(first: char, second: char, third: char) -> u32 { + let mut hash = 2_166_136_261u32; + for ch in [first, second, third] { + hash = (hash ^ (ch as u32)).wrapping_mul(16_777_619); + } + hash +} + +/// Sorted, de-duplicated padded character trigrams of `text`, for Jaccard fuzzy matching. +pub fn compute_trigrams(text: &str) -> Vec<u32> { + let norm = normalize_search_text(text); + if norm.is_empty() { + return Vec::new(); + } + let chars: Vec<char> = [' ', ' '] + .into_iter() + .chain(norm.chars()) + .chain(std::iter::once(' ')) + .collect(); + let mut grams: Vec<u32> = chars + .windows(3) + .map(|window| trigram_hash(window[0], window[1], window[2])) + .collect(); + grams.sort_unstable(); + grams.dedup(); + grams +} + +/// Intersect two ascending-sorted row-id slices. +fn intersect_sorted(left: &[u32], right: &[u32]) -> Vec<u32> { + let mut out = Vec::new(); + let (mut i, mut j) = (0, 0); + while i < left.len() && j < right.len() { + match left[i].cmp(&right[j]) { + std::cmp::Ordering::Less => i += 1, + std::cmp::Ordering::Greater => j += 1, + std::cmp::Ordering::Equal => { + out.push(left[i]); + i += 1; + j += 1; + } + } + } + out +} + +/// Union two ascending-sorted row-id slices (deduplicated, stays sorted). +fn union_sorted(left: &[u32], right: &[u32]) -> Vec<u32> { + let mut out = Vec::with_capacity(left.len() + right.len()); + let (mut i, mut j) = (0, 0); + while i < left.len() && j < right.len() { + match left[i].cmp(&right[j]) { + std::cmp::Ordering::Less => { + out.push(left[i]); + i += 1; + } + std::cmp::Ordering::Greater => { + out.push(right[j]); + j += 1; + } + std::cmp::Ordering::Equal => { + out.push(left[i]); + i += 1; + j += 1; + } + } + } + out.extend_from_slice(&left[i..]); + out.extend_from_slice(&right[j..]); + out +} + +/// Distinct indexable tokens (len ≥ 2) across all of a place's search aliases. ASCII because +/// `normalize_search_text` already dropped non-alphanumerics, so prefix byte-slicing is safe. +fn place_index_tokens(search_text: &str) -> Vec<String> { + let mut tokens: Vec<String> = place_alias_tokens(search_text) + .filter(|token| token.len() >= 2) + .map(ToString::to_string) + .collect(); + tokens.sort_unstable(); + tokens.dedup(); + tokens +} + +fn build_place_prefix_index( + token_index: &FxHashMap<String, Vec<u32>>, +) -> FxHashMap<String, Vec<String>> { + let mut prefix_index: FxHashMap<String, Vec<String>> = FxHashMap::default(); + for token in token_index.keys() { + let max_len = token.len().min(PLACE_PREFIX_MAX_LEN); + for len in PLACE_PREFIX_MIN_LEN..=max_len { + prefix_index + .entry(token[..len].to_string()) + .or_default() + .push(token.clone()); + } + } + for tokens in prefix_index.values_mut() { + tokens.sort_unstable(); + tokens.dedup(); + } + prefix_index +} + +/// Whether a place type participates in fuzzy (typo) matching. Settlements/stations/universities +/// do; the ~1M streets and POIs do not (people rarely misspell a road and it keeps fuzzy bounded). +fn is_fuzzy_eligible_type(place_type: &str) -> bool { + !matches!( + place_type, + "street" | "park" | "attraction" | "hospital" | "retail" + ) +} + +/// Jaccard similarity between two sorted trigram sets (0.0–1.0). +pub fn trigram_similarity(left: &[u32], right: &[u32]) -> f32 { + if left.is_empty() || right.is_empty() { + return 0.0; + } + let (mut i, mut j, mut intersection) = (0, 0, 0usize); + while i < left.len() && j < right.len() { + match left[i].cmp(&right[j]) { + std::cmp::Ordering::Less => i += 1, + std::cmp::Ordering::Greater => j += 1, + std::cmp::Ordering::Equal => { + intersection += 1; + i += 1; + j += 1; + } + } + } + let union = left.len() + right.len() - intersection; + intersection as f32 / union as f32 +} + fn replace_token(text: &str, from: &str, to: &str) -> Option<String> { let mut changed = false; let replaced: Vec<&str> = text @@ -191,15 +346,31 @@ fn push_alias(aliases: &mut Vec<String>, alias: String) { } } +/// Bidirectional token abbreviations expanded into search aliases so a query typed either +/// way matches (e.g. "gt missenden" ↔ "Great Missenden", "mt" ↔ "Mount"). +const PLACE_TOKEN_ALIASES: &[(&str, &str)] = &[ + ("st", "saint"), + ("saint", "st"), + ("mt", "mount"), + ("mount", "mt"), + ("gt", "great"), + ("great", "gt"), + ("lt", "little"), + ("little", "lt"), + ("upr", "upper"), + ("upper", "upr"), + ("lwr", "lower"), + ("lower", "lwr"), +]; + fn build_search_text(name: &str, place_type: &str) -> String { let primary = normalize_search_text(name); let mut aliases = vec![primary.clone()]; - if let Some(alias) = replace_token(&primary, "st", "saint") { - push_alias(&mut aliases, alias); - } - if let Some(alias) = replace_token(&primary, "saint", "st") { - push_alias(&mut aliases, alias); + for (from, to) in PLACE_TOKEN_ALIASES { + if let Some(alias) = replace_token(&primary, from, to) { + push_alias(&mut aliases, alias); + } } if place_type == "station" { @@ -391,6 +562,26 @@ impl PlaceData { fallback_city }; + // Build the place search index: an inverted token index over all rows (so the per-query + // cost scales with matched candidates, not the ~1M-row corpus), plus a trigram index over + // only fuzzy-eligible rows for bounded typo matching. + let mut token_index: FxHashMap<String, Vec<u32>> = FxHashMap::default(); + let mut fuzzy_trigram_index: FxHashMap<u32, Vec<u32>> = FxHashMap::default(); + for idx in 0..row_count { + for token in place_index_tokens(&name_search[idx]) { + token_index.entry(token).or_default().push(idx as u32); + } + if is_fuzzy_eligible_type(&place_type_raw[idx]) { + for trigram in compute_trigrams(&name[idx]) { + fuzzy_trigram_index + .entry(trigram) + .or_default() + .push(idx as u32); + } + } + } + let token_prefix_index = build_place_prefix_index(&token_index); + let with_pop = population.iter().filter(|&&pop| pop > 0).count(); let with_city = city.iter().filter(|c| c.is_some()).count(); info!( @@ -398,6 +589,8 @@ impl PlaceData { types = place_type.values.len(), with_population = with_pop, with_city = with_city, + tokens = token_index.len(), + fuzzy_trigrams = fuzzy_trigram_index.len(), "Place data loaded" ); @@ -412,14 +605,261 @@ impl PlaceData { lon, city, travel_destination, + token_index, + token_prefix_index, + fuzzy_trigram_index, }) } + + /// Candidate place rows for the query content tokens: intersect the posting lists of words + /// typed in full; if none matched an indexed token exactly, seed from the smallest + /// prefix-expanded list (so a partially-typed final word still works). Bounded by + /// `PLACE_CANDIDATE_LIMIT`. + pub fn place_candidate_rows(&self, tokens: &[&str]) -> Vec<u32> { + let mut exact: Vec<&[u32]> = tokens + .iter() + .filter_map(|token| self.token_index.get(*token).map(Vec::as_slice)) + .collect(); + + let mut rows = if exact.is_empty() { + self.place_prefix_seed(tokens) + } else { + exact.sort_by_key(|posting| posting.len()); + let mut acc = exact[0].to_vec(); + for posting in &exact[1..] { + if acc.is_empty() { + break; + } + acc = intersect_sorted(&acc, posting); + } + acc + }; + rows.truncate(PLACE_CANDIDATE_LIMIT); + rows + } + + fn place_prefix_seed(&self, tokens: &[&str]) -> Vec<u32> { + let mut best: Option<Vec<u32>> = None; + for token in tokens { + if token.len() < PLACE_PREFIX_MIN_LEN { + continue; + } + let key = &token[..token.len().min(PLACE_PREFIX_MAX_LEN)]; + let Some(indexed) = self.token_prefix_index.get(key) else { + continue; + }; + let mut union: Vec<u32> = Vec::new(); + for indexed_token in indexed { + if !indexed_token.starts_with(token) { + continue; + } + if let Some(rows) = self.token_index.get(indexed_token) { + union = if union.is_empty() { + rows.clone() + } else { + union_sorted(&union, rows) + }; + } + } + if !union.is_empty() + && best + .as_ref() + .is_none_or(|current| union.len() < current.len()) + { + best = Some(union); + } + } + best.unwrap_or_default() + } + + /// Fuzzy-eligible rows sharing enough trigrams with the query to be worth Jaccard scoring. + /// Bounded by the (small) fuzzy trigram index rather than scanning every place. + pub fn fuzzy_candidate_rows(&self, query_trigrams: &[u32]) -> Vec<u32> { + if query_trigrams.is_empty() { + return Vec::new(); + } + let mut counts: FxHashMap<u32, u16> = FxHashMap::default(); + for trigram in query_trigrams { + if let Some(rows) = self.fuzzy_trigram_index.get(trigram) { + for &row in rows { + *counts.entry(row).or_default() += 1; + } + } + } + let min_shared = (((query_trigrams.len() as f32) * 0.4).ceil() as u16).max(1); + counts + .into_iter() + .filter_map(|(row, shared)| (shared >= min_shared).then_some(row)) + .collect() + } +} + +#[cfg(test)] +impl PlaceData { + /// Build a minimal PlaceData from (name, place_type) pairs for index tests. + fn from_names<S: AsRef<str>>(rows: &[(S, S)]) -> Self { + let name: Vec<String> = rows.iter().map(|(nm, _)| nm.as_ref().to_string()).collect(); + let place_type_raw: Vec<String> = + rows.iter().map(|(_, pt)| pt.as_ref().to_string()).collect(); + let name_lower: Vec<String> = name.iter().map(|nm| nm.to_lowercase()).collect(); + let name_search: Vec<String> = name + .iter() + .zip(&place_type_raw) + .map(|(nm, pt)| build_search_text(nm, pt)) + .collect(); + let mut token_index: FxHashMap<String, Vec<u32>> = FxHashMap::default(); + let mut fuzzy_trigram_index: FxHashMap<u32, Vec<u32>> = FxHashMap::default(); + for idx in 0..name.len() { + for token in place_index_tokens(&name_search[idx]) { + token_index.entry(token).or_default().push(idx as u32); + } + if is_fuzzy_eligible_type(&place_type_raw[idx]) { + for trigram in compute_trigrams(&name[idx]) { + fuzzy_trigram_index + .entry(trigram) + .or_default() + .push(idx as u32); + } + } + } + let token_prefix_index = build_place_prefix_index(&token_index); + let len = name.len(); + PlaceData { + name, + name_lower, + name_search, + place_type: InternedColumn::build(&place_type_raw), + type_rank: place_type_raw.iter().map(|pt| type_rank(pt)).collect(), + population: vec![0; len], + lat: vec![0.0; len], + lon: vec![0.0; len], + city: vec![None; len], + travel_destination: vec![false; len], + token_index, + token_prefix_index, + fuzzy_trigram_index, + } + } } #[cfg(test)] mod tests { use super::*; + #[test] + fn place_index_tokens_dedup_and_min_length() { + // "a" is too short; aliases split on " | ". + assert_eq!( + place_index_tokens("st albans | saint albans"), + vec!["albans".to_string(), "saint".to_string(), "st".to_string()] + ); + } + + #[test] + fn place_candidate_rows_intersect_and_prefix_seed() { + let pd = PlaceData::from_names(&[ + ("Camden", "suburb"), + ("Camden Town", "suburb"), + ("Camden Market", "attraction"), + ("Manchester", "city"), + ("Manchester Piccadilly", "station"), + ]); + + // Full word → posting list (Camden, Camden Town, Camden Market). + let camden = pd.place_candidate_rows(&["camden"]); + assert_eq!(camden, vec![0, 1, 2]); + + // Two full words intersect to rows containing BOTH (Camden Town only). + let camden_town = pd.place_candidate_rows(&["camden", "town"]); + assert_eq!(camden_town, vec![1]); + + // A partially-typed final word with no exact token seeds from the prefix index. + let piccad = pd.place_candidate_rows(&["piccad"]); + assert_eq!(piccad, vec![4]); + + // No match → empty. + assert!(pd.place_candidate_rows(&["zzzz"]).is_empty()); + } + + // Run with: cargo test --release bench_place_search -- --ignored --nocapture + #[test] + #[ignore] + fn bench_place_search_at_one_million_rows() { + let roads = [ + "High Street", + "Station Road", + "Church Lane", + "Victoria Road", + "Mill Lane", + "Park Avenue", + "Queens Road", + "Kings Road", + ]; + let mut rows: Vec<(String, String)> = Vec::with_capacity(1_000_000); + for i in 0..1_000_000usize { + // Vary the name so the index resembles ~1M distinct (street, area) rows. + rows.push(( + format!("{} {}", roads[i % roads.len()], i % 4000), + "street".into(), + )); + } + rows.push(("London".into(), "city".into())); + let pd = PlaceData::from_names(&rows); + + let start = std::time::Instant::now(); + let mut hits = 0usize; + for _ in 0..50 { + let candidates = pd.place_candidate_rows(&["high", "street"]); + for row in candidates { + let idx = row as usize; + if place_search_test_score(&pd, idx, "high street", &["high", "street"]).is_some() { + hits += 1; + } + } + } + let per_query = start.elapsed() / 50; + println!( + "indexed place search over {} rows: {:?}/query ({} hits)", + pd.name.len(), + per_query, + hits / 50 + ); + // The old full O(N) scan measured ~36ms here; candidate-based must be far under that. + assert!(per_query.as_millis() < 10, "per_query was {per_query:?}"); + } + + /// Mirrors the route's per-candidate match check for the bench. + fn place_search_test_score( + pd: &PlaceData, + idx: usize, + query_search: &str, + query_tokens: &[&str], + ) -> Option<f32> { + let search_text = &pd.name_search[idx]; + if query_tokens.iter().all(|qt| { + place_alias_tokens(search_text) + .any(|t| t == *qt || (qt.len() >= 2 && t.starts_with(qt))) + }) { + Some(640.0) + } else if pd.name_lower[idx] == query_search { + Some(1000.0) + } else { + None + } + } + + #[test] + fn fuzzy_candidate_rows_finds_typos_only_for_eligible_rows() { + let pd = PlaceData::from_names(&[ + ("London", "city"), + ("Baker Street", "street"), // not fuzzy-eligible + ]); + let typo = compute_trigrams("Londn"); + let candidates = pd.fuzzy_candidate_rows(&typo); + assert!(candidates.contains(&0)); // London (city) is reachable by fuzzy + assert!(!candidates.contains(&1)); // streets are excluded from the fuzzy index + } + fn test_city_rows() -> [(&'static str, f32, f32, u32); 5] { [ ("London", 51.507_446, -0.1277653, 8_908_083), @@ -470,6 +910,29 @@ mod tests { assert!(build_search_text("Shadwell DLR station", "station").contains("shadwell station")); } + #[test] + fn search_text_expands_directional_and_size_abbreviations() { + assert!(build_search_text("Great Missenden", "village").contains("gt missenden")); + assert!(build_search_text("Mount Pleasant", "suburb").contains("mt pleasant")); + assert!(build_search_text("Little Venice", "suburb").contains("lt venice")); + } + + #[test] + fn trigram_similarity_is_high_for_typos_and_low_for_unrelated() { + let london = compute_trigrams("London"); + let typo = compute_trigrams("Londn"); + let other = compute_trigrams("Manchester"); + assert!(trigram_similarity(&london, &typo) >= 0.4); + assert!(trigram_similarity(&london, &other) < 0.2); + assert!((trigram_similarity(&london, &london) - 1.0).abs() < 1e-6); + } + + #[test] + fn place_alias_tokens_split_across_aliases() { + let tokens: Vec<&str> = place_alias_tokens("kings cross | kings x").collect(); + assert_eq!(tokens, vec!["kings", "cross", "kings", "x"]); + } + #[test] fn travel_destination_types_match_legacy_places() { assert!(is_travel_destination_type("city")); diff --git a/server-rs/src/data/poi.rs b/server-rs/src/data/poi.rs index 0fb3b50..7f7d024 100644 --- a/server-rs/src/data/poi.rs +++ b/server-rs/src/data/poi.rs @@ -398,7 +398,7 @@ fn build_school_meta( let mut idx = vec![u32::MAX; row_count]; let mut meta = Vec::new(); - for row in 0..row_count { + for (row, meta_idx) in idx.iter_mut().enumerate().take(row_count) { let type_group_val = fetch_str(&type_group, row); let type_val = fetch_str(&r#type, row); // type_group is present for every GIAS row, so use it as the sentinel @@ -406,7 +406,7 @@ fn build_school_meta( if type_group_val.is_none() && type_val.is_none() { continue; } - idx[row] = meta.len() as u32; + *meta_idx = meta.len() as u32; meta.push(SchoolMetadata { phase: fetch_str(&phase, row), r#type: type_val, diff --git a/server-rs/src/data/property.rs b/server-rs/src/data/property.rs index 141661b..dd04645 100644 --- a/server-rs/src/data/property.rs +++ b/server-rs/src/data/property.rs @@ -10,8 +10,10 @@ use rustc_hash::{FxHashMap, FxHashSet}; use crate::consts::{H3_PRECOMPUTE_MAX, HISTOGRAM_BINS, NAN_U16, QUANT_SCALE}; use crate::features::{self, Bounds}; -const ADDRESS_SEARCH_CANDIDATE_LIMIT: usize = 50_000; -const ADDRESS_SEARCH_MAX_POSTINGS_PER_TOKEN: usize = 250_000; +/// Upper bound on rows scored per query. Intersection keeps most candidate sets far below +/// this; only a single very common road word (e.g. "high") approaches it, and the in-area +/// priority sort keeps a refined query's matches ahead of the cut. +const ADDRESS_SEARCH_CANDIDATE_LIMIT: usize = 150_000; const ADDRESS_SEARCH_PREFIX_MIN_LEN: usize = 4; const ADDRESS_SEARCH_PREFIX_MAX_LEN: usize = 8; const NO_POI_METRIC_ROW: u32 = u32::MAX; @@ -162,6 +164,11 @@ struct AddressTermGroup { #[derive(Debug)] struct AddressQuery { full_postcode: Option<String>, + /// Compact uppercase outward code (optionally with a sector digit) recovered when the + /// user appended a partial postcode like "NW1" or "NW1 6". Used as an additive ranking + /// bias, never as a hard filter — so the disambiguating hint is honoured without + /// excluding the same road in other areas. + postcode_area: Option<String>, text_groups: Vec<AddressTermGroup>, numeric_terms: Vec<String>, candidate_terms: Vec<String>, @@ -442,6 +449,138 @@ fn build_address_prefix_index( prefix_index } +/// Intersect two ascending-sorted row-id slices. +fn intersect_sorted(left: &[u32], right: &[u32]) -> Vec<u32> { + let mut out = Vec::new(); + let (mut i, mut j) = (0, 0); + while i < left.len() && j < right.len() { + match left[i].cmp(&right[j]) { + std::cmp::Ordering::Less => i += 1, + std::cmp::Ordering::Greater => j += 1, + std::cmp::Ordering::Equal => { + out.push(left[i]); + i += 1; + j += 1; + } + } + } + out +} + +/// Union two ascending-sorted row-id slices (deduplicated, stays sorted). +fn union_sorted(left: &[u32], right: &[u32]) -> Vec<u32> { + let mut out = Vec::with_capacity(left.len() + right.len()); + let (mut i, mut j) = (0, 0); + while i < left.len() && j < right.len() { + match left[i].cmp(&right[j]) { + std::cmp::Ordering::Less => { + out.push(left[i]); + i += 1; + } + std::cmp::Ordering::Greater => { + out.push(right[j]); + j += 1; + } + std::cmp::Ordering::Equal => { + out.push(left[i]); + i += 1; + j += 1; + } + } + } + out.extend_from_slice(&left[i..]); + out.extend_from_slice(&right[j..]); + out +} + +/// An ordinal like "1st", "2nd", "3rd", "21st" — part of the street name ("2nd Avenue"), not a +/// house-number prefix. +fn is_ordinal_token(token: &str) -> bool { + let split = token.len().saturating_sub(2); + let (digits, suffix) = token.split_at(split); + !digits.is_empty() + && digits.chars().all(|ch| ch.is_ascii_digit()) + && matches!(suffix, "st" | "nd" | "rd" | "th") +} + +/// Leading address tokens that denote a unit/house number rather than the street itself. +fn is_house_prefix_token(token: &str) -> bool { + if is_ordinal_token(token) { + return false; + } + matches!( + token, + "flat" | "fl" | "apartment" | "apt" | "unit" | "no" | "block" | "floor" | "room" + ) || token.len() == 1 + || token.chars().all(|ch| ch.is_ascii_digit()) + || (token.chars().next().is_some_and(|ch| ch.is_ascii_digit()) + && token.chars().any(|ch| ch.is_ascii_alphabetic())) +} + +/// Street-level key for an address: drops the leading house-number / flat prefix so that +/// "12 Baker Street" and "5 Baker Street" collapse to a single street entry. +fn street_key(address: &str) -> String { + let tokens = tokenize_address_text(address); + let mut start = 0; + while start < tokens.len() && is_house_prefix_token(&tokens[start]) { + start += 1; + } + if start >= tokens.len() { + return tokens.join(" "); + } + tokens[start..].join(" ") +} + +/// Road-type words. Their presence (with no house number) marks a road browse, which we +/// collapse to one result per street. +const ROAD_TYPE_TOKENS: &[&str] = &[ + "street", + "st", + "road", + "rd", + "lane", + "ln", + "avenue", + "ave", + "close", + "cl", + "drive", + "dr", + "way", + "court", + "ct", + "crescent", + "cres", + "place", + "terrace", + "terr", + "grove", + "gardens", + "gdns", + "walk", + "row", + "square", + "sq", + "hill", + "parade", + "mews", + "embankment", + "broadway", + "boulevard", + "blvd", +]; + +fn query_has_road_type(query: &str) -> bool { + tokenize_address_text(query) + .iter() + .any(|token| ROAD_TYPE_TOKENS.contains(&token.as_str())) +} + +/// The outward code (everything before the space) of a canonical postcode. +fn outcode_of(postcode: &str) -> &str { + postcode.split(' ').next().unwrap_or(postcode) +} + fn parse_address_query(query: &str) -> AddressQuery { let tokens = tokenize_address_text(query); let (full_postcode, postcode_token_indices) = extract_full_postcode(&tokens) @@ -449,12 +588,45 @@ fn parse_address_query(query: &str) -> AddressQuery { .unwrap_or((None, Vec::new())); let skip_postcode_tokens: FxHashSet<usize> = postcode_token_indices.into_iter().collect(); + + // Recover an appended partial postcode (outcode, or outcode + sector digit) as a ranking + // bias rather than discarding it — but only from the TRAILING position, so a leading road + // designation like "A4 Great West Road" is not mistaken for an area refinement. + let mut postcode_area: Option<String> = None; + let mut consumed_partial_tokens: FxHashSet<usize> = FxHashSet::default(); + if full_postcode.is_none() && !tokens.is_empty() { + let last = tokens.len() - 1; + if !skip_postcode_tokens.contains(&last) { + let sector_digit = + tokens[last].len() == 1 && tokens[last].chars().all(|ch| ch.is_ascii_digit()); + if last >= 1 + && sector_digit + && !skip_postcode_tokens.contains(&(last - 1)) + && looks_like_postcode_fragment(&tokens[last - 1]) + { + postcode_area = Some(format!( + "{}{}", + tokens[last - 1].to_ascii_uppercase(), + tokens[last] + )); + consumed_partial_tokens.insert(last); + consumed_partial_tokens.insert(last - 1); + } else if looks_like_postcode_fragment(&tokens[last]) { + postcode_area = Some(tokens[last].to_ascii_uppercase()); + consumed_partial_tokens.insert(last); + } + } + } + let mut text_groups = Vec::new(); let mut numeric_terms = Vec::new(); let mut candidate_terms = Vec::new(); for (idx, token) in tokens.iter().enumerate() { - if skip_postcode_tokens.contains(&idx) || looks_like_postcode_fragment(token) { + if skip_postcode_tokens.contains(&idx) + || consumed_partial_tokens.contains(&idx) + || looks_like_postcode_fragment(token) + { continue; } @@ -486,6 +658,7 @@ fn parse_address_query(query: &str) -> AddressQuery { AddressQuery { full_postcode, + postcode_area, text_groups, numeric_terms, candidate_terms, @@ -897,9 +1070,15 @@ impl PropertyData { &self.address_search_token_keys[offset..offset + length] } - /// Search individual property addresses. Full postcode queries use a direct row index; - /// free-text queries use a small inverted index over distinctive address tokens. - pub fn search_addresses(&self, query: &str, limit: usize) -> Vec<usize> { + /// Search individual property addresses, returning `(row, score)` ranked best-first. + /// + /// Candidate rows come from intersecting the posting lists of the distinctive words the + /// user typed in full (so "Cherry Hinton Road" narrows to rows containing both), unioned + /// with the exact-postcode rows when a complete postcode is present (so a postcode is a + /// boost, not an all-or-nothing gate). An appended partial postcode keeps in-area rows + /// ahead of the candidate cut and adds a scoring bias. With a road-type word and no house + /// number, results collapse to one row per street. + pub fn search_addresses(&self, query: &str, limit: usize) -> Vec<(usize, i32)> { if limit == 0 { return Vec::new(); } @@ -912,25 +1091,45 @@ impl PropertyData { return Vec::new(); } - let candidate_rows: Vec<u32> = if let Some(postcode) = parsed.full_postcode.as_deref() { - self.postcode_interner + let mut candidate_rows = self.address_candidate_rows(&parsed.candidate_terms); + + // A complete postcode contributes its rows too, instead of replacing the road match. + if let Some(postcode) = parsed.full_postcode.as_deref() { + if let Some(rows) = self + .postcode_interner .get(postcode) .and_then(|key| self.postcode_row_index.get(&key)) - .map(|rows| rows.to_vec()) - .unwrap_or_default() - } else if let Some(rows) = self.best_address_token_rows(&parsed.candidate_terms) { - rows.iter() - .take(ADDRESS_SEARCH_CANDIDATE_LIMIT) - .copied() - .collect() - } else { - Vec::new() - }; + { + candidate_rows = if candidate_rows.is_empty() { + rows.clone() + } else { + union_sorted(&candidate_rows, rows) + }; + } + } if candidate_rows.is_empty() { return Vec::new(); } + // When the user appended a partial postcode, keep in-area rows ahead of the cut so the + // refinement still surfaces even for very common roads. Single pass (stable partition) so + // the postcode check — which allocates — runs exactly once per candidate. + if let Some(area) = parsed.postcode_area.as_deref() { + let mut in_area = Vec::new(); + let mut others = Vec::new(); + for &row in &candidate_rows { + if self.row_postcode_in_area(row as usize, area) { + in_area.push(row); + } else { + others.push(row); + } + } + in_area.extend(others); + candidate_rows = in_area; + } + candidate_rows.truncate(ADDRESS_SEARCH_CANDIDATE_LIMIT); + let mut scored: Vec<(i32, usize, usize)> = candidate_rows .into_iter() .filter_map(|row| { @@ -948,18 +1147,29 @@ impl PropertyData { .then(left.2.cmp(&right.2)) }); + // Collapse a road browse (road-type word, no house number) to one row per street. + let collapse_streets = parsed.numeric_terms.is_empty() && query_has_road_type(query); + let mut seen = FxHashSet::default(); let mut results = Vec::with_capacity(limit); - for (_, _, row) in scored { + for (score, _, row) in scored { let address = self.address(row).trim(); if address.is_empty() { continue; } - let key = format!("{}\n{}", address.to_ascii_lowercase(), self.postcode(row)); + let key = if collapse_streets { + format!( + "{}\n{}", + street_key(address), + outcode_of(self.postcode(row)) + ) + } else { + format!("{}\n{}", address.to_ascii_lowercase(), self.postcode(row)) + }; if !seen.insert(key) { continue; } - results.push(row); + results.push((row, score)); if results.len() == limit { break; } @@ -968,36 +1178,75 @@ impl PropertyData { results } - fn best_address_token_rows(&self, terms: &[String]) -> Option<&[u32]> { - let mut best: Option<&[u32]> = None; - - for term in terms { - if let Some(rows) = self.address_token_index.get(term) { - if best.is_none_or(|current| rows.len() < current.len()) { - best = Some(rows.as_slice()); - } - continue; - } - - if term.len() < 4 { - continue; - } - - if let Some(tokens) = self.address_prefix_index.get(address_prefix_key(term)) { - for token in tokens { - if !token.starts_with(term) { - continue; - } - if let Some(rows) = self.address_token_index.get(token) { - if best.is_none_or(|current| rows.len() < current.len()) { - best = Some(rows.as_slice()); - } - } - } + /// True when the row's postcode begins with the compact partial-postcode `area` + /// (e.g. "NW1" or "NW16" matches "NW1 6XE"). + fn row_postcode_in_area(&self, row: usize, area: &str) -> bool { + let mut compact = String::new(); + for ch in self.postcode(row).chars() { + if !ch.is_whitespace() { + compact.push(ch.to_ascii_uppercase()); } } + compact.starts_with(area) + } - best + /// Candidate rows for the distinctive query words. Words typed in full intersect by their + /// exact posting lists (precise); a still-being-typed final word with no exact match seeds + /// from the smallest prefix-expanded posting list (so partial typing keeps working). + fn address_candidate_rows(&self, terms: &[String]) -> Vec<u32> { + let mut exact: Vec<&[u32]> = terms + .iter() + .filter_map(|term| self.address_token_index.get(term).map(Vec::as_slice)) + .collect(); + + if !exact.is_empty() { + exact.sort_by_key(|rows| rows.len()); + let mut acc = exact[0].to_vec(); + for rows in &exact[1..] { + if acc.is_empty() { + break; + } + acc = intersect_sorted(&acc, rows); + } + return acc; + } + + self.prefix_seed_rows(terms) + } + + /// Seed rows from the smallest prefix-expanded term — used only when no word matched an + /// indexed token exactly (i.e. the user is still typing the final word). + fn prefix_seed_rows(&self, terms: &[String]) -> Vec<u32> { + let mut best: Option<Vec<u32>> = None; + for term in terms { + if term.len() < ADDRESS_SEARCH_PREFIX_MIN_LEN { + continue; + } + let Some(tokens) = self.address_prefix_index.get(address_prefix_key(term)) else { + continue; + }; + let mut union: Vec<u32> = Vec::new(); + for token in tokens { + if !token.starts_with(term) { + continue; + } + if let Some(rows) = self.address_token_index.get(token) { + union = if union.is_empty() { + rows.clone() + } else { + union_sorted(&union, rows) + }; + } + } + if !union.is_empty() + && best + .as_ref() + .is_none_or(|current| union.len() < current.len()) + { + best = Some(union); + } + } + best.unwrap_or_default() } fn address_match_score(&self, row: usize, parsed: &AddressQuery) -> Option<i32> { @@ -1037,6 +1286,12 @@ impl PropertyData { if numeric_matches == parsed.numeric_terms.len() && numeric_matches > 0 { score += 50; } + // Additive bias (never a filter) when the row sits in the appended partial postcode. + if let Some(area) = parsed.postcode_area.as_deref() { + if self.row_postcode_in_area(row, area) { + score += 400; + } + } Some(score) } @@ -1969,16 +2224,23 @@ impl PropertyData { } } } - let address_token_count_before_prune = address_token_index.len(); - address_token_index.retain(|_, rows| rows.len() <= ADDRESS_SEARCH_MAX_POSTINGS_PER_TOKEN); + // Keep every distinctive token: common road words ("high", "church", "station") are + // exactly what people search, and dropping them made those roads unsearchable while a + // prefix fallback surfaced the wrong street ("Highbury" for "High"). The candidate scan + // is bounded per query instead (ADDRESS_SEARCH_CANDIDATE_LIMIT), and stop words are + // already excluded from the index, so the largest posting lists stay modest. + let max_postings = address_token_index + .values() + .map(Vec::len) + .max() + .unwrap_or(0); let address_prefix_index = build_address_prefix_index(&address_token_index); let address_search_interner = address_search_rodeo.into_reader(); let address_postings_count: usize = address_token_index.values().map(Vec::len).sum(); tracing::info!( tokens = address_token_index.len(), prefixes = address_prefix_index.len(), - pruned_tokens = - address_token_count_before_prune.saturating_sub(address_token_index.len()), + max_postings_per_token = max_postings, postings = address_postings_count, row_tokens = address_search_token_keys.len(), "Address search index built" @@ -2340,6 +2602,79 @@ mod tests { assert_eq!(parsed.candidate_terms, vec!["downing".to_string()]); } + #[test] + fn address_query_recovers_appended_partial_postcode_as_bias() { + let parsed = parse_address_query("Baker Street NW1"); + assert_eq!(parsed.full_postcode, None); + assert_eq!(parsed.postcode_area.as_deref(), Some("NW1")); + // The road words are still searchable; the postcode fragment did not consume them. + assert_eq!(parsed.candidate_terms, vec!["baker".to_string()]); + assert!(parsed.numeric_terms.is_empty()); + } + + #[test] + fn address_query_recovers_outcode_plus_sector_without_a_phantom_house_number() { + let parsed = parse_address_query("High Street CR0 2"); + assert_eq!(parsed.postcode_area.as_deref(), Some("CR02")); + // The lone sector digit must not be treated as a house number. + assert!(parsed.numeric_terms.is_empty()); + assert_eq!(parsed.candidate_terms, vec!["high".to_string()]); + } + + #[test] + fn full_postcode_takes_precedence_over_partial_bias() { + let parsed = parse_address_query("Baker Street NW1 6XE"); + assert_eq!(parsed.full_postcode.as_deref(), Some("NW1 6XE")); + assert_eq!(parsed.postcode_area, None); + } + + #[test] + fn intersect_and_union_sorted_row_ids() { + assert_eq!( + intersect_sorted(&[1, 2, 3, 5], &[2, 3, 4, 5]), + vec![2, 3, 5] + ); + assert_eq!(intersect_sorted(&[1, 2], &[3, 4]), Vec::<u32>::new()); + assert_eq!(union_sorted(&[1, 3, 5], &[2, 3, 4]), vec![1, 2, 3, 4, 5]); + assert_eq!(union_sorted(&[], &[2, 4]), vec![2, 4]); + } + + #[test] + fn street_key_collapses_house_numbers_and_flats() { + assert_eq!(street_key("12 Baker Street"), "baker street"); + assert_eq!(street_key("5 Baker Street"), "baker street"); + assert_eq!(street_key("Flat 2, 10 Downing Street"), "downing street"); + assert_eq!(street_key("221B Baker Street"), "baker street"); + } + + #[test] + fn street_key_keeps_ordinal_street_names() { + // Ordinals are part of the street name, not a house-number prefix. + assert_eq!(street_key("2nd Avenue"), "2nd avenue"); + assert_eq!(street_key("12 3rd Avenue"), "3rd avenue"); + assert!(is_ordinal_token("21st")); + assert!(!is_ordinal_token("21")); + assert!(!is_ordinal_token("221b")); + } + + #[test] + fn postcode_area_recovered_only_from_the_trailing_position() { + // A leading road designation must NOT be taken as an area refinement. + let parsed = parse_address_query("A4 Great West Road"); + assert_eq!(parsed.postcode_area, None); + // A genuine trailing outcode still is. + let trailing = parse_address_query("Great West Road W4"); + assert_eq!(trailing.postcode_area.as_deref(), Some("W4")); + } + + #[test] + fn road_type_detection() { + assert!(query_has_road_type("high street")); + assert!(query_has_road_type("acacia avenue")); + assert!(!query_has_road_type("acacia")); + assert!(!query_has_road_type("london")); + } + #[test] fn address_query_parsing_keeps_partial_terms_for_row_matching() { let parsed = parse_address_query("settlers cour"); diff --git a/server-rs/src/main.rs b/server-rs/src/main.rs index b1293fc..4b5f318 100644 --- a/server-rs/src/main.rs +++ b/server-rs/src/main.rs @@ -507,8 +507,7 @@ async fn main() -> anyhow::Result<()> { "property_borders.pmtiles", ); - let noise_overlay_reader = - init_required_tile_reader("Noise", &noise_overlay_tiles).await?; + let noise_overlay_reader = init_required_tile_reader("Noise", &noise_overlay_tiles).await?; let satellite_reader = init_required_tile_reader("Satellite", &satellite_tiles).await?; let satellite_highres_reader = init_required_tile_reader("Satellite high-res", &satellite_highres_tiles).await?; diff --git a/server-rs/src/routes/places.rs b/server-rs/src/routes/places.rs index 430517e..491a854 100644 --- a/server-rs/src/routes/places.rs +++ b/server-rs/src/routes/places.rs @@ -2,14 +2,26 @@ use std::sync::Arc; use axum::extract::{Query, State}; use axum::response::Json; +use rustc_hash::FxHashSet; use serde::{Deserialize, Serialize}; use tracing::info; use crate::api_error::ApiError; use crate::consts::PLACES_LIMIT; -use crate::data::{normalize_search_text, slugify}; +use crate::data::{ + compute_trigrams, normalize_search_text, place_alias_tokens, slugify, trigram_similarity, +}; use crate::state::SharedState; +/// Trailing connective words dropped from a place query so "fish and chips" matches a place +/// stored (after `&` is normalized away) as "fish chips". +const QUERY_STOP_WORDS: &[&str] = &["and", "the", "of"]; + +/// Minimum trigram similarity for a fuzzy place match. +const FUZZY_MIN_SIMILARITY: f32 = 0.42; +/// Run the (linear) fuzzy pass only when the exact passes found fewer than this. +const FUZZY_TRIGGER_BELOW: usize = 3; + #[derive(Serialize)] pub struct PlaceResult { name: String, @@ -29,6 +41,43 @@ pub struct AddressResult { lon: f32, } +/// A single, category-tagged, relevance-scored result. The frontend renders these in order, +/// so ranking is unified across places, outcodes, postcodes and addresses instead of the old +/// fixed positional bucketing. +#[derive(Serialize)] +#[serde(tag = "type", rename_all = "lowercase")] +pub enum UnifiedResult { + Place { + name: String, + slug: String, + place_type: String, + lat: f32, + lon: f32, + #[serde(skip_serializing_if = "Option::is_none")] + city: Option<String>, + score: f32, + }, + Postcode { + label: String, + score: f32, + }, + Address { + address: String, + postcode: String, + lat: f32, + lon: f32, + score: f32, + }, +} + +fn unified_score(result: &UnifiedResult) -> f32 { + match result { + UnifiedResult::Place { score, .. } + | UnifiedResult::Postcode { score, .. } + | UnifiedResult::Address { score, .. } => *score, + } +} + #[derive(Serialize)] pub struct PlacesResponse { places: Vec<PlaceResult>, @@ -36,6 +85,9 @@ pub struct PlacesResponse { postcodes: Vec<String>, #[serde(skip_serializing_if = "Vec::is_empty")] addresses: Vec<AddressResult>, + /// Unified, relevance-ordered results. Preferred by the frontend; the arrays above remain + /// for backward compatibility. + results: Vec<UnifiedResult>, } #[derive(Deserialize)] @@ -44,6 +96,9 @@ pub struct PlacesParams { q: String, /// If set, only return places that have travel time data for this mode. mode: Option<String>, + /// Optional map-viewport centre used to bias ranking toward what the user is looking at. + lat: Option<f32>, + lng: Option<f32>, } fn compact_postcode_query(query: &str) -> String { @@ -93,6 +148,131 @@ fn postcode_starts_with_compact(postcode: &str, compact_query: &str) -> bool { current.is_none() } +fn is_postcode_fragmentish(token: &str) -> bool { + (2..=4).contains(&token.len()) + && token + .chars() + .next() + .is_some_and(|ch| ch.is_ascii_alphabetic()) + && token.chars().any(|ch| ch.is_ascii_digit()) + && token.chars().all(|ch| ch.is_ascii_alphanumeric()) +} + +/// Peel a trailing geographic refinement (outcode, or outcode + sector digit) off the query. +/// "camden nw1" → ("camden", Some("NW1")); the core matches the place, the refinement biases +/// ranking and drives the outcode/postcode lists — instead of breaking the match entirely. +fn split_geographic_refinement(query: &str) -> (String, Option<String>) { + let words: Vec<&str> = query.split_whitespace().collect(); + if words.len() < 2 { + return (query.to_string(), None); + } + let last = words[words.len() - 1]; + if words.len() >= 3 && last.len() == 1 && last.chars().all(|ch| ch.is_ascii_digit()) { + let prev = words[words.len() - 2]; + if is_postcode_fragmentish(prev) { + let area = format!("{}{}", prev.to_ascii_uppercase(), last); + return (words[..words.len() - 2].join(" "), Some(area)); + } + } + if is_postcode_fragmentish(last) { + return ( + words[..words.len() - 1].join(" "), + Some(last.to_ascii_uppercase()), + ); + } + (query.to_string(), None) +} + +/// Content words of a place query, dropping connectives so "fish and chips" matches "Fish & Chips". +fn query_content_tokens(query_search: &str) -> Vec<&str> { + query_search + .split(' ') + .filter(|token| !token.is_empty() && !QUERY_STOP_WORDS.contains(token)) + .collect() +} + +/// Base relevance tier for a place, or None if it does not match at all. +fn place_base_score( + search_text: &str, + name_lower: &str, + query_search: &str, + query_lower: &str, + query_tokens: &[&str], +) -> Option<f32> { + if query_search.is_empty() { + return None; + } + + let mut exact = name_lower == query_lower; + let mut prefix = name_lower.starts_with(query_lower); + for alias in search_text.split(" | ") { + if alias == query_search { + exact = true; + } + if alias.starts_with(query_search) { + prefix = true; + } + } + if exact { + return Some(1000.0); + } + if prefix { + return Some(820.0); + } + + if !query_tokens.is_empty() { + let all_covered = query_tokens.iter().all(|query_token| { + place_alias_tokens(search_text).any(|token| { + token == *query_token || (query_token.len() >= 2 && token.starts_with(query_token)) + }) + }); + if all_covered { + return Some(640.0); + } + } + + None +} + +/// Small additive bonuses: more important place types and bigger populations rank higher. +fn place_modifiers(type_rank: u8, population: u32) -> f32 { + let type_bonus = f32::from(6u8.saturating_sub(type_rank)) * 8.0; + let pop_bonus = (population as f32 + 1.0).ln() * 4.0; + type_bonus + pop_bonus.min(64.0) +} + +/// Distance-decay bonus toward the viewport / refinement centre. Capped below the gap between +/// match tiers so it reorders within a tier and breaks ties without overriding exact matches. +fn proximity_bonus(center: Option<(f32, f32)>, lat: f32, lon: f32) -> f32 { + let Some((center_lat, center_lon)) = center else { + return 0.0; + }; + let dlat = lat - center_lat; + let dlon = (lon - center_lon) * center_lat.to_radians().cos(); + let dist = (dlat * dlat + dlon * dlon).sqrt(); + 160.0 * (-dist / 0.3).exp() +} + +/// Map an address match's raw specificity score onto the unified scale. +fn address_unified_score(raw: i32) -> f32 { + 460.0 + raw.min(1000) as f32 * 0.47 +} + +/// Resolve the outcode a compact partial postcode sits in (e.g. "NW16" → "nw1"), trying +/// progressively shorter prefixes against the known outcode set. Returns its index. +fn resolve_outcode_idx(name_lower: &[String], area: &str) -> Option<usize> { + let area_lower = area.to_lowercase(); + let mut len = area_lower.len(); + while len >= 2 { + let candidate = &area_lower[..len]; + if let Some(idx) = name_lower.iter().position(|name| name == candidate) { + return Some(idx); + } + len -= 1; + } + None +} + pub async fn get_places( State(shared): State<Arc<SharedState>>, Query(params): Query<PlacesParams>, @@ -106,154 +286,229 @@ pub async fn get_places( let limit = PLACES_LIMIT; let mode_filter = params.mode; + let viewport = match (params.lat, params.lng) { + (Some(lat), Some(lng)) => Some((lat, lng)), + _ => None, + }; - let places = tokio::task::spawn_blocking(move || { + let response = tokio::task::spawn_blocking(move || { let t0 = std::time::Instant::now(); - let query_lower = query.to_lowercase(); - let query_search = normalize_search_text(&query); let pd = &state.place_data; let od = &state.outcode_data; let postcode_data = &state.postcode_data; let tt_store = &state.travel_time_store; let property_data = &state.data; - // Linear scan — ~50-100k rows, <1ms - // Tuple: (row_idx, is_exact, is_prefix, type_rank, population, name_len, slug) - let mut matches: Vec<(usize, bool, bool, u8, u32, usize, String)> = pd - .name_search - .iter() - .enumerate() - .filter_map(|(idx, search_text)| { - if query_search.is_empty() || !search_text.contains(&query_search) { - return None; - } - let slug = slugify(&pd.name[idx]); + // Peel any appended outcode/partial-postcode so the place text matches on the core + // words while the refinement biases ranking and drives the outcode/postcode lists. + let (split_query, refinement) = split_geographic_refinement(&query); + // Only honour the refinement when it resolves to a real outcode; otherwise (e.g. "the o2", + // where "o2" looks postcode-ish but is not an outcode) treat the whole query as place text. + let refinement_outcode = refinement + .as_deref() + .and_then(|area| resolve_outcode_idx(&od.name_lower, area)); + let place_query = if refinement.is_some() && refinement_outcode.is_none() { + query.clone() + } else { + split_query + }; + let query_search = normalize_search_text(&place_query); + let query_lower = place_query.to_lowercase(); + let query_tokens = query_content_tokens(&query_search); - // If mode filter is set, keep the historical travel destination set only. - if let Some(ref mode) = mode_filter { - if !pd.travel_destination[idx] || !tt_store.has_destination(mode, &slug) { - return None; - } - } + // Bias centre: explicit viewport, else the resolved refinement outcode's centroid. + let bias_center = viewport.or_else(|| refinement_outcode.map(|idx| od.centroids[idx])); - let is_exact = search_text - .split(" | ") - .any(|alias| alias == query_search || pd.name_lower[idx] == query_lower); - let is_prefix = search_text - .split(" | ") - .any(|alias| alias.starts_with(&query_search)) - || pd.name_lower[idx].starts_with(&query_lower); - Some(( - idx, - is_exact, - is_prefix, - pd.type_rank[idx], - pd.population[idx], - pd.name[idx].len(), - slug, - )) + // ---- Places: candidate rows from the inverted token index, then exact/prefix/token-AND + // scoring — bounded by matched candidates, not the ~1M-row corpus. Fuzzy fallback uses the + // (small) trigram index over fuzzy-eligible rows only. + let mut place_results: Vec<(f32, PlaceResult)> = Vec::new(); + let mut matched_place_idx: FxHashSet<usize> = FxHashSet::default(); + let make_place = |idx: usize| PlaceResult { + name: pd.name[idx].clone(), + slug: slugify(&pd.name[idx]), + place_type: pd.place_type.get(idx).to_string(), + lat: pd.lat[idx], + lon: pd.lon[idx], + city: pd.city[idx].clone(), + }; + let passes_mode = |idx: usize| { + mode_filter.as_ref().is_none_or(|mode| { + pd.travel_destination[idx] + && tt_store.has_destination(mode, &slugify(&pd.name[idx])) }) - .collect(); + }; - // Sort: exact first, then prefix, then type rank asc, then population desc, then name length asc - matches.sort_unstable_by(|lhs, rhs| { - rhs.1 - .cmp(&lhs.1) - .then(rhs.2.cmp(&lhs.2)) - .then(lhs.3.cmp(&rhs.3)) - .then(rhs.4.cmp(&lhs.4)) - .then(lhs.5.cmp(&rhs.5)) - }); + for row in pd.place_candidate_rows(&query_tokens) { + let idx = row as usize; + let Some(base) = place_base_score( + &pd.name_search[idx], + &pd.name_lower[idx], + &query_search, + &query_lower, + &query_tokens, + ) else { + continue; + }; + if !passes_mode(idx) { + continue; + } + let score = base + + place_modifiers(pd.type_rank[idx], pd.population[idx]) + + proximity_bonus(bias_center, pd.lat[idx], pd.lon[idx]); + matched_place_idx.insert(idx); + place_results.push((score, make_place(idx))); + } - matches.truncate(limit); + // Fuzzy (trigram) fallback only when the exact passes were thin and the query is long + // enough to be discriminating. + if place_results.len() < FUZZY_TRIGGER_BELOW && query_search.len() >= 4 { + let query_trigrams = compute_trigrams(&place_query); + for row in pd.fuzzy_candidate_rows(&query_trigrams) { + let idx = row as usize; + if matched_place_idx.contains(&idx) || !passes_mode(idx) { + continue; + } + let similarity = + trigram_similarity(&query_trigrams, &compute_trigrams(&pd.name[idx])); + if similarity < FUZZY_MIN_SIMILARITY { + continue; + } + let score = 280.0 + + similarity * 120.0 + + place_modifiers(pd.type_rank[idx], pd.population[idx]) + + proximity_bonus(bias_center, pd.lat[idx], pd.lon[idx]); + matched_place_idx.insert(idx); + place_results.push((score, make_place(idx))); + } + } - let mut results: Vec<PlaceResult> = matches - .iter() - .map(|(idx, .., slug)| PlaceResult { - name: pd.name[*idx].clone(), - slug: slug.clone(), - place_type: pd.place_type.get(*idx).to_string(), - lat: pd.lat[*idx], - lon: pd.lon[*idx], - city: pd.city[*idx].clone(), - }) - .collect(); - - // Also search outcodes (skip when mode filter is set — outcodes aren't travel destinations) - if mode_filter.is_none() { - let query_upper = query_lower.to_uppercase(); - let mut outcode_results: Vec<PlaceResult> = od - .name_lower - .iter() - .enumerate() - .filter_map(|(idx, name)| { - if !name.starts_with(&query_lower) { - return None; - } - let is_exact = name.len() == query_lower.len(); - Some((idx, is_exact)) - }) - .collect::<Vec<_>>() - .into_iter() - .map(|(idx, _is_exact)| PlaceResult { + // ---- Outcodes (skipped under a mode filter) ---- + let push_outcode = |results: &mut Vec<(f32, PlaceResult)>, idx: usize, base: f32| { + let (clat, clon) = od.centroids[idx]; + results.push(( + base + proximity_bonus(bias_center, clat, clon), + PlaceResult { name: od.names[idx].clone(), slug: od.names[idx].to_lowercase(), place_type: "outcode".to_string(), - lat: od.centroids[idx].0, - lon: od.centroids[idx].1, + lat: clat, + lon: clon, city: od.cities[idx].clone(), - }) - .collect(); - - // Sort outcodes: exact first, then by name length (shorter = broader area) - outcode_results.sort_unstable_by(|a, b| { - let a_exact = a.name.eq_ignore_ascii_case(&query_upper); - let b_exact = b.name.eq_ignore_ascii_case(&query_upper); - b_exact.cmp(&a_exact).then(a.name.len().cmp(&b.name.len())) - }); - - // Prepend outcode results (up to 3) before place results, keeping total ≤ limit - outcode_results.truncate(3); - let place_slots = limit.saturating_sub(outcode_results.len()); - results.truncate(place_slots); - outcode_results.append(&mut results); - results = outcode_results; + }, + )); + }; + if mode_filter.is_none() { + if let Some(idx) = refinement_outcode { + // A refinement ("camden nw1") resolves to exactly one outcode — no NW10/NW11 noise. + push_outcode(&mut place_results, idx, 980.0); + } else if looks_like_postcode_prefix(&query) { + // A bare postcode-prefix query ("e1") lists matching outcodes (e1, e10, e11, ...). + let area_lower = compact_postcode_query(&query).to_lowercase(); + for idx in 0..od.names.len() { + let name = &od.name_lower[idx]; + let is_exact = *name == area_lower; + if !(name.starts_with(&area_lower) || area_lower.starts_with(name.as_str())) { + continue; + } + push_outcode( + &mut place_results, + idx, + if is_exact { 980.0 } else { 760.0 }, + ); + } + } } - let postcodes: Vec<String> = if mode_filter.is_none() && looks_like_postcode_prefix(&query) - { - let compact_query = compact_postcode_query(&query); - postcode_data - .postcodes - .iter() - .filter(|postcode| postcode_starts_with_compact(postcode, &compact_query)) - .filter(|postcode| !property_data.rows_for_postcode(postcode).is_empty()) - .take(limit) - .cloned() - .collect() - } else { - Vec::new() - }; + place_results.sort_by(|left, right| right.0.total_cmp(&left.0)); + place_results.truncate(limit); - let addresses: Vec<AddressResult> = if mode_filter.is_none() { - property_data - .search_addresses(&query, limit) - .into_iter() - .map(|row| AddressResult { - address: property_data.address(row).trim().to_string(), - postcode: property_data.postcode(row).to_string(), - lat: property_data.lat[row], - lon: property_data.lon[row], - }) - .collect() - } else { - Vec::new() - }; + // ---- Postcodes (full-postcode prefix list) ---- + let mut postcode_results: Vec<(f32, String)> = Vec::new(); + if mode_filter.is_none() && looks_like_postcode_prefix(&query) { + let compact_query = compact_postcode_query(&query); + for postcode in &postcode_data.postcodes { + if !postcode_starts_with_compact(postcode, &compact_query) { + continue; + } + if property_data.rows_for_postcode(postcode).is_empty() { + continue; + } + let compact_pc: String = + postcode.chars().filter(|ch| !ch.is_whitespace()).collect(); + let score = if compact_pc == compact_query { + 960.0 + } else { + 900.0 + }; + postcode_results.push((score, postcode.clone())); + if postcode_results.len() >= limit { + break; + } + } + } + postcode_results.sort_by(|left, right| right.0.total_cmp(&left.0)); + + // ---- Addresses ---- + let mut address_results: Vec<(f32, AddressResult)> = Vec::new(); + if mode_filter.is_none() { + for (row, raw) in property_data.search_addresses(&query, limit) { + let lat = property_data.lat[row]; + let lon = property_data.lon[row]; + let score = address_unified_score(raw) + proximity_bonus(bias_center, lat, lon); + address_results.push(( + score, + AddressResult { + address: property_data.address(row).trim().to_string(), + postcode: property_data.postcode(row).to_string(), + lat, + lon, + }, + )); + } + } + address_results.sort_by(|left, right| right.0.total_cmp(&left.0)); + + // ---- Unified merge: one relevance-ordered list across every source ---- + let mut unified: Vec<UnifiedResult> = Vec::new(); + for (score, place) in &place_results { + unified.push(UnifiedResult::Place { + name: place.name.clone(), + slug: place.slug.clone(), + place_type: place.place_type.clone(), + lat: place.lat, + lon: place.lon, + city: place.city.clone(), + score: *score, + }); + } + for (score, postcode) in &postcode_results { + unified.push(UnifiedResult::Postcode { + label: postcode.clone(), + score: *score, + }); + } + for (score, address) in &address_results { + unified.push(UnifiedResult::Address { + address: address.address.clone(), + postcode: address.postcode.clone(), + lat: address.lat, + lon: address.lon, + score: *score, + }); + } + unified.sort_by(|left, right| unified_score(right).total_cmp(&unified_score(left))); + unified.truncate(limit); + + let places: Vec<PlaceResult> = place_results.into_iter().map(|(_, p)| p).collect(); + let postcodes: Vec<String> = postcode_results.into_iter().map(|(_, p)| p).collect(); + let addresses: Vec<AddressResult> = address_results.into_iter().map(|(_, a)| a).collect(); let elapsed = t0.elapsed(); info!( query = query.as_str(), - results = results.len(), + results = unified.len(), + places = places.len(), postcodes = postcodes.len(), addresses = addresses.len(), scanned = pd.name_lower.len(), @@ -262,16 +517,17 @@ pub async fn get_places( "GET /api/places" ); - (results, postcodes, addresses) + PlacesResponse { + places, + postcodes, + addresses, + results: unified, + } }) .await .map_err(|error| ApiError::Internal(error.to_string()))?; - Ok(Json(PlacesResponse { - places: places.0, - postcodes: places.1, - addresses: places.2, - })) + Ok(Json(response)) } #[cfg(test)] @@ -293,4 +549,88 @@ mod tests { assert!(postcode_starts_with_compact("SW1A 1AA", "SW1A1")); assert!(!postcode_starts_with_compact("SW1A 1AA", "SW1A2")); } + + #[test] + fn refinement_splits_off_trailing_outcode() { + assert_eq!( + split_geographic_refinement("camden nw1"), + ("camden".to_string(), Some("NW1".to_string())) + ); + assert_eq!( + split_geographic_refinement("high street cr0 2"), + ("high street".to_string(), Some("CR02".to_string())) + ); + // A bare outcode is not split (handled by the outcode/postcode path directly). + assert_eq!( + split_geographic_refinement("e14"), + ("e14".to_string(), None) + ); + // No trailing postcode → unchanged. + assert_eq!( + split_geographic_refinement("baker street"), + ("baker street".to_string(), None) + ); + } + + #[test] + fn query_tokens_drop_connectives() { + assert_eq!( + query_content_tokens("fish and chips"), + vec!["fish", "chips"] + ); + assert_eq!(query_content_tokens("isle of dogs"), vec!["isle", "dogs"]); + } + + fn base(search: &str, query: &str) -> Option<f32> { + let q = normalize_search_text(query); + let tokens = query_content_tokens(&q); + place_base_score(search, search, &q, &query.to_lowercase(), &tokens) + } + + #[test] + fn place_match_tiers_order_exact_above_prefix_above_token_and() { + let exact = base("camden", "camden").unwrap(); + let prefix = base("camden town", "camden").unwrap(); + let token_and = base("camden market", "market camden").unwrap(); + assert!(exact > prefix); + assert!(prefix > token_and); + // A reordered multi-word query still matches via token-AND. + assert!(base("manchester piccadilly", "piccadilly manchester").is_some()); + // Pure infix substrings no longer match (candidates are token-based): "ford" must not + // surface "Stratford" — that was the old population-dominated noise. + assert!(base("stratford", "ford").is_none()); + // Appended noise that matches nothing yields no match (the route strips postcodes first). + assert!(base("camden", "camden zzzz").is_none()); + } + + #[test] + fn address_full_postcode_outranks_an_outcode_prefix() { + // raw 1200 ≈ road + full postcode + number; outcode prefix base is 760. + assert!(address_unified_score(1200) > 760.0); + // a road-only address (raw 200) ranks below an outcode prefix. + assert!(address_unified_score(200) < 760.0); + assert!(address_unified_score(1200) > address_unified_score(200)); + } + + #[test] + fn proximity_bonus_decays_and_never_flips_match_tiers() { + let here = proximity_bonus(Some((51.5, -0.1)), 51.5, -0.1); + let far = proximity_bonus(Some((51.5, -0.1)), 53.5, -2.0); + assert!(here > far); + assert!(here <= 160.0); + // Smaller than the 180-pt gap between exact (1000) and prefix (820). + assert!(here < 180.0); + assert_eq!(proximity_bonus(None, 51.5, -0.1), 0.0); + } + + #[test] + fn resolve_outcode_idx_handles_sectorised_area_and_unknown() { + let names = vec!["nw1".to_string(), "e14".to_string()]; + // "NW16" → outcode NW1 (strips the sector digit); "E14" → exact. + assert_eq!(resolve_outcode_idx(&names, "NW16"), Some(0)); + assert_eq!(resolve_outcode_idx(&names, "E14"), Some(1)); + // A postcode-ish token that is not a real outcode resolves to nothing (folds back). + assert_eq!(resolve_outcode_idx(&names, "O2"), None); + assert_eq!(resolve_outcode_idx(&names, "ZZ9"), None); + } } From fbfebc651cdc92f8625741a37ee8427ef5115376 Mon Sep 17 00:00:00 2001 From: Andras Schmelczer <andras@schmelczer.dev> Date: Tue, 2 Jun 2026 13:46:22 +0100 Subject: [PATCH 6/9] idk2 --- pipeline/download/test_transit_network.py | 79 ++++++++++++++ .../postcode_boundaries/fragments_cache.py | 79 ++++++++++++++ .../price_estimation/test_shrinkage.py | 99 ++++++++++++++++++ pipeline/utils/test_postcode_mapping.py | 38 +++++++ probe_bin | Bin 0 -> 4337536 bytes 5 files changed, 295 insertions(+) create mode 100644 pipeline/download/test_transit_network.py create mode 100644 pipeline/transform/postcode_boundaries/fragments_cache.py create mode 100644 pipeline/transform/price_estimation/test_shrinkage.py create mode 100644 pipeline/utils/test_postcode_mapping.py create mode 100755 probe_bin diff --git a/pipeline/download/test_transit_network.py b/pipeline/download/test_transit_network.py new file mode 100644 index 0000000..c50e654 --- /dev/null +++ b/pipeline/download/test_transit_network.py @@ -0,0 +1,79 @@ +"""Tests for transit_network GTFS processing.""" + +import zipfile +from pathlib import Path + +import pytest + +from pipeline.download.transit_network import convert_high_freq_to_frequency_based + + +def _write_gtfs(path: Path, *, stop_times: str) -> None: + """Write a minimal GTFS zip with one metro route and several trips.""" + routes = "route_id,route_type\nR1,1\n" + trips = "trip_id,route_id,direction_id,service_id\n" + "".join( + f"T{i},R1,0,S1\n" for i in range(1, 7) + ) + with zipfile.ZipFile(path, "w") as z: + z.writestr("routes.txt", routes) + z.writestr("trips.txt", trips) + z.writestr("stop_times.txt", stop_times) + + +def _one_based_stop_times() -> str: + """Six trips, 1-based stop_sequence (1,2,...), 5-minute headway.""" + header = "trip_id,stop_sequence,departure_time,stop_id\n" + rows = [] + # First departures 06:00, 06:05, ... (300s = 5 min headway, well under 15 min) + for i in range(6): + trip = f"T{i + 1}" + first_dep = 6 * 3600 + i * 300 + h, m = divmod(first_dep, 3600) + m, s = divmod(m, 60) + # First stop has stop_sequence 1 (NOT 0); second stop sequence 2. + rows.append(f"{trip},1,{h:02d}:{m:02d}:{s:02d},STOP_A\n") + later = first_dep + 120 + h2, m2 = divmod(later, 3600) + m2, s2 = divmod(m2, 60) + rows.append(f"{trip},2,{h2:02d}:{m2:02d}:{s2:02d},STOP_B\n") + return header + "".join(rows) + + +def test_one_based_stop_sequence_is_converted(tmp_path: Path) -> None: + """First stop selection must use the minimum stop_sequence, not literal "0". + + With 1-based stop_sequence the old code (keyed on stop_sequence == "0") found + zero first stops and produced an empty frequencies.txt. The fix selects the + minimum stop_sequence per trip, so the high-frequency group is converted. + """ + src = tmp_path / "in.zip" + dst = tmp_path / "out.zip" + _write_gtfs(src, stop_times=_one_based_stop_times()) + + convert_high_freq_to_frequency_based(src, dst) + + with zipfile.ZipFile(dst, "r") as z: + freq = z.read("frequencies.txt").decode("utf-8") + + freq_rows = [r for r in freq.splitlines()[1:] if r.strip()] + # The single high-frequency group must produce exactly one frequency entry. + assert len(freq_rows) == 1, freq + trip_id, start_time, end_time, headway_secs, _exact = freq_rows[0].split(",") + # Template trip is the earliest departure (T1 at 06:00) starting at first stop. + assert start_time == "06:00:00" + # Median headway of 300s rounds to a 300s headway entry. + assert headway_secs == "300" + + +def test_raises_when_no_first_stops_found(tmp_path: Path) -> None: + """A non-empty target trip set with unparseable stop_sequence is loud, not silent.""" + src = tmp_path / "in.zip" + dst = tmp_path / "out.zip" + bad = ( + "trip_id,stop_sequence,departure_time,stop_id\n" + "T1,not_a_number,06:00:00,STOP_A\n" + ) + _write_gtfs(src, stop_times=bad) + + with pytest.raises(RuntimeError, match="no first stops"): + convert_high_freq_to_frequency_based(src, dst) diff --git a/pipeline/transform/postcode_boundaries/fragments_cache.py b/pipeline/transform/postcode_boundaries/fragments_cache.py new file mode 100644 index 0000000..5fa5b4d --- /dev/null +++ b/pipeline/transform/postcode_boundaries/fragments_cache.py @@ -0,0 +1,79 @@ +"""Persist Phase-3 output (the per-postcode fragments) so a crash in the later +merge/write phases can resume in seconds instead of re-running the ~10-hour OA +loop. + +Phase 3 turns OA boundaries + INSPIRE parcels + UPRN points into ~1.8M +``(postcode, geometry)`` fragments held only in memory. Everything after it +(merge, simplify, GeoJSON write) is cheap but failure-prone -- a single +degenerate postcode used to abort the whole run *after* those 10 hours. Caching +the fragments to disk decouples the expensive computation from the fragile +output stage. + +Fragments are stored as one parquet file with two columns: ``postcode`` +(string) and ``wkb`` (binary Shapely WKB). Writes are atomic (temp file + +``os.replace``) so an interrupted write never leaves a cache that passes the +freshness check. The cache is validated against its upstream inputs by mtime: if +any input is newer than the cache it is treated as stale and ignored, mirroring +make's own freshness logic. +""" + +from __future__ import annotations + +import os +from pathlib import Path + +import numpy as np +import polars as pl +import shapely +from shapely.geometry.base import BaseGeometry + +Fragment = tuple[str, BaseGeometry] + + +def _tmp_path(cache_path: Path) -> Path: + return cache_path.parent / (cache_path.name + ".tmp") + + +def fragments_cache_is_fresh( + cache_path: Path, inputs: list[Path | None] +) -> bool: + """True if ``cache_path`` exists and is newer than every input that exists. + + A missing input is ignored (it cannot have changed the cache); a ``None`` + input is skipped. Any existing input newer than the cache marks it stale. + """ + if not cache_path.exists(): + return False + cache_mtime = cache_path.stat().st_mtime + for inp in inputs: + if inp is None: + continue + path = Path(inp) + if path.exists() and path.stat().st_mtime > cache_mtime: + return False + return True + + +def save_fragments(cache_path: Path, fragments: list[Fragment]) -> None: + """Atomically write ``(postcode, geometry)`` fragments to a parquet cache.""" + postcodes = [pc for pc, _ in fragments] + geoms = np.array([geom for _, geom in fragments], dtype=object) + wkb = shapely.to_wkb(geoms) + + frame = pl.DataFrame( + {"postcode": postcodes, "wkb": list(wkb)}, + schema={"postcode": pl.Utf8, "wkb": pl.Binary}, + ) + + cache_path.parent.mkdir(parents=True, exist_ok=True) + tmp = _tmp_path(cache_path) + frame.write_parquet(tmp, compression="zstd") + os.replace(tmp, cache_path) + + +def load_fragments(cache_path: Path) -> list[Fragment]: + """Read fragments written by :func:`save_fragments` back into memory.""" + frame = pl.read_parquet(cache_path) + postcodes = frame["postcode"].to_list() + geoms = shapely.from_wkb(frame["wkb"].to_list()) + return list(zip(postcodes, geoms)) diff --git a/pipeline/transform/price_estimation/test_shrinkage.py b/pipeline/transform/price_estimation/test_shrinkage.py new file mode 100644 index 0000000..06ab01f --- /dev/null +++ b/pipeline/transform/price_estimation/test_shrinkage.py @@ -0,0 +1,99 @@ +"""Regression tests for common-base-year re-anchoring before blending. + +Each repeat-sales index dict is anchored to log-index 0 at its OWN earliest +year. shrink_dicts / blend_dicts combine dicts key-by-key, so dicts anchored to +different base years must be re-anchored to a single common base first, or the +blend averages level-incompatible numbers (fix5-index-base-year). +""" + +from pipeline.transform.price_estimation.shrinkage import ( + blend_dicts, + reanchor_dict, + reanchor_dicts, + shrink_dicts, +) + + +def test_reanchor_is_pure_constant_shift_preserving_differences(): + """Re-anchoring only shifts the origin; year-to-year moves are unchanged.""" + # Anchored at its own earliest year 2008. + idx = {2008: 0.0, 2009: 0.10, 2010: 0.25, 2011: 0.40} + + reanchored = reanchor_dict(idx, 1996) + # 1996 is before this dict's history -> back-fill earliest value (0.0), + # so the shift is 0 and the dict is unchanged. + assert reanchored[2008] == 0.0 + + # Same shape, different exact-hit base year: anchoring at 2010 subtracts 0.25. + reanchored_2010 = reanchor_dict(idx, 2010) + assert reanchored_2010[2010] == 0.0 + # All within-dict differences are preserved under the constant shift. + years = sorted(idx) + for a, b in zip(years, years[1:]): + assert abs((reanchored_2010[b] - reanchored_2010[a]) - (idx[b] - idx[a])) < 1e-12 + + +def test_blend_different_base_years_needs_reanchoring(): + """Blending two dicts on different bases is biased unless re-anchored first. + + Both cells observe the common base year 1996 but were anchored to DIFFERENT + origins (sectorA at 1996, sectorB at 2008, as solve_robust_index would do for + cells whose pair history starts at different years). They describe the SAME + true trajectory measured from 1996, so a 50/50 blend should reproduce that + common level. Pre-fix, blend_dicts mixes sectorB's 2008-relative numbers with + sectorA's 1996-relative numbers, level-shifting the smoothed result. + """ + base_year = 1996 + + # True log-levels relative to 1996 (identical trajectory for both cells). + truth = {1996: 0.0, 2008: 0.80, 2012: 1.00} + + # sectorA: anchored at 1996 (its earliest year) -> equals truth. + sector_a = dict(truth) + # sectorB: same trajectory but anchored at 2008 (subtract truth[2008] from + # every year), exactly how solve_robust_index would express a cell whose + # earliest year happened to be picked as 2008. + shift_b = truth[2008] + sector_b = {y: v - shift_b for y, v in truth.items()} + + # --- Pre-fix behaviour: blend the raw dicts directly. --- + raw_blend = blend_dicts(sector_a, [sector_b], 0.5, [0.5]) + # Every year is pulled by half of shift_b (0.4) away from the truth. + assert abs(raw_blend[2012] - truth[2012]) > 0.3 + assert abs(raw_blend[1996] - truth[1996]) > 0.3 + + # --- Post-fix behaviour: re-anchor to the common base, THEN blend. --- + reanchored = reanchor_dicts({"A": sector_a, "B": sector_b}, base_year) + fixed_blend = blend_dicts(reanchored["A"], [reanchored["B"]], 0.5, [0.5]) + # Both cells now read 0 at 1996 and the true level at every shared year. + for y in truth: + assert abs(fixed_blend[y] - truth[y]) < 1e-9 + + +def test_shrink_dicts_after_reanchoring_is_consistent(): + """Shrinking a cell toward its parent must use a common origin.""" + base_year = 2000 + # Parent (national) anchored at 2000. + parent = {2000: 0.0, 2010: 0.50, 2020: 1.20} + # Sector tracking the parent exactly but anchored at 2010 (subtract 0.50 from + # every year), as solve_robust_index would express a cell whose earliest year + # is later. It still observes the 2000 base year (value -0.50). + sector = {2000: -0.50, 2010: 0.0, 2020: 0.70} + n = 0 # no own data weight -> result should equal parent after anchoring + + reanchored_sector = reanchor_dict(sector, base_year) + # Exact hit on 2000 subtracts -0.50, putting the sector back on the parent's + # origin: 0.0 at 2000, 0.50 at 2010, 1.20 at 2020. + shrunk = shrink_dicts(reanchored_sector, parent, n) + assert abs(shrunk[2000] - 0.0) < 1e-9 + assert abs(shrunk[2010] - 0.50) < 1e-9 + assert abs(shrunk[2020] - 1.20) < 1e-9 + + +def test_reanchor_exact_hit_shifts_all_years(): + """When the base year is present, subtract its value from every year.""" + idx = {1996: 0.0, 2005: 0.30, 2015: 0.90} + reanchored = reanchor_dict(idx, 2005) + assert reanchored[2005] == 0.0 + assert abs(reanchored[1996] - (-0.30)) < 1e-12 + assert abs(reanchored[2015] - 0.60) < 1e-12 diff --git a/pipeline/utils/test_postcode_mapping.py b/pipeline/utils/test_postcode_mapping.py new file mode 100644 index 0000000..3ed0c0f --- /dev/null +++ b/pipeline/utils/test_postcode_mapping.py @@ -0,0 +1,38 @@ +import polars as pl + +from pipeline.utils.postcode_mapping import ( + MAX_REMAP_DISTANCE_M, + build_postcode_mapping, +) + + +def test_remap_drops_terminated_postcodes_beyond_distance_cap(tmp_path): + # One active England postcode at the origin. + # One terminated postcode 100m away (legitimate adjacent remap -> mapped). + # One terminated postcode 5km away (gross misattribution -> dropped). + arcgis = pl.DataFrame( + { + "pcds": ["AB1 1AA", "AB1 1AB", "ZZ9 9ZZ"], + "ctry25cd": ["E92000001", "E92000001", "E92000001"], + "doterm": [None, "202001", "202001"], + "east1m": [500000.0, 500100.0, 505000.0], + "north1m": [200000.0, 200000.0, 200000.0], + } + ) + arcgis_path = tmp_path / "arcgis.parquet" + arcgis.write_parquet(arcgis_path) + + mapping = build_postcode_mapping(arcgis_path) + + # The nearby terminated postcode is remapped onto the active one. + assert mapping.filter(pl.col("old_postcode") == "AB1 1AB")[ + "new_postcode" + ].to_list() == ["AB1 1AA"] + + # The far (5km > 1km cap) terminated postcode must NOT appear in the mapping. + assert "ZZ9 9ZZ" not in mapping["old_postcode"].to_list() + assert mapping.height == 1 + + +def test_max_remap_distance_constant_is_one_kilometre(): + assert MAX_REMAP_DISTANCE_M == 1000.0 diff --git a/probe_bin b/probe_bin new file mode 100755 index 0000000000000000000000000000000000000000..e89bbf9a32a4a29f2e545647e4e99eab128af2d7 GIT binary patch literal 4337536 zcmdqK30zf0AOAmd&bcf1!bNrkJenz{!etQ<H{7+XNV8ljxWYy5BixG@P|T+%)E3Q5 zY_+V!(zLRq-Li$s%63{Tvqjpq#i+E$R)3#43misH^;Ey#|MmJ~)699#%y;(n%$a-P zgsBq+N{Rj_l2L>`wT)C+p=MEd;#l1YDJ1#Ch5rvE1Bew=f-2N(dA&(cEp*+kxf7u? ze{GsQuP1BnbX|`j)0scBzqTQ&OI;@()g_}AD4px+)Ah!^EJlRry3rp?W3`p}hTgxc zUNk_#q;a6C^Zr_fsP0?N<#dPY{xWA*e>Oa_^qGYxYtD-_UC&RJjVzvpC#c~Rj_azo zY8j~Oy1!|k)|UNVczpUaF{DWI*YuJa5ndm!<-4xyWp)Pqv3UNkf6PBqzi9P^*T-uD zb)C6oe;Jj5xw$zRm1RRJ1HrobA@%vWLvnM{YeMN+iaZugmZnLk&0x+6s|8vRihZoc znEe|$*Tj~#Z5x~sb!Y95>1Dm|{C3_D=BK+qCbLI37BOIQH@vS2A7#R4f-^t--#mcs z!d+;>FEHV&P56~2e4Pp3V8XYU@a-mimkEE~gzq!q2Tb^X!Mn@P-%Q+FP{7^gv&)2^ zV8RPb_!tvD*@T~N!p}3|r6zp73148s>rMCtCVaUGzs!WMHR0Er@Qo(?J`=vvgg;@z zpE2RDoA6If_|GQXg3hPAdKF>9dzkPf6E2(ZfhIf)yf4}S|CevV&oGfwX2KVl@Kq-K z8WX<Jgzq%ryG-~V6Mn>m+c02sS6-<me6R^GFyUvI@Xk?6#5iTaxW)gIFdwifRDuiM zw)5Fe938e!jD4z&9eM<mi@3qqzeqeW+bBr$K<WS3_$iVA;^{>tQODB=vKG%p9nX}+ zVL)!zDp67Y#Sv^YUj#SI{dDEoK`zvuOG*Y{cH|+K;+g%`^$g%yB<nT%m_Wcy5W6kf zb8Ql{k0SSI&sVR#7E=rhc}#o0R(XyjyS3+a%Cnoip*^oqo?YYv?YUWbwvmI{^S#Qm zlN{Eb?^B-b<e2t+zw#^)r#9(O<7ZXkr=~!iV@$vUnmy^MLtQT}#w?|@xTe+@t}U+e z1%jlwcwSW~sF7k)Jmt(&i_83B|GYp=tv`I`spBd`LI0V)xs`s^u6vu}(t2NUc_8Sk z44e;#GlGi(!Ls6M{+hZfKdJIpl~yk%WtGJNi1gL^i>oWj!enk~RW&KC4AsCzU9iem z%^X&R7Wzre;+j%lWhJSutqA*lWyQYQ+AtzjQyUH~CX67~{%|-LDy|Hb`f39qBtr{w zlD~FJ5v*$~Yl`RjYm0ql2nmMTKp7KX<F6&5YJV^{$LQlse|_yVf8|&oqGAv<-dF3> zF+})-3kjl7=?{`B#4c1yszWt_`eKMhvgZX!dD!n~(NpXeg^^golA$<6YRXH4wUtES z5CjjtN+qSCU^yvAiPRb*HP%-;zc%bE^^?jPzkfb#%Id0#Z*C}D+mS0Z{>t)>2gFaw zrC@ajQl7yfx^zAZ&{wKtRkg1U>4Zh;qB0~%3AYN_k3d-Dt9`W<N+x3(3vaNmM}D&M z?I;a@eW12DP*vSoLi7ELi%a1fN!AOEp)!9Z@~s0Q_iL*CrGfH5DGT3MSHF<u0b*9E z#ZvdI$9-O%FI-l`>Qq&AI8^H|twmhwtLLG<hEW4T;o`8d#HRX!@G;LnT?>VkpwWIx z(Uf3$$VjH4qKAUhS$pWf)BUxRrWv1Djnb>MFHqy3P+#h=?o#c>D+%r7Xl3(C(azZP zKa)%vH?BB4-K*)@ik_361;Sb*bCXLZO`S4!TyYlY&<-<PYBW1Nr^B3SFn0RO%<piJ z)oIK|pt^{xPNP9^4(WEqg7vAk{?ylR4Wn3(LdZIfx4ehW34cvI*W9;o+%sC0vzz0s zn)_B0zL(=~`IKOZeSo_D?1<+E450Y)@O-t(6FGjmCTB9oNt5cni04<Ryqe=hn)`a5 zYwjC3zU_21{_9M5Gsjz|tL}Gm{EQNnw{cu|f0W~TxSq7G`KI$Ujvv&*E#$cFekRB5 zY%s=OwFzHg!gp|7{zR=;EgYZE7Lxee%kjp~)Oyv<@m4n2;_oQO8$8+|I<RX#G)Jr4 z&hfF+6fs2RxE^jk$E)|N;TCedRg*uN<1IbZaEmyu%dg;gn<l@S=bD^)j<>|9@*6m= z%U{QFZ=2SxIo_tp*~;;TSXF*A$Mt%++k_wGc(vA!$VpteT&1=<JI9;O)XIh9lmDag ze2(k&wus}YY@-8z6(+oa<9dBq$8o(sX*S`zIj*;_HjY28ZWEEC93Oq28c)xluKA<$ zG>(^iuC|LpjyHazmhWVaS07S&5yzXg@}0@?*H2aBQ_XQbK202N|5TN~mE)}+tGt=x z%^Kgq@fMA@aJ*1U?_Q3}AFA@(I9~Fj$`5e7<*3TrIo_n@gJ*Ep{P%pOx=-Zzz_Zo- z@tW|-9FNla+Y%FA&+)sodfUixy`FD1;VmY7uL*BA;dX7`Ss#D(aAl64e}<Y5`6j%` zgjaC<LT!9$;J987*Ku5Lr_CHMIZchvZjS5j+c<vO9M%0%6YfdxS|4=xX(qgo<Gxv{ z{Fxlr^RwE7ui$t`yEEZCIDW&WYPhW&AAgq04{-dD*58thuIbfzBFAsj%H7LxJzbMI z{*u<em2h0o&qj{7Xzgwt$BQ)H#PKGLZ{>Ki#+y0b6t9kJJ2>8|^#d&&FG*0{@8)>( zhiX6E#&P*;t^eV;=L@a>;ds-RDnH6`k0ytByOv9%#_b$$*5r6N-sD!}pUClBO4Rz` z<@h|Uye4y8AD2rwe(wrZPCdu<e!G$54cdHQ9mkt*RObUbIPPH^boguGc&p~VjpMTB z{s7N!R^_yta8G8}eD-Q`5_zu4kxh6S$Mtqs$nja)d|)QWzbjFaOR72Ux=iIOIKEHo zKbtsy>ba`>9VWchgdZ^BB&%!w=<*XyxYvYFHsK{Eyq@E+TEE)J@$|WBdRsW&uB~Tx zbNpJp|L1s-woW10UDK<tgAzHuObge`aebaPnd5C*e2O?;_?6n9RB*iYIko*(b6j`7 zg5zz^sO}p%uFF}+aXlVQ9QP!ua<+2ZtMO)z6OHfSxGtxK<Fe*{H^=pHq0NLJHQ}C| zuH~i6N#nTQj}>xUcR$mFSDWw^CcKH`di~kKaeaQ$%JJ5qTA%lFJiJ`xZ5&^&@dF%h z(&V&roP<<4M>&3tCWj2|nx9)WZs+(T8uxJgIgKZBe2>Ouj(?%?G>-qEaWBW|MQZ%> zIUcX^LXHp8_+*Y3XuOEylQlk*<8w4#!ttdVui*H@8n5Q~>l&};_(6>~aQukIS8)6{ zjW=?<RV&|h9JgPr=35iTdux0v$A@UVnd8GXzJueFHQvJUW^Mhxo8#wb?pry&NaK4s zE^Fy(<M_pz`vV+bukm({H*5ST$9HO+<XV)B($_(+Y24274>a!K_(6>)a{REyWsZNK zjo0}myolrae7nMgH<<8sCcK&B`ub}(#~;_$S#2i#D9819dh#q?@>Az&CcMyu&*Zos zpK6ZxDAwvZ$2Y8%6pO7K*Zb!d6Ta7kw{u(%*Ph=sy*igoc)kfQGT{{*KYWgw-Ubui z%<<o@RP&*g<5M->&hh<PzIldqP1j+KCvsd*uh)c6HsK{EyxxR2n((bAyv2m?HR0_h z++NT%AN2If9ABWVuk%fKkqNIb;SDByoe6I?;k!+En+ZQ^!ac*g=7XNzG!tHE!e^TB zY7@S~gg2S+9VWchgdZ^Bi6gqEck1P8JCZrR^jejtalF@cD)(|+Z@-f{uJ=pz9QSGM zu7Tsa`*j@OJ6r7^nmK-Wjmmd$eCCBJZ{c{Q#&>f(p;2|;%JFYB`FlAYtGPeGaY^It z96zSXIm+=U&AokO*K+w$bMN7}Lvx?V@fBLSWR4eUJdNY8Yw`;@{)5IRbKI(hTg372 zH1{((-b-^|!SP=-_thMCY3}Pe-c#cZ92d3vu+D@xoABKnztN|bdz%SA%5gnh D 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 Jp;6d30FE4J{=pKG5uGI*{zOnx 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�`$jQH<!w#+rgJz0OU42 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≦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μ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%0D85E)0!9X!CfYP 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%0DE~Gdx@0i| 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≤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%0DaeO@XKRd^1YWC3npD}vNc&Lww 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%0D3Y60x|S)W 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�u;)Si3^3wc9 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�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⪴#=bX%YtyeCyF}bU2Crq*<Bp)U- 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Ξ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 L(9h_%MB@JdwL9*M literal 0 HcmV?d00001 From aab85fe32e0cccedb2c2777893deb4094a39f72f Mon Sep 17 00:00:00 2001 From: Andras Schmelczer <andras@schmelczer.dev> Date: Tue, 2 Jun 2026 20:14:32 +0100 Subject: [PATCH 7/9] idgf --- Makefile.data | 10 +- frontend/src/hooks/useLocationSearch.ts | 5 +- pipeline/download/arcgis.py | 25 +- pipeline/download/median_age.py | 100 ++++++-- pipeline/download/noise.py | 83 +++++-- pipeline/download/places.py | 79 +++++-- pipeline/download/test_median_age.py | 75 ++++++ pipeline/download/test_noise.py | 199 ++++++++++++++++ pipeline/download/test_places.py | 87 +++++++ pipeline/download/uprn_lookup.py | 18 +- pipeline/test_validate_outputs.py | 66 ++++++ pipeline/transform/crime_spatial.py | 22 ++ pipeline/transform/join_epc_pp.py | 21 +- pipeline/transform/merge.py | 99 +++++--- pipeline/transform/noise_overlay_tiles.py | 26 ++- .../test_postcode_boundaries.py | 61 ++++- .../transform/postcode_boundaries/voronoi.py | 45 ++-- pipeline/transform/price_estimation/index.py | 69 +++--- pipeline/transform/price_estimation/knn.py | 24 ++ .../transform/price_estimation/shrinkage.py | 69 ++++-- .../transform/price_estimation/test_index.py | 135 +++++++++++ .../transform/price_estimation/test_knn.py | 40 ++++ .../price_estimation/test_shrinkage.py | 170 ++++++++------ pipeline/transform/test_crime_spatial.py | 41 ++++ pipeline/transform/test_join_epc_pp.py | 61 ++++- pipeline/transform/test_merge.py | 216 +++++++++++++++++- .../transform/test_noise_overlay_tiles.py | 110 +++++++++ pipeline/transform/test_transform_poi.py | 179 +++++++++++++++ pipeline/transform/transform_poi.py | 20 +- pipeline/utils/__init__.py | 2 + pipeline/utils/nspl_schema.py | 30 +++ pipeline/utils/test_nspl_schema.py | 57 +++++ pipeline/validate_outputs.py | 55 +++++ 33 files changed, 2016 insertions(+), 283 deletions(-) create mode 100644 pipeline/download/test_median_age.py create mode 100644 pipeline/transform/price_estimation/test_index.py create mode 100644 pipeline/transform/test_noise_overlay_tiles.py create mode 100644 pipeline/utils/nspl_schema.py create mode 100644 pipeline/utils/test_nspl_schema.py diff --git a/Makefile.data b/Makefile.data index ecc065e..31a3c03 100644 --- a/Makefile.data +++ b/Makefile.data @@ -116,9 +116,9 @@ MAP_ASSETS_DEPS := pipeline/download/map_assets.py pipeline/transform/transform_ generate-postcode-boundaries generate-travel-times enrich-actual-listings prepare: $(PRICES_STAMP) download-places tiles satellite-tiles overlay-tiles property-border-tiles generate-postcode-boundaries download-map-assets generate-travel-times | $(POSTCODES_PQ) $(PROPERTIES_PQ) $(PRICE_INDEX) - $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) --parquet $(PRICE_INDEX) --postcode-boundary-match "$(POSTCODES_PQ)::$(PC_BOUNDARIES)" --postcode-features $(POSTCODES_PQ) --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" --price-index $(PRICE_INDEX) + $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) --parquet $(PRICE_INDEX) --postcode-boundary-match "$(POSTCODES_PQ)::$(PC_BOUNDARIES)" --postcode-features $(POSTCODES_PQ) --postcode-universe "$(ARCGIS)::$(POSTCODES_PQ)" --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" --price-index $(PRICE_INDEX) merge: $(MERGE_STAMP) | $(POSTCODES_PQ) $(PROPERTIES_PQ) - $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) --postcode-features $(POSTCODES_PQ) --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" + $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) --postcode-features $(POSTCODES_PQ) --postcode-universe "$(ARCGIS)::$(POSTCODES_PQ)" --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" enrich-actual-listings: $(ACTUAL_LISTINGS_ENRICHED) tiles: $(TILES) $(SATELLITE_TILES) $(SATELLITE_HIGHRES_TILES) satellite-tiles: $(SATELLITE_TILES) @@ -413,13 +413,13 @@ $(MERGE_STAMP): $(EPC_PP) $(ARCGIS) $(IOD) $(POI_PROXIMITY) \ --tree-density-postcodes $(TREE_DENSITY_PC) \ --output-postcodes $(POSTCODES_PQ) \ --output-properties $(PROPERTIES_PQ) - $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) --postcode-features $(POSTCODES_PQ) --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" + $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) --postcode-features $(POSTCODES_PQ) --postcode-universe "$(ARCGIS)::$(POSTCODES_PQ)" --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" @touch $@ # ── Price estimation (post-merge) ─────────────────────────────────────────── $(POSTCODES_PQ) $(PROPERTIES_PQ) &: $(MERGE_STAMP) - $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) --postcode-features $(POSTCODES_PQ) --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" + $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) --postcode-features $(POSTCODES_PQ) --postcode-universe "$(ARCGIS)::$(POSTCODES_PQ)" --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" $(PRICE_INDEX): $(MERGE_STAMP) $(PRICE_INDEX_DEPS) | $(PROPERTIES_PQ) $(POSTCODES_PQ) uv run python -m pipeline.transform.price_estimation.index --input $(PROPERTIES_PQ) --postcodes $(POSTCODES_PQ) --output $@ @@ -428,7 +428,7 @@ $(PRICE_INDEX): $(MERGE_STAMP) $(PRICE_INDEX_DEPS) | $(PROPERTIES_PQ) $(POSTCODE $(PRICES_STAMP): $(MERGE_STAMP) $(PRICE_INDEX) $(PRICE_ESTIMATE_DEPS) | $(PROPERTIES_PQ) $(POSTCODES_PQ) @rm -f $@ uv run python -m pipeline.transform.price_estimation.estimate --properties $(PROPERTIES_PQ) --postcodes $(POSTCODES_PQ) --index $(PRICE_INDEX) - $(VALIDATE_OUTPUTS) --parquet $(PROPERTIES_PQ) --parquet $(POSTCODES_PQ) --parquet $(PRICE_INDEX) --postcode-features $(POSTCODES_PQ) --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" --price-index $(PRICE_INDEX) + $(VALIDATE_OUTPUTS) --parquet $(PROPERTIES_PQ) --parquet $(POSTCODES_PQ) --parquet $(PRICE_INDEX) --postcode-features $(POSTCODES_PQ) --postcode-universe "$(ARCGIS)::$(POSTCODES_PQ)" --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" --price-index $(PRICE_INDEX) @touch $@ $(ACTUAL_LISTINGS_ENRICHED): $(ACTUAL_LISTINGS_RAW) $(EPC) \ diff --git a/frontend/src/hooks/useLocationSearch.ts b/frontend/src/hooks/useLocationSearch.ts index df4cdfa..05def85 100644 --- a/frontend/src/hooks/useLocationSearch.ts +++ b/frontend/src/hooks/useLocationSearch.ts @@ -244,10 +244,7 @@ function legacyCombineResults(json: PlacesApiResponse, trimmed: string): SearchR export type ViewportCenter = { lat: number; lng: number }; -export function useLocationSearch( - mode?: string, - getViewportCenter?: () => ViewportCenter | null -) { +export function useLocationSearch(mode?: string, getViewportCenter?: () => ViewportCenter | null) { const [query, setQuery] = useState(''); const [results, setResults] = useState<SearchResult[]>([]); const [recentSearches, setRecentSearches] = useState<SearchResult[]>(readRecentSearches); diff --git a/pipeline/download/arcgis.py b/pipeline/download/arcgis.py index 418d9bf..588d5c1 100644 --- a/pipeline/download/arcgis.py +++ b/pipeline/download/arcgis.py @@ -4,27 +4,24 @@ import polars as pl from pathlib import Path from pipeline.local_temp import local_tmp_dir -from pipeline.utils import download, extract_zip +from pipeline.utils import code_col_overrides, download, extract_zip URL = "https://www.arcgis.com/sharing/rest/content/items/36b718ad00de49afb9ad364f8b815b9e/data" def convert_to_parquet(data_path: Path, parquet_path: Path) -> None: - # Classification code columns (ruc21ind, oac11ind, imd20ind) look numeric - # in early rows but contain string codes like "UN1" (Unclassified) later - # on. Force them to String to avoid mid-stream dtype inference failures. - # Note: NSPL renames these year suffixes as new releases roll in (e.g. - # Feb 2026 bumped oac from oac21ind → oac11ind, imd from imd19ind → - # imd20ind), so keep this dict in sync with the current CSV headers — - # polars silently ignores overrides for missing columns, masking drift. + # Classification code columns (e.g. ruc21ind, oac11ind, imd20ind) look + # numeric in early rows but contain string codes like "UN1" (Unclassified) + # later on. Force them to String to avoid mid-stream dtype inference + # failures. NSPL renames these year suffixes each release, and polars + # silently ignores overrides for missing columns, so match on the + # suffix-free stem (read from the header) rather than hard-coding suffixes. + csv_path = data_path / "Data/NSPL_FEB_2026_UK.csv" + names = pl.scan_csv(csv_path).collect_schema().names() df = pl.scan_csv( - data_path / "Data/NSPL_FEB_2026_UK.csv", + csv_path, try_parse_dates=True, - schema_overrides={ - "ruc21ind": pl.String, - "oac11ind": pl.String, - "imd20ind": pl.String, - }, + schema_overrides=code_col_overrides(names), ) print(f"Columns: {df.collect_schema().names()}") parquet_path.parent.mkdir(parents=True, exist_ok=True) diff --git a/pipeline/download/median_age.py b/pipeline/download/median_age.py index 4471ce8..b02c43d 100644 --- a/pipeline/download/median_age.py +++ b/pipeline/download/median_age.py @@ -43,6 +43,35 @@ AGE_BANDS = [ (85, 5), # Aged 85 years and over ] +# Canonical NOMIS TS007A (C2021_AGE_19_NAME) band labels, in the SAME order as +# AGE_BANDS. Index i here corresponds to AGE_BANDS[i]; we validate the pivot +# output against this set and use it (not positional string parsing) to order +# the columns, so a stray/relabelled/missing band fails loudly instead of +# silently mis-aligning counts against the wrong lower bound. +EXPECTED_BAND_NAMES = [ + "Aged 0 to 4 years", + "Aged 5 to 9 years", + "Aged 10 to 14 years", + "Aged 15 to 19 years", + "Aged 20 to 24 years", + "Aged 25 to 29 years", + "Aged 30 to 34 years", + "Aged 35 to 39 years", + "Aged 40 to 44 years", + "Aged 45 to 49 years", + "Aged 50 to 54 years", + "Aged 55 to 59 years", + "Aged 60 to 64 years", + "Aged 65 to 69 years", + "Aged 70 to 74 years", + "Aged 75 to 79 years", + "Aged 80 to 84 years", + "Aged 85 years and over", +] +assert len(EXPECTED_BAND_NAMES) == len(AGE_BANDS), ( + "EXPECTED_BAND_NAMES and AGE_BANDS must stay aligned 1:1" +) + def compute_median_age(counts: list[int]) -> float: """Compute median age from five-year band counts using linear interpolation.""" @@ -62,6 +91,53 @@ def compute_median_age(counts: list[int]) -> float: return float("nan") +def _bands_to_median_table(pivoted: pl.DataFrame) -> pl.DataFrame: + """Validate the pivoted age-band columns, then compute median age per LSOA. + + The pivot must contain exactly the canonical NOMIS TS007A bands; a + missing/extra/relabelled band would otherwise silently mis-align counts + against the wrong AGE_BANDS lower bound, so we fail loudly instead. + """ + # Validate the pivoted age-band columns against the canonical NOMIS set + # BEFORE computing anything. + band_cols = [c for c in pivoted.columns if c != "GEOGRAPHY_CODE"] + found = set(band_cols) + expected = set(EXPECTED_BAND_NAMES) + if found != expected: + missing = sorted(expected - found) + unexpected = sorted(found - expected) + raise ValueError( + "Census age-band columns do not match the expected NOMIS TS007A bands.\n" + f" expected {len(EXPECTED_BAND_NAMES)} bands, found {len(band_cols)}\n" + f" missing: {missing}\n" + f" unexpected: {unexpected}\n" + "Refusing to compute medians against misaligned bands." + ) + + # Use the canonical order (guaranteed aligned with AGE_BANDS), not positional + # string parsing, and treat a null band (zero-population) as 0 rather than + # crashing on sum(). + band_cols = list(EXPECTED_BAND_NAMES) + pivoted = pivoted.with_columns(pl.col(band_cols).fill_null(0)) + + print(f"Age bands found: {len(band_cols)}") + print(f" First: {band_cols[0]}") + print(f" Last: {band_cols[-1]}") + + rows = pivoted.select("GEOGRAPHY_CODE", *band_cols).to_dicts() + medians = [] + for row in rows: + counts = [row[col] for col in band_cols] + median = compute_median_age(counts) + medians.append( + {"lsoa21": row["GEOGRAPHY_CODE"], "median_age": round(median, 1)} + ) + + return pl.DataFrame(medians).with_columns( + pl.col("median_age").cast(pl.Float32), + ) + + def download_and_convert(output_path: Path) -> None: print("Downloading Census 2021 age by five-year bands from NOMIS...") frames = [] @@ -94,29 +170,7 @@ def download_and_convert(output_path: Path) -> None: values="OBS_VALUE", ) - # Extract age band columns in order and compute median - # NOMIS returns band names like "Aged 0 to 4 years", "Aged 85 years and over" - band_cols = [c for c in pivoted.columns if c != "GEOGRAPHY_CODE"] - # Sort by the lower bound of each band - band_cols.sort(key=lambda c: int(c.split()[1])) - - print(f"Age bands found: {len(band_cols)}") - print(f" First: {band_cols[0]}") - print(f" Last: {band_cols[-1]}") - - # Compute median age per LSOA - rows = pivoted.select("GEOGRAPHY_CODE", *band_cols).to_dicts() - medians = [] - for row in rows: - counts = [row[col] for col in band_cols] - median = compute_median_age(counts) - medians.append( - {"lsoa21": row["GEOGRAPHY_CODE"], "median_age": round(median, 1)} - ) - - result = pl.DataFrame(medians).with_columns( - pl.col("median_age").cast(pl.Float32), - ) + result = _bands_to_median_table(pivoted) print(f"England LSOAs: {result.height}") print( diff --git a/pipeline/download/noise.py b/pipeline/download/noise.py index 660ce30..545f559 100644 --- a/pipeline/download/noise.py +++ b/pipeline/download/noise.py @@ -83,11 +83,32 @@ NATIVE_RESOLUTION = 10 # Request pixel resolution in metres. RESOLUTION = NATIVE_RESOLUTION +# Defra encodes TRUE "no data" with this sentinel (NOT 0.0). A 0.0 cell that is +# otherwise inside the raster means "modelled below the lowest reporting band", +# i.e. genuinely quiet — see noise_overlay_tiles.py:167. +NOISE_NODATA_SENTINEL = np.float32(-96.0) + +# Lowest modelled Defra Lden reporting band (dB). Verified against the actual +# rasters: the minimum positive in-coverage value is 40.0 dB with NO values in +# (0, 40) — below the band, cells are encoded as 0.0 (genuinely quiet). We floor +# in-coverage cells to 40.0 so a below-band 0.0 surfaces as "we know it's quiet" +# (~40 dB) instead of collapsing to null ("we don't know"), WITHOUT inflating the +# ~35% of genuine 40-44.99 dB readings that a 45.0 floor would wrongly bump to 45. +# NB: 45.0 is the overlay's lowest *paint* stop (noise_overlay_tiles. +# NOISE_COLOR_STOPS[0]) — a rendering threshold, not the data's reporting floor. +NOISE_QUIET_FLOOR_DB = np.float32(40.0) + # The pipeline has postcode representative points rather than complete unit # polygons here. Use a small local footprint and take the maximum 10m cell so # postcode-level noise is not understated by centroid rounding. POSTCODE_NOISE_RADIUS_M = 50 +# Adjacent download tiles must overlap by at least the sampling radius so every +# postcode's 50m max-window is fully contained in at least one tile. Without +# this, a loud pixel just across a tile seam is invisible to a postcode on the +# far side, under-reporting noise near seams. +TILE_OVERLAP_M = POSTCODE_NOISE_RADIUS_M + # Retry/split behaviour for slow Defra WCS requests. Some 100km eastern tiles # intermittently return 504s; smaller fallback requests usually succeed. MAX_RETRIES = 3 @@ -287,6 +308,31 @@ def _download_tile( return [], [(min_e, min_n, max_e, max_n)] +def _generate_tiles( + min_e: int, + max_e: int, + min_n: int, + max_n: int, + tile_size: int, + overlap_m: int, + step: int, +) -> list[Tile]: + """Generate download tile bboxes stepping by ``step`` but extending each + tile's far edge by ``overlap_m`` so neighbours overlap. + + Overlapping neighbours guarantee that every postcode's POSTCODE_NOISE_RADIUS_M + sampling window is fully contained in at least one tile, so a loud pixel near + a seam is never lost (the sampler takes np.fmax across tiles). + """ + tiles: list[Tile] = [] + for tile_min_e in range(min_e, max_e, step): + for tile_min_n in range(min_n, max_n, step): + tile_max_e = min(tile_min_e + tile_size + overlap_m, BNG_MAX_E) + tile_max_n = min(tile_min_n + tile_size + overlap_m, BNG_MAX_N) + tiles.append((tile_min_e, tile_min_n, tile_max_e, tile_max_n)) + return tiles + + def download_raster( tile_dir: Path, wcs_base: str, @@ -296,12 +342,9 @@ def download_raster( allow_missing_tiles: bool = False, ) -> list[Path]: """Download noise GeoTIFF raster covering England, returning paths to saved files.""" - tiles = [] - for min_e in range(BNG_MIN_E, BNG_MAX_E, TILE_SIZE): - for min_n in range(BNG_MIN_N, BNG_MAX_N, TILE_SIZE): - max_e = min(min_e + TILE_SIZE, BNG_MAX_E) - max_n = min(min_n + TILE_SIZE, BNG_MAX_N) - tiles.append((min_e, min_n, max_e, max_n)) + tiles = _generate_tiles( + BNG_MIN_E, BNG_MAX_E, BNG_MIN_N, BNG_MAX_N, TILE_SIZE, TILE_OVERLAP_M, TILE_SIZE + ) print( f"[{label}] Downloading {len(tiles)} tiles at {RESOLUTION}m resolution ({MAX_WORKERS} workers)..." @@ -385,14 +428,23 @@ def sample_noise_at_postcodes( if len(candidate_indices) == 0: continue + # Defra rasters encode TRUE nodata as the -96.0 sentinel (and + # occasionally non-finite / dataset.nodata); genuinely quiet ground + # below the model's lowest reporting band is encoded as 0.0. Only + # the former is "we don't know" — the latter is a real "we know it's + # quiet" reading and must not collapse to null. So treat ONLY true + # nodata as -inf (it never wins a max and never counts as coverage), + # and clamp every in-coverage cell up to NOISE_QUIET_FLOOR_DB so a + # below-threshold 0.0 surfaces as the documented quiet floor. grid = dataset.read(1).astype(np.float32, copy=False) - invalid = ~np.isfinite(grid) | (grid == 0) + nodata = ~np.isfinite(grid) | np.isclose( + grid, NOISE_NODATA_SENTINEL, rtol=1e-5, atol=1e-5 + ) if dataset.nodata is not None: - invalid |= np.isclose( + nodata |= np.isclose( grid, np.float32(dataset.nodata), rtol=1e-5, atol=1e-5 ) - grid = grid.copy() - grid[invalid] = -np.inf + grid = np.where(nodata, -np.inf, np.maximum(grid, NOISE_QUIET_FLOOR_DB)) if filter_size > 1: grid = maximum_filter( grid, size=filter_size, mode="constant", cval=-np.inf @@ -412,12 +464,15 @@ def sample_noise_at_postcodes( sampled_indices = candidate_indices[in_bounds] sampled = grid[rows[in_bounds], cols[in_bounds]] - valid = sampled != -np.inf - if not np.any(valid): + # A finite sample means at least one in-coverage cell sat in the + # window (quiet -> floor, or louder). -inf means the whole window was + # true nodata, so the postcode stays uncovered (null) for this tile. + covered = np.isfinite(sampled) + if not np.any(covered): continue - sampled_indices = sampled_indices[valid] - sampled = sampled[valid] + sampled_indices = sampled_indices[covered] + sampled = sampled[covered] existing = noise_db[sampled_indices] noise_db[sampled_indices] = np.where( np.isnan(existing), sampled, np.maximum(existing, sampled) diff --git a/pipeline/download/places.py b/pipeline/download/places.py index ffa1f56..6b5d875 100644 --- a/pipeline/download/places.py +++ b/pipeline/download/places.py @@ -84,6 +84,38 @@ LONDON_COUNTY_CODES = {"E13000001", "E13000002"} DISPLAY_CITY_NEAREST_POSTCODE_MAX_M = 3_000 WGS84_TO_BNG = Transformer.from_crs("EPSG:4326", "EPSG:27700", always_xy=True) +# England British National Grid (EPSG:27700) bounding box, with margin. ONS NSPL stores +# postcodes that have no grid reference at the Null-Island sentinel lat=99.999999, +# long=0.000000, whose paired easting/northing collapse to the grid origin (0, 0) (or +# inf). Requiring coordinates inside this box drops the sentinel from every index, so an +# active postcode lacking a grid ref can never become a false nearest neighbour. +ENGLAND_BNG_MIN_EAST = 50_000.0 +ENGLAND_BNG_MAX_EAST = 660_000.0 +ENGLAND_BNG_MIN_NORTH = 0.0 +ENGLAND_BNG_MAX_NORTH = 660_000.0 + + +def _valid_wgs84_expr() -> pl.Expr: + """Rows with a real lat/long inside England (drops the ONS lat=99.999999, long=0.0 + no-grid-reference sentinel and any nulls), so they never enter a coordinate index.""" + return ( + pl.col("lat").is_not_null() + & pl.col("long").is_not_null() + & pl.col("lat").is_between(ENGLAND_BBOX_SOUTH, ENGLAND_BBOX_NORTH) + & pl.col("long").is_between(ENGLAND_BBOX_WEST, ENGLAND_BBOX_EAST) + ) + + +def _valid_bng_expr() -> pl.Expr: + """Rows with a real easting/northing inside England (drops the (0, 0) grid-origin / + inf paired with the ONS no-grid-reference sentinel and any nulls).""" + return ( + pl.col("east1m").is_not_null() + & pl.col("north1m").is_not_null() + & pl.col("east1m").is_between(ENGLAND_BNG_MIN_EAST, ENGLAND_BNG_MAX_EAST) + & pl.col("north1m").is_between(ENGLAND_BNG_MIN_NORTH, ENGLAND_BNG_MAX_NORTH) + ) + # Suffixes to strip from raw station names before appending the typed suffix. _STATION_STRIP = ( " tube station", @@ -303,7 +335,7 @@ def _outcode_tree(postcodes_path: Path) -> tuple[cKDTree, list[str]]: postcodes_path, columns=["pcds", "lat", "long", "ctry25cd", "doterm"] ) .filter((pl.col("ctry25cd") == ENGLAND_COUNTRY_CODE) & pl.col("doterm").is_null()) - .filter(pl.col("lat").is_not_null() & pl.col("long").is_not_null()) + .filter(_valid_wgs84_expr()) ) coords = np.column_stack( [df["lat"].to_numpy().astype(np.float64), df["long"].to_numpy().astype(np.float64)] @@ -359,12 +391,22 @@ def _build_street_places( return sorted(places, key=lambda place: place["name"].lower()) +def _poi_dedup_key(name: str, place_type: str, lat: float, lon: float) -> tuple: + """Geographic de-dup key: round(.,2) is ~1.1km lat / ~0.7km UK lon. + + Coarse enough to collapse the SAME physical POI mapped twice a few metres + apart, fine enough to keep genuinely distinct same-named POIs in different + towns (e.g. "Victoria Park" in London vs Bristol). + """ + return (name.lower(), place_type, round(lat, 2), round(lon, 2)) + + def _pois_to_places(pois: pl.DataFrame) -> list[dict]: - """Map high-value named POIs onto gazetteer place rows (M), de-duplicated by (name, type).""" + """Map high-value named POIs onto gazetteer place rows (M), de-duplicated by (name, type, coords).""" if pois.is_empty(): return [] - seen: set[tuple[str, str]] = set() + seen: set[tuple] = set() places: list[dict] = [] for row in pois.iter_rows(named=True): place_type = HIGH_VALUE_POI_CATEGORIES.get(str(row.get("category", ""))) @@ -373,7 +415,9 @@ def _pois_to_places(pois: pl.DataFrame) -> list[dict]: name = str(row.get("name") or "").strip() if len(name) < 3: continue - key = (name.lower(), place_type) + lat = float(row["lat"]) + lon = float(row["lng"]) + key = _poi_dedup_key(name, place_type, lat, lon) if key in seen: continue seen.add(key) @@ -381,8 +425,8 @@ def _pois_to_places(pois: pl.DataFrame) -> list[dict]: { "name": name, "place_type": place_type, - "lat": float(row["lat"]), - "lon": float(row["lng"]), + "lat": lat, + "lon": lon, "population": 0, "travel_destination": False, "display_city": None, @@ -395,11 +439,16 @@ def _append_high_value_pois(places: list[dict], pois_path: Path) -> int: pois = pl.read_parquet(pois_path, columns=["name", "category", "lat", "lng"]) new_places = _pois_to_places(pois) existing = { - (str(place["name"]).lower(), place["place_type"]) for place in places + _poi_dedup_key( + str(place["name"]), place["place_type"], place["lat"], place["lon"] + ) + for place in places } added = 0 for place in new_places: - key = (place["name"].lower(), place["place_type"]) + key = _poi_dedup_key( + place["name"], place["place_type"], place["lat"], place["lon"] + ) if key in existing: continue places.append(place) @@ -409,10 +458,14 @@ def _append_high_value_pois(places: list[dict], pois_path: Path) -> int: def _postcode_lookup(postcodes_path: Path) -> dict[str, tuple[float, float]]: - df = pl.read_parquet( - postcodes_path, - columns=["pcds", "lat", "long", "ctry25cd", "doterm"], - ).filter((pl.col("ctry25cd") == ENGLAND_COUNTRY_CODE) & pl.col("doterm").is_null()) + df = ( + pl.read_parquet( + postcodes_path, + columns=["pcds", "lat", "long", "ctry25cd", "doterm"], + ) + .filter((pl.col("ctry25cd") == ENGLAND_COUNTRY_CODE) & pl.col("doterm").is_null()) + .filter(_valid_wgs84_expr()) + ) return { _normalize_postcode(postcode): (float(lat), float(lon)) for postcode, lat, lon in df.select(["pcds", "lat", "long"]).iter_rows() @@ -470,7 +523,7 @@ def _london_postcode_tree(postcodes_path: Path) -> tuple[cKDTree, np.ndarray]: .filter( (pl.col("ctry25cd") == ENGLAND_COUNTRY_CODE) & pl.col("doterm").is_null() ) - .filter(pl.col("east1m").is_not_null() & pl.col("north1m").is_not_null()) + .filter(_valid_bng_expr()) .with_columns(_is_london_admin_expr().alias("is_london")) .select("east1m", "north1m", "is_london") ) diff --git a/pipeline/download/test_median_age.py b/pipeline/download/test_median_age.py new file mode 100644 index 0000000..ccff9f4 --- /dev/null +++ b/pipeline/download/test_median_age.py @@ -0,0 +1,75 @@ +import math + +import polars as pl +import pytest + +from pipeline.download import median_age +from pipeline.download.median_age import ( + AGE_BANDS, + EXPECTED_BAND_NAMES, + compute_median_age, +) + + +def test_expected_band_names_align_with_age_bands(): + assert len(EXPECTED_BAND_NAMES) == len(AGE_BANDS) + + +def test_compute_median_age_interpolates_within_median_band(): + # All weight in the 30-34 band -> median is the band midpoint via linear + # interpolation: 30 + ((50 - 0) / 100) * 5 = 32.5. + counts = [0] * len(AGE_BANDS) + counts[6] = 100 # "Aged 30 to 34 years" + assert compute_median_age(counts) == pytest.approx(32.5) + + # 50 below the median band, 100 inside the 35-39 band holding the median. + # half = 75; cumulative before band 7 = 50; 35 + ((75 - 50) / 100) * 5 = 36.25. + counts = [0] * len(AGE_BANDS) + counts[0] = 50 # below the median band + counts[7] = 100 # "Aged 35 to 39 years" holds the median + assert compute_median_age(counts) == pytest.approx(36.25) + + +def test_compute_median_age_empty_lsoa_is_nan(): + assert math.isnan(compute_median_age([0] * len(AGE_BANDS))) + + +def _pivoted(band_to_counts: dict[str, list]) -> pl.DataFrame: + """Build a pivot-shaped frame: GEOGRAPHY_CODE + one column per band.""" + n = len(next(iter(band_to_counts.values()))) + data = {"GEOGRAPHY_CODE": [f"E0100000{i}" for i in range(n)]} + data.update(band_to_counts) + return pl.DataFrame(data) + + +def test_null_band_count_is_treated_as_zero_not_crash(): + # One LSOA has a null in the 85+ band (NOMIS can return null for a band with + # zero people). It must be coerced to 0, not raise TypeError in sum(). With + # all 100 people in the 30-34 band the median is the band midpoint, 32.5. + counts_by_band = {name: [0] for name in EXPECTED_BAND_NAMES} + counts_by_band["Aged 30 to 34 years"] = [100] + counts_by_band["Aged 85 years and over"] = [None] + pivoted = _pivoted(counts_by_band) + + table = median_age._bands_to_median_table(pivoted) + + assert table.height == 1 + assert table["median_age"][0] == pytest.approx(32.5) + + +def test_missing_band_raises_clear_error(): + counts_by_band = {name: [10] for name in EXPECTED_BAND_NAMES} + del counts_by_band["Aged 85 years and over"] + pivoted = _pivoted(counts_by_band) + + with pytest.raises(ValueError, match=r"do not match the expected NOMIS"): + median_age._bands_to_median_table(pivoted) + + +def test_relabelled_band_raises_clear_error(): + counts_by_band = {name: [10] for name in EXPECTED_BAND_NAMES} + counts_by_band["Total"] = counts_by_band.pop("Aged 85 years and over") + pivoted = _pivoted(counts_by_band) + + with pytest.raises(ValueError, match=r"unexpected:"): + median_age._bands_to_median_table(pivoted) diff --git a/pipeline/download/test_noise.py b/pipeline/download/test_noise.py index ab5a01d..b7c159b 100644 --- a/pipeline/download/test_noise.py +++ b/pipeline/download/test_noise.py @@ -125,6 +125,205 @@ def test_download_raster_raises_on_missing_strict_tiles(monkeypatch, tmp_path): noise.download_raster(tmp_path, "base", "coverage", "Road") +def test_generate_tiles_neighbours_overlap_by_radius(): + tile_size = 20_000 + overlap = noise.POSTCODE_NOISE_RADIUS_M + tiles = noise._generate_tiles( + 0, 60_000, 0, 60_000, tile_size, overlap, tile_size + ) + + by_origin = {(min_e, min_n): (max_e, max_n) for min_e, min_n, max_e, max_n in tiles} + + # Horizontally adjacent tiles must overlap by >= overlap. + for (min_e, min_n), (max_e, _max_n) in by_origin.items(): + right_origin = (min_e + tile_size, min_n) + if right_origin in by_origin: + assert max_e - right_origin[0] >= overlap + + # Vertically adjacent tiles must overlap by >= overlap. + for (min_e, min_n), (_max_e, max_n) in by_origin.items(): + up_origin = (min_e, min_n + tile_size) + if up_origin in by_origin: + assert max_n - up_origin[1] >= overlap + + +def test_generate_tiles_clamps_to_grid_extent(): + tile_size = 20_000 + overlap = noise.POSTCODE_NOISE_RADIUS_M + tiles = noise._generate_tiles( + noise.BNG_MAX_E - tile_size, + noise.BNG_MAX_E, + noise.BNG_MAX_N - tile_size, + noise.BNG_MAX_N, + tile_size, + overlap, + tile_size, + ) + # The final (top-right) tile cannot extend past the England extent even + # though the overlap would otherwise push it beyond. + for _min_e, _min_n, max_e, max_n in tiles: + assert max_e <= noise.BNG_MAX_E + assert max_n <= noise.BNG_MAX_N + + +def _write_geotiff(path, data, left, top, resolution, nodata): + with rasterio.open( + path, + "w", + driver="GTiff", + height=data.shape[0], + width=data.shape[1], + count=1, + dtype=data.dtype, + crs="EPSG:27700", + transform=from_origin(left, top, resolution, resolution), + nodata=nodata, + ) as dataset: + dataset.write(data, 1) + + +def test_sample_noise_recovers_value_across_overlapping_seam(monkeypatch, tmp_path): + monkeypatch.setattr(noise, "POSTCODE_NOISE_RADIUS_M", 50) + monkeypatch.setattr(noise, "RESOLUTION", 10) + + # Two download tiles share a vertical seam at easting=100. _generate_tiles + # decides their real footprints: with the overlap fix the LEFT tile extends + # past the seam by POSTCODE_NOISE_RADIUS_M and thus covers a loud cell that + # physically sits just across the seam. + tile_size = 100 + overlap = noise.POSTCODE_NOISE_RADIUS_M + tiles = noise._generate_tiles(0, 200, 0, 100, tile_size, overlap, tile_size) + by_origin = { + (min_e, min_n): (max_e, max_n) for min_e, min_n, max_e, max_n in tiles + } + left_min_e, left_min_n = 0, 0 + left_max_e, left_max_n = by_origin[(left_min_e, left_min_n)] + # Overlap fix is what makes the left tile reach across the seam. + assert left_max_e > 100 + + # The loud 70 dB cell centre is at easting 105 (just across the seam) and + # the postcode point is at easting 75 in the left tile, within 50m of it. + res = noise.RESOLUTION + width = int((left_max_e - left_min_e) // res) + height = int((left_max_n - left_min_n) // res) + left_data = np.zeros((height, width), dtype=np.float32) + loud_row = height - 1 - int((25 - left_min_n) // res) # northing ~25 + loud_col = int((105 - left_min_e) // res) # easting ~105 + left_data[loud_row, loud_col] = 70.0 + _write_geotiff( + tmp_path / "left.tif", left_data, left_min_e, left_max_n, res, nodata=0 + ) + + # The right tile holds the same loud cell but the postcode point is NOT + # inside it, so without overlap the value would be lost for that point. + right_min_e, right_min_n = 100, 0 + right_max_e, right_max_n = by_origin[(right_min_e, right_min_n)] + rwidth = int((right_max_e - right_min_e) // res) + rheight = int((right_max_n - right_min_n) // res) + right_data = np.zeros((rheight, rwidth), dtype=np.float32) + right_data[rheight - 1 - int((25 - right_min_n) // res), 0] = 70.0 + _write_geotiff( + tmp_path / "right.tif", right_data, right_min_e, right_max_n, res, nodata=0 + ) + + result = noise.sample_noise_at_postcodes( + [tmp_path / "left.tif", tmp_path / "right.tif"], + easting=np.array([75.0]), + northing=np.array([25.0]), + label="Road", + col_name="road_noise_lden_db", + ) + + assert result.to_list() == [70.0] + + +def test_sample_noise_distinguishes_nodata_from_in_coverage_quiet( + monkeypatch, tmp_path +): + monkeypatch.setattr(noise, "POSTCODE_NOISE_RADIUS_M", 0) + monkeypatch.setattr(noise, "RESOLUTION", 10) + + # Defra encodes TRUE nodata as the -96.0 sentinel; genuinely quiet ground + # below the lowest reporting band is 0.0. With a 0m radius each postcode + # reads exactly one cell, so we can pin behaviour per cell: + # -96.0 sentinel -> null ("we don't know") + # 0.0 in-coverage -> NOISE_QUIET_FLOOR_DB ("we know it's quiet") + # 65.0 -> 65.0 (a real modelled reading) + data = np.array( + [ + [-96.0, 0.0, 65.0], + ], + dtype=np.float32, + ) + _write_geotiff(tmp_path / "noise.tif", data, 0, 10, 10, nodata=-96.0) + + result = noise.sample_noise_at_postcodes( + [tmp_path / "noise.tif"], + # Cell centres at easting 5 (nodata), 15 (quiet 0.0), 25 (loud 65). + easting=np.array([5.0, 15.0, 25.0]), + northing=np.array([5.0, 5.0, 5.0]), + label="Road", + col_name="road_noise_lden_db", + ) + + assert result.to_list() == [None, float(noise.NOISE_QUIET_FLOOR_DB), 65.0] + + +def test_sample_noise_preserves_genuine_reading_above_quiet_floor(monkeypatch, tmp_path): + monkeypatch.setattr(noise, "POSTCODE_NOISE_RADIUS_M", 0) + monkeypatch.setattr(noise, "RESOLUTION", 10) + + # The lowest Defra reporting band is 40.0 dB; genuine readings populate + # [40, ~80]. A genuine in-coverage reading at or just above the floor must be + # PRESERVED, not clamped UP to the floor — only true-quiet 0.0 is floored. A + # quiet floor set too high (e.g. 45) would inflate the ~35% of real 40-44.99 + # dB readings; this pins that they survive unchanged. + floor = float(noise.NOISE_QUIET_FLOOR_DB) + data = np.array( + [ + [42.0, floor, 0.0], + ], + dtype=np.float32, + ) + _write_geotiff(tmp_path / "noise.tif", data, 0, 10, 10, nodata=-96.0) + + result = noise.sample_noise_at_postcodes( + [tmp_path / "noise.tif"], + # Cell centres at easting 5 (42 dB), 15 (floor), 25 (quiet 0.0). + easting=np.array([5.0, 15.0, 25.0]), + northing=np.array([5.0, 5.0, 5.0]), + label="Road", + col_name="road_noise_lden_db", + ) + + # 42 preserved (NOT raised to the floor), floor preserved, 0.0 -> floor. + assert result.to_list() == [42.0, floor, floor] + # The floor must sit at/below the lowest genuine reading so nothing inflates. + assert floor <= 42.0 + + +def test_sample_noise_nodata_window_stays_null(monkeypatch, tmp_path): + monkeypatch.setattr(noise, "POSTCODE_NOISE_RADIUS_M", 15) + monkeypatch.setattr(noise, "RESOLUTION", 10) + + # A postcode whose entire 3x3 max-window is the -96.0 sentinel must remain + # null: no in-coverage cell was read, so "quiet" must NOT be inferred. + data = np.full((5, 5), -96.0, dtype=np.float32) + data[4, 4] = 70.0 # one loud cell, far from the nodata corner + _write_geotiff(tmp_path / "noise.tif", data, 0, 50, 10, nodata=-96.0) + + result = noise.sample_noise_at_postcodes( + [tmp_path / "noise.tif"], + # Top-left point: its 3x3 window is cells (rows 0-1, cols 0-1) = all -96. + easting=np.array([5.0]), + northing=np.array([45.0]), + label="Road", + col_name="road_noise_lden_db", + ) + + assert result.to_list() == [None] + + def test_sample_noise_at_postcodes_uses_local_maximum(monkeypatch, tmp_path): monkeypatch.setattr(noise, "POSTCODE_NOISE_RADIUS_M", 15) monkeypatch.setattr(noise, "RESOLUTION", 10) diff --git a/pipeline/download/test_places.py b/pipeline/download/test_places.py index 30ae9ec..48c9bae 100644 --- a/pipeline/download/test_places.py +++ b/pipeline/download/test_places.py @@ -9,10 +9,12 @@ from pipeline.download.places import ( _display_city_from_tags, _is_dlr_station, _is_tram_station, + _london_postcode_tree, _naptan_dlr_stations, _normalize_street_name, _ofs_universities, _outcode_of_postcode, + _outcode_tree, _pois_to_places, _select_university_name, _station_display_name, @@ -242,6 +244,42 @@ def test_pois_to_places_keeps_high_value_named_pois_only(): assert all(place["travel_destination"] is False for place in places) +def test_pois_to_places_keeps_distinct_same_named_pois(): + # Two genuinely distinct POIs sharing a name, far apart (London vs Bristol). + pois = pl.DataFrame( + { + "name": ["Victoria Park", "Victoria Park"], + "category": ["leisure/park", "leisure/park"], + "lat": [51.54, 51.46], + "lng": [-0.04, -2.60], + } + ) + + places = _pois_to_places(pois) + + assert len(places) == 2 + assert {(place["lat"], place["lon"]) for place in places} == { + (51.54, -0.04), + (51.46, -2.60), + } + + +def test_pois_to_places_still_dedupes_colocated(): + # The same physical POI mapped twice a few metres apart collapses to one. + pois = pl.DataFrame( + { + "name": ["Victoria Park", "Victoria Park"], + "category": ["leisure/park", "leisure/park"], + "lat": [51.5400, 51.5401], + "lng": [-0.0400, -0.0399], + } + ) + + places = _pois_to_places(pois) + + assert len(places) == 1 + + def test_display_city_from_tags_uses_explicit_london_context(): assert _display_city_from_tags({"is_in": "Croydon, London, UK"}) == "London" assert _display_city_from_tags({"is_in": "Croydon, Cambridgeshire, UK"}) is None @@ -290,3 +328,52 @@ def test_assign_london_display_city_uses_nearest_active_postcode_admin(tmp_path) assert assigned == 2 assert [place["display_city"] for place in places] == ["London", "London", None] + + +def test_no_grid_reference_sentinel_is_excluded_from_coordinate_trees(tmp_path): + # ONS NSPL stores postcodes with no grid reference at the Null-Island sentinel + # lat=99.999999, long=0.0, whose paired BNG coords collapse to the (0, 0) origin. + # Such an active postcode must never enter the nearest-neighbour indexes. + sentinel = { + "pcds": "ZZ99 9ZZ", + "lat": 99.999999, + "long": 0.0, + "doterm": None, + "ctry25cd": "E92000001", + "east1m": 0, + "north1m": 0, + "rgn25cd": "E12000007", + "lad25cd": "E09000008", + "cty25cd": "E13000002", + } + croydon_easting, croydon_northing = WGS84_TO_BNG.transform(-0.101793, 51.371273) + real = { + "pcds": "CR0 1SZ", + "lat": 51.371273, + "long": -0.101793, + "doterm": None, + "ctry25cd": "E92000001", + "east1m": int(round(croydon_easting)), + "north1m": int(round(croydon_northing)), + "rgn25cd": "E12000007", + "lad25cd": "E09000008", + "cty25cd": "E13000002", + } + postcodes = tmp_path / "postcodes.parquet" + pl.DataFrame([sentinel, real]).write_parquet(postcodes) + + # lat/long outcode tree: only the real postcode survives, so a London-area query + # cannot be tagged with the sentinel's (empty) outcode. + tree, outcodes = _outcode_tree(postcodes) + assert tree.n == 1 + assert outcodes == ["CR0"] + _, idx = tree.query([[51.371273, -0.101793]]) + assert outcodes[idx[0]] == "CR0" + + # BNG London tree: only the real postcode survives, so the (0, 0) origin can never + # be the nearest neighbour of a real place. + bng_tree, london_flags = _london_postcode_tree(postcodes) + assert bng_tree.n == 1 + assert london_flags.tolist() == [True] + _, bng_idx = bng_tree.query([[croydon_easting, croydon_northing]]) + assert bng_idx[0] == 0 diff --git a/pipeline/download/uprn_lookup.py b/pipeline/download/uprn_lookup.py index 3f2c804..dcedc0f 100644 --- a/pipeline/download/uprn_lookup.py +++ b/pipeline/download/uprn_lookup.py @@ -14,7 +14,7 @@ from pathlib import Path import polars as pl from pipeline.local_temp import local_tmp_dir -from pipeline.utils import download, extract_zip +from pipeline.utils import code_col_overrides, download, extract_zip URL = "https://www.arcgis.com/sharing/rest/content/items/4e0b4b3fbc2540caae27e7be532e61be/data" @@ -34,16 +34,16 @@ def find_csvs(extract_path: Path) -> list[Path]: def convert_to_parquet(csv_paths: list[Path], parquet_path: Path) -> None: # Some regional files infer different types for the same column (e.g. - # ruc21ind is String in most but Int64 in YH). Read all code columns as - # String to avoid schema mismatches. - CODE_COLS = { - "ruc21ind": pl.String, - "oac21ind": pl.String, - "imd19ind": pl.String, - } + # ruc21ind is String in most but Int64 in YH), and string codes like "UN1" + # appear deep in the data. Read all classification-index code columns as + # String to avoid schema mismatches. NSUL renames the year suffixes each + # release and polars silently ignores overrides for missing columns, so + # match on the suffix-free stem (from the header) rather than hard-coding. + names = pl.scan_csv(csv_paths[0]).collect_schema().names() + code_cols = code_col_overrides(names) df = pl.concat( [ - pl.scan_csv(p, try_parse_dates=True, schema_overrides=CODE_COLS) + pl.scan_csv(p, try_parse_dates=True, schema_overrides=code_cols) for p in csv_paths ] ) diff --git a/pipeline/test_validate_outputs.py b/pipeline/test_validate_outputs.py index 748a661..5b93e2a 100644 --- a/pipeline/test_validate_outputs.py +++ b/pipeline/test_validate_outputs.py @@ -265,6 +265,72 @@ def test_rejects_contaminated_postcode_features(tmp_path, monkeypatch, capsys): assert "[0, 100]" in err +def test_postcode_universe_rejects_missing(tmp_path, monkeypatch, capsys): + arcgis_path = tmp_path / "arcgis.parquet" + postcodes_path = tmp_path / "postcode.parquet" + pl.DataFrame( + { + "pcds": ["AA1 1AA", "AA1 1AB", "AA1 1AC"], + "ctry25cd": ["E92000001", "E92000001", "E92000001"], + "doterm": [None, None, None], + } + ).write_parquet(arcgis_path) + # Only 1 of the 3 active English postcodes is present, all otherwise valid. + _write_postcode_features( + postcodes_path, + { + "Postcode": ["AA1 1AA"], + "lat": [51.5], + "lon": [-0.1], + "ctry25cd": ["E92000001"], + "% White": [80.0], + }, + ) + monkeypatch.setattr( + "sys.argv", + [ + "validate", + "--postcode-universe", + f"{arcgis_path}::{postcodes_path}", + ], + ) + assert main() == 1 + err = capsys.readouterr().err + assert "missing" in err + assert "2" in err # 2 of the 3 active postcodes are absent + + +def test_postcode_universe_accepts_exact_match(tmp_path, monkeypatch): + arcgis_path = tmp_path / "arcgis.parquet" + postcodes_path = tmp_path / "postcode.parquet" + pl.DataFrame( + { + "pcds": ["AA1 1AA", "AA1 1AB"], + "ctry25cd": ["E92000001", "E92000001"], + "doterm": [None, None], + } + ).write_parquet(arcgis_path) + _write_postcode_features( + postcodes_path, + { + "Postcode": ["AA1 1AA", "AA1 1AB"], + "lat": [51.5, 53.4], + "lon": [-0.1, -2.2], + "ctry25cd": ["E92000001", "E92000001"], + "% White": [80.0, 55.0], + }, + ) + monkeypatch.setattr( + "sys.argv", + [ + "validate", + "--postcode-universe", + f"{arcgis_path}::{postcodes_path}", + ], + ) + assert main() == 0 + + def test_validates_properties_subset(tmp_path, monkeypatch): postcode = tmp_path / "postcode.parquet" properties = tmp_path / "properties.parquet" diff --git a/pipeline/transform/crime_spatial.py b/pipeline/transform/crime_spatial.py index b1a4de7..4b54623 100644 --- a/pipeline/transform/crime_spatial.py +++ b/pipeline/transform/crime_spatial.py @@ -273,6 +273,28 @@ def _write_avg_yr( for type_idx, name in enumerate(ALL_CRIME_TYPES): data[f"{name} (avg/yr)"] = avg[:, type_idx] + # Serious/Minor rollup headlines, computed the SAME way as the by-year rollup + # bars (_write_by_year/_rollup_long): sum the rollup's types per year, then + # average over the years in which ANY of those types occurred. This keeps the + # headline equal to the mean of the "Serious/Minor crime (by year)" bars. + # Summing the per-type avg/yr values instead (as the merge previously did) + # divides each type by its OWN years-present and overstates the rollup when a + # postcode's serious/minor types occur in disjoint years. + for rollup_name, rollup_types in ( + ("Serious crime", SERIOUS_CRIME_TYPES), + ("Minor crime", MINOR_CRIME_TYPES), + ): + rollup_idx = [ALL_CRIME_TYPES.index(name) for name in rollup_types] + rollup_counts = counts[:, rollup_idx, :].sum(axis=1) # (n_postcodes, n_years) + rollup_per_year = per_year[:, rollup_idx, :].sum(axis=1) + rollup_years_present = np.clip( + (rollup_counts > 0).sum(axis=1), 1, None + ).astype(np.float64) + rollup_avg = rollup_per_year.sum(axis=1) / rollup_years_present + data[f"{rollup_name} (avg/yr)"] = np.round(rollup_avg * norm, 1).astype( + np.float32 + ) + output_path.parent.mkdir(parents=True, exist_ok=True) pl.DataFrame(data).write_parquet(output_path, compression="zstd") print(f"Wrote postcode crime averages: {output_path}") diff --git a/pipeline/transform/join_epc_pp.py b/pipeline/transform/join_epc_pp.py index dc34bb3..b20b8de 100644 --- a/pipeline/transform/join_epc_pp.py +++ b/pipeline/transform/join_epc_pp.py @@ -106,7 +106,14 @@ def _select_epc_columns(raw: pl.LazyFrame) -> pl.LazyFrame: .alias("potential_energy_rating"), _clean_string("property_type").alias("epc_property_type"), _clean_string("built_form").alias("built_form"), - _clean_string("inspection_date").alias("inspection_date"), + # Parse to a real Date once (unparseable/blank -> null) so dedup can + # sort newest-first with nulls_last and _event_year can use dt.year(); + # a lexicographic string sort would let a null/garbled date win under + # Polars' default nulls-first descending order. EPC inspection dates + # are ISO (YYYY-MM-DD). + _clean_string("inspection_date") + .str.to_date(format="%Y-%m-%d", strict=False) + .alias("inspection_date"), _clean_number("total_floor_area", pl.Float64).alias("total_floor_area"), _clean_number("number_habitable_rooms", pl.Int16).alias( "number_habitable_rooms" @@ -247,9 +254,11 @@ def _run(epc_path: Path, price_paid_path: Path, output_path: Path, temp_dir: Pat normalize_postcode_key(pl.col("epc_postcode")).alias("_epc_match_postcode"), ) - # Dedup fork: keep latest certificate per property (existing logic) + # Dedup fork: keep latest certificate per property. inspection_date is a typed + # Date (see _select_epc_columns); nulls_last keeps a real-dated cert ahead of a + # null/unparseable-dated one so the genuinely newest certificate is chosen. epc = ( - epc_base.sort("inspection_date", descending=True) + epc_base.sort("inspection_date", descending=True, nulls_last=True) .group_by("_epc_match_address", "_epc_match_postcode") .first() .drop("tenure") @@ -303,11 +312,7 @@ def _run(epc_path: Path, price_paid_path: Path, output_path: Path, temp_dir: Pat ) .filter(pl.col("_event").is_not_null()) .with_columns( - pl.col("inspection_date") - .cast(pl.String) - .str.slice(0, 4) - .cast(pl.Int32) - .alias("_event_year"), + pl.col("inspection_date").dt.year().cast(pl.Int32).alias("_event_year"), ) .group_by("_epc_match_address", "_epc_match_postcode") .agg( diff --git a/pipeline/transform/merge.py b/pipeline/transform/merge.py index a6d18f8..d844572 100644 --- a/pipeline/transform/merge.py +++ b/pipeline/transform/merge.py @@ -807,6 +807,22 @@ def _remap_terminated_postcodes( ) +def _dedupe_collapsed_properties(wide: pl.LazyFrame) -> pl.LazyFrame: + """Keep one row per (postcode, pp_address) — the most-recent transaction. + + The terminated-postcode remap can map two distinct postcodes onto one active + successor, collapsing the same physical address onto a single + (postcode, pp_address) key with conflicting sale records. Keep the row with + the latest date_of_transfer so the headline price/date reflect the most + recent transaction; genuinely distinct addresses (a different pp_address) are + untouched. pp_address is non-null here (join_epc_pp filters it), so the key + never merges unrelated rows. + """ + return wide.sort( + "date_of_transfer", descending=True, nulls_last=True + ).unique(subset=["postcode", "pp_address"], keep="first", maintain_order=True) + + def _filter_to_active_english_postcodes( wide: pl.LazyFrame, active_postcodes: pl.LazyFrame ) -> pl.LazyFrame: @@ -837,38 +853,19 @@ def _join_area_side_tables( ) # Crime is counted spatially per postcode (incidents within 50m of the - # postcode boundary), so it joins on postcode rather than LSOA. - base = base.join(crime, on="postcode", how="left") - serious_crime_cols = [ - "Violence and sexual offences (avg/yr)", - "Robbery (avg/yr)", - "Burglary (avg/yr)", - "Possession of weapons (avg/yr)", - ] - minor_crime_cols = [ - "Anti-social behaviour (avg/yr)", - "Criminal damage and arson (avg/yr)", - "Shoplifting (avg/yr)", - "Bicycle theft (avg/yr)", - "Theft from the person (avg/yr)", - "Other theft (avg/yr)", - "Vehicle crime (avg/yr)", - "Public order (avg/yr)", - "Drugs (avg/yr)", - "Other crime (avg/yr)", - ] - # The LEFT join leaves every per-type column null for postcodes absent from - # the crime table; sum_horizontal alone would fabricate a "zero crime" - # rollup there, so keep the rollup null when ALL components are null. - base = base.with_columns( - pl.when(pl.all_horizontal([pl.col(c).is_null() for c in serious_crime_cols])) - .then(None) - .otherwise(pl.sum_horizontal(serious_crime_cols)) - .alias("serious_crime_avg_yr"), - pl.when(pl.all_horizontal([pl.col(c).is_null() for c in minor_crime_cols])) - .then(None) - .otherwise(pl.sum_horizontal(minor_crime_cols)) - .alias("minor_crime_avg_yr"), + # postcode boundary), so it joins on postcode rather than LSOA. crime_spatial + # precomputes the Serious/Minor headline rollups as the mean of the by-year + # rollup bars; read those straight through (renamed to the internal columns + # _finalize_merged_columns expects) rather than re-summing the per-type + # avg/yr columns — summing divides each type by its OWN years-present and + # overstates the rollup when types differ in coverage. A postcode absent from + # the crime table keeps null rollups via the left join (no fabricated zero); + # the per-type avg/yr columns pass through unchanged for display. + base = base.join(crime, on="postcode", how="left").rename( + { + "Serious crime (avg/yr)": "serious_crime_avg_yr", + "Minor crime (avg/yr)": "minor_crime_avg_yr", + } ) base = base.join(median_age, on="lsoa21", how="left") @@ -881,7 +878,37 @@ def _join_area_side_tables( ) if tree_density is not None: base = base.join(tree_density, on="postcode", how="left") - return base.join(broadband, left_on="postcode", right_on="bb_postcode", how="left") + + # Broadband is the one side table sourced straight from a third-party CSV + # (Ofcom `postcode_space`) rather than from a sibling pcds-keyed pipeline + # step, so its postcode may drift in spacing/casing from the NSPL `pcds` + # base key. Normalize BOTH sides to the same canonical pcds form (reusing + # `_canonical_postcode_expr`, exactly as the listing/EPC re-anchor joins do) + # before joining, otherwise a real postcode silently misses and its + # `max_download_speed` reads as null "no data" downstream. Re-aggregate on + # the canonical key so two raw spellings collapsing to one key can't fan out + # the base; drop a null canonical key so an unparseable Ofcom row joins + # nothing rather than matching a null-key base row. + broadband_canonical = ( + broadband.with_columns( + _canonical_postcode_expr("bb_postcode").alias("_bb_canonical_postcode") + ) + .drop_nulls("_bb_canonical_postcode") + .group_by("_bb_canonical_postcode") + .agg(pl.col("max_download_speed").max()) + ) + return ( + base.with_columns( + _canonical_postcode_expr("postcode").alias("_base_canonical_postcode") + ) + .join( + broadband_canonical, + left_on="_base_canonical_postcode", + right_on="_bb_canonical_postcode", + how="left", + ) + .drop("_base_canonical_postcode") + ) def _finalize_merged_columns(frame: pl.LazyFrame) -> pl.LazyFrame: @@ -1328,7 +1355,7 @@ def _load_direct_epc_candidates( ) return ( - epc_base.sort("inspection_date", descending=True) + epc_base.sort("inspection_date", descending=True, nulls_last=True) .group_by("_direct_epc_match_address", "_direct_epc_match_postcode") .first() .join( @@ -1918,6 +1945,10 @@ def _build( # terminated English postcodes are retained under their successor postcode. postcode_mapping = build_postcode_mapping(arcgis_path) wide = _remap_terminated_postcodes(wide, postcode_mapping.lazy()) + # The remap can collapse two terminated postcodes onto one active successor, + # duplicating a physical address's (postcode, pp_address) key; keep only the + # most-recent transaction per address before the per-postcode joins. + wide = _dedupe_collapsed_properties(wide) arcgis_raw = pl.scan_parquet(arcgis_path) arcgis = _active_english_postcode_area(arcgis_raw) active_postcodes = arcgis.select("postcode").unique() diff --git a/pipeline/transform/noise_overlay_tiles.py b/pipeline/transform/noise_overlay_tiles.py index b242fad..671c9c8 100644 --- a/pipeline/transform/noise_overlay_tiles.py +++ b/pipeline/transform/noise_overlay_tiles.py @@ -164,19 +164,39 @@ def _read_noise_tile( for info in candidates: with rasterio.open(info.path) as source: + # The Defra rasters encode genuine "quiet / below threshold" as the + # value 0.0 (only -96.0 is true nodata). Mask both BEFORE + # reprojecting so resampling never blends a 0 cell into an adjacent + # loud corridor and fabricates a halo of intermediate dB. + # + # Lden values are dB (a logarithmic scale), so bilinear resampling + # would arithmetically average neighbouring dB cells, which is + # acoustically wrong (it diluted a 75 dB peak to ~53 dB in tests) + # and inconsistent with the postcode sampler. Use Resampling.max: + # it preserves peak corridors, never invents an intermediate dB + # between a masked (NaN) quiet cell and a loud one, and mirrors the + # max semantics of sample_noise_at_postcodes. + src_arr = source.read(1).astype(np.float32) + nodata = source.nodata + invalid = ~np.isfinite(src_arr) | (src_arr <= 0) + if nodata is not None: + invalid |= np.isclose( + src_arr, np.float32(nodata), rtol=1e-5, atol=1e-5 + ) + src_arr = np.where(invalid, np.float32("nan"), src_arr) tile = np.full((tile_size, tile_size), np.nan, dtype=np.float32) reproject( - source=rasterio.band(source, 1), + source=src_arr, destination=tile, src_transform=source.transform, src_crs=source.crs, - src_nodata=source.nodata if source.nodata is not None else 0, + src_nodata=float("nan"), dst_transform=from_bounds( left, bottom, right, top, tile_size, tile_size ), dst_crs=WEB_MERCATOR_CRS, dst_nodata=np.nan, - resampling=Resampling.bilinear, + resampling=Resampling.max, ) tile[~np.isfinite(tile) | (tile <= 0)] = np.nan diff --git a/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py b/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py index 2c20d33..0b6ce96 100644 --- a/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py +++ b/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py @@ -27,7 +27,7 @@ from .output import ( to_wgs84_geojson_multi, write_district_geojson, ) -from .process_oa import _extract_polygonal, process_oa +from .process_oa import MIN_GEOM_AREA, _extract_polygonal, process_oa from .uprn import get_oa_uprns, load_uprns from .voronoi import _equal_split_fallback, compute_voronoi_regions @@ -341,6 +341,65 @@ class TestVoronoiDeduplication: assert "B" in result, "Postcode B missing with int64 coords" +class TestVoronoiCoincidentClusterNotCrushed: + """3+ postcodes at one coordinate must each keep a real cell. + + Pre-fix, the first coincident postcode stayed unjittered at the exact + cluster centre; with other seeds in the OA its Voronoi cell was squeezed + below MIN_GEOM_AREA, so _clean_polygonal dropped that active postcode + downstream. The fix spreads coincident postcodes onto a small regular + polygon (equal wedges), so none is crushed. + """ + + def test_coincident_cluster_plus_outer_seed_no_postcode_crushed(self): + # A block of flats: 4 distinct postcodes share one building coordinate, + # plus one other postcode elsewhere in the OA. Pre-fix, the centre seed's + # cell collapsed to ~0.0001 m^2 (< MIN_GEOM_AREA) and the postcode was + # dropped; every postcode must now keep a non-degenerate cell. + boundary = box(0, 0, 1000, 1000) + points = np.array( + [ + [500, 500], # A — coincident + [500, 500], # B — coincident + [500, 500], # C — coincident + [500, 500], # D — coincident + [100, 100], # OUT — elsewhere in the OA + ], + dtype=np.float64, + ) + postcodes = ["A", "B", "C", "D", "OUT"] + result = compute_voronoi_regions(points, postcodes, boundary) + for pc in postcodes: + assert pc in result, f"Postcode {pc} was dropped" + assert result[pc].area > MIN_GEOM_AREA, ( + f"Postcode {pc} cell {result[pc].area} <= MIN_GEOM_AREA" + ) + + def test_coincident_cluster_partitions_into_fair_wedges(self, square_boundary): + # N postcodes sharing one coordinate split the surrounding area into + # roughly equal wedges (regular-polygon seeds), none degenerate. + points = np.array([[500050, 180050]] * 5, dtype=np.float64) + postcodes = ["A", "B", "C", "D", "E"] + result = compute_voronoi_regions(points, postcodes, square_boundary) + fair_share = square_boundary.area / len(postcodes) + for pc in postcodes: + assert pc in result, f"Postcode {pc} was dropped" + # Each wedge is a meaningful fraction of its fair share (not crushed). + assert result[pc].area > 0.3 * fair_share, ( + f"Postcode {pc} cell {result[pc].area} far below fair share {fair_share}" + ) + + def test_two_coincident_split_is_fair(self, square_boundary): + """Regression: two postcodes at one coordinate split ~50/50.""" + points = np.array([[500050, 180050], [500050, 180050]], dtype=np.float64) + postcodes = ["A", "B"] + result = compute_voronoi_regions(points, postcodes, square_boundary) + assert "A" in result and "B" in result + total = result["A"].area + result["B"].area + assert result["A"].area / total > 0.4 + assert result["B"].area / total > 0.4 + + # --------------------------------------------------------------------------- # Bug 4: Voronoi collinear fallback gives everything to first postcode # --------------------------------------------------------------------------- diff --git a/pipeline/transform/postcode_boundaries/voronoi.py b/pipeline/transform/postcode_boundaries/voronoi.py index 21ce654..6d80d12 100644 --- a/pipeline/transform/postcode_boundaries/voronoi.py +++ b/pipeline/transform/postcode_boundaries/voronoi.py @@ -20,33 +20,48 @@ def compute_voronoi_regions( # Convert to float64 so sub-metre jitter isn't truncated. points = points.astype(np.float64) - # Deduplicate points, keeping one per (location, postcode) pair. - # Multiple postcodes at the same coordinate each get their own point, - # jittered by a tiny offset (0.01m) so Voronoi can distinguish them. - # Coords are rounded to mm precision for stable hashing — UPRN inputs are - # already integer metres, but the float64 cast can introduce ULP noise. - GOLDEN_ANGLE = np.pi * (3.0 - np.sqrt(5.0)) + # Deduplicate points, keeping one per (location, postcode) pair. Coords are + # rounded to mm precision for stable hashing — UPRN inputs are already integer + # metres, but the float64 cast can introduce ULP noise. + # + # Where several DISTINCT postcodes share one coordinate, jitter ALL of them + # onto a small regular polygon (equal 0.01m radius, equally spaced by angle) + # so their Voronoi cells become equal wedges and NONE is crushed. Leaving any + # seed at the centre — or innermost on a spiral — squeezes its cell below + # MIN_GEOM_AREA, which _clean_polygonal then drops downstream, silently losing + # an active postcode. Seeds at a UNIQUE coordinate are left exactly on their + # UPRN (no perturbation of normal Voronoi output). Coords are rounded to mm + # for stable hashing (the float64 cast can add ULP noise). + rounded_coords = [ + (round(float(points[i, 0]), 3), round(float(points[i, 1]), 3)) + for i in range(len(points)) + ] + coord_postcodes: dict[tuple[float, float], set[str]] = defaultdict(set) + for coord, pc in zip(rounded_coords, postcodes): + coord_postcodes[coord].add(pc) + seen: dict[tuple[float, float, str], bool] = {} unique_pts = [] unique_pcs = [] coord_counts: dict[tuple[float, float], int] = defaultdict(int) for i in range(len(points)): - coord = (round(float(points[i, 0]), 3), round(float(points[i, 1]), 3)) + coord = rounded_coords[i] key = (coord[0], coord[1], postcodes[i]) if key not in seen: seen[key] = True - jitter_idx = coord_counts[coord] - coord_counts[coord] += 1 - if jitter_idx == 0: - unique_pts.append(points[i].copy()) - else: - # Golden-angle spacing distributes any number of jittered - # points evenly around (and outward from) the original coord. + count = len(coord_postcodes[coord]) + if count > 1: + # Coincident cluster: equally-spaced regular polygon -> equal + # Voronoi wedges, so every postcode here keeps a fair share. + jitter_idx = coord_counts[coord] + coord_counts[coord] += 1 + angle = 2.0 * np.pi * jitter_idx / count jittered = points[i].copy() - angle = jitter_idx * GOLDEN_ANGLE jittered[0] += 0.01 * np.cos(angle) jittered[1] += 0.01 * np.sin(angle) unique_pts.append(jittered) + else: + unique_pts.append(points[i].copy()) unique_pcs.append(postcodes[i]) if len(unique_pts) == 1: diff --git a/pipeline/transform/price_estimation/index.py b/pipeline/transform/price_estimation/index.py index 676c0b8..e667ae3 100644 --- a/pipeline/transform/price_estimation/index.py +++ b/pipeline/transform/price_estimation/index.py @@ -19,8 +19,7 @@ from tqdm import tqdm from pipeline.transform.price_estimation.shrinkage import ( blend_dicts, hierarchical_shrinkage, - reanchor_dict, - reanchor_dicts, + lift_onto_parent, shrink_dicts, spatial_smooth, ) @@ -169,33 +168,47 @@ def solve_robust_index( signs_arr = np.concatenate([np.ones(mask2.sum()), -np.ones(mask1.sum())]) # Temporal smoothness prior: penalise curvature in the year betas with a - # second-difference penalty lambda * (beta_t - 2*beta_{t-1} + beta_{t-2})^2, - # encoded as extra least-squares rows (sqrt(lambda) * [1, -2, 1] against a - # zero target). This damps single-year index spikes without flattening - # genuine multi-year trends. Betas are ordered by calendar year; the baseline - # year (min_year, implicit beta=0) has no column, so the penalty spans the - # non-baseline years only. For cells with <3 betas there is no curvature to - # penalise and the solve is unchanged. + # second-difference penalty lambda * (d2 beta / dt2)^2, encoded as extra + # least-squares rows (sqrt(lambda) * [w0, w1, w2] against a zero target). + # The weights are the CALENDAR-SPACING-AWARE second-derivative coefficients + # for the consecutive triple (y0, y1, y2), so gap years are not treated as + # adjacent: a multi-year gap relaxes the penalty (correctly preserving a + # genuine level jump) instead of forcing a smooth ramp. For unit spacing + # (1, 1) these reduce to [1, -2, 1], leaving contiguous cells unchanged. + # This damps single-year index spikes without flattening genuine trends. + # Betas are ordered by calendar year; the baseline year (min_year, implicit + # beta=0) has no column, so the penalty spans the non-baseline years only. + # For cells with <3 betas there is no curvature to penalise and the solve is + # unchanged. n_pen = 0 pen_rows_arr = pen_cols_arr = np.empty(0, dtype=np.int64) pen_vals_arr = pen_b = np.empty(0, dtype=np.float64) if TEMPORAL_SMOOTHNESS_LAMBDA > 0 and n_cols >= 3: sqrt_lambda = float(np.sqrt(TEMPORAL_SMOOTHNESS_LAMBDA)) - cols_by_year = [c for _, c in sorted(year_to_col.items())] + years_sorted = sorted(year_to_col) + cols_by_year = [year_to_col[y] for y in years_sorted] n_pen = n_cols - 2 pen_rows = np.repeat(n + np.arange(n_pen), 3) pen_cols = np.empty(n_pen * 3, dtype=np.int64) + pen_vals = np.empty(n_pen * 3, dtype=np.float64) for k in range(n_pen): pen_cols[3 * k : 3 * k + 3] = ( cols_by_year[k], cols_by_year[k + 1], cols_by_year[k + 2], ) + y0, y1, y2 = years_sorted[k], years_sorted[k + 1], years_sorted[k + 2] + w0 = 2.0 / ((y1 - y0) * (y2 - y0)) + w1 = -2.0 / ((y1 - y0) * (y2 - y1)) + w2 = 2.0 / ((y2 - y1) * (y2 - y0)) + pen_vals[3 * k : 3 * k + 3] = ( + sqrt_lambda * w0, + sqrt_lambda * w1, + sqrt_lambda * w2, + ) pen_rows_arr = pen_rows.astype(np.int64) pen_cols_arr = pen_cols - pen_vals_arr = np.tile( - [sqrt_lambda, -2.0 * sqrt_lambda, sqrt_lambda], n_pen - ).astype(np.float64) + pen_vals_arr = pen_vals pen_b = np.zeros(n_pen, dtype=np.float64) n_total_rows = n + n_pen @@ -252,7 +265,11 @@ def compute_indices_for_level(pairs: pl.DataFrame, group_col: str): idx = solve_robust_index(y1, y2, lr, w) if idx: indices[key] = idx - n_pairs[key] = len(y1) + # Count only information-bearing pairs: same-year (year1==year2) and + # baseline-baseline pairs cancel in the sparse solve and contribute + # zero information to the annual index, so including them would + # inflate the shrinkage weight n/(n+k) and under-shrink noisy sectors. + n_pairs[key] = int(np.count_nonzero(y2 != y1)) return indices, n_pairs @@ -433,20 +450,17 @@ def build_index( f" {len(area_idx)} areas, {len(district_idx)} districts, {len(sector_idx)} sectors" ) - # Re-anchor every repeat-sales dict to the global base year before any - # shrinkage/smoothing/blending. solve_robust_index anchors each cell to - # log-index 0 at its OWN earliest year, so cells with shorter histories - # are measured from a later origin; combining them key-by-key would - # otherwise average level-incompatible numbers. The hedonic fallback is - # already anchored at min_year, so we align everything to min_year. - national_idx = reanchor_dict(national_idx, min_year) - area_idx = reanchor_dicts(area_idx, min_year) - district_idx = reanchor_dicts(district_idx, min_year) - sector_idx = reanchor_dicts(sector_idx, min_year) - - # Shrinkage: national -> hedonic first, then hierarchical + # Shrinkage: national -> hedonic first, then hierarchical. Each cell is + # anchored to log-index 0 at its OWN earliest year (solve_robust_index), + # so cells with shorter histories sit on a later origin than their wider + # parents. Before each blend we lift the child onto its parent's base at + # the child's first year (lift_onto_parent) -- otherwise combining them + # key-by-key averages level-incompatible numbers. The hedonic fallback is + # anchored at the global min_year, so it serves as the base for national. print(" Applying shrinkage...") - national_shrunk = shrink_dicts(national_idx, hedonic_idx, national_n) + national_shrunk = shrink_dicts( + lift_onto_parent(national_idx, hedonic_idx), hedonic_idx, national_n + ) sector_shrunk = hierarchical_shrinkage( sector_idx, sector_n, @@ -459,6 +473,7 @@ def build_index( sector_to_dist, dist_to_area, shrink_dicts, + lift_onto_parent, ) # Spatial smoothing diff --git a/pipeline/transform/price_estimation/knn.py b/pipeline/transform/price_estimation/knn.py index 0c18157..50c3b18 100644 --- a/pipeline/transform/price_estimation/knn.py +++ b/pipeline/transform/price_estimation/knn.py @@ -142,6 +142,20 @@ def _sale_identity_matches( target_price: float, target_sale_date: int, ) -> np.ndarray: + """Mark pool comparables that are (almost certainly) the target's own sale. + + properties.parquet has no per-property id, so a sale is identified by the + proxy tuple (postcode, price within 0.5, sale_date) to keep a target's own + prior sale out of its comparable set (leakage prevention). + + Limitation: new-build / bulk blocks sell many DISTINCT properties in one + postcode on the same day at the same price, so all such siblings collide on + this proxy and are excluded together. This is intentional conservative + over-exclusion: it guarantees no leakage at the cost of occasionally + dropping legitimate same-(postcode, price, date) siblings. The effect is + bounded (~1.8% of the pool) and a precise fix would require a per-property + id that the data does not carry. + """ if not target_postcode or not np.isfinite(target_price) or target_sale_date < 0: return np.zeros(len(pool_postcodes), dtype=bool) return ( @@ -166,6 +180,16 @@ def knn_median_psm( PSM is at the reference date used when building the pool. NaN where not computable (missing coords, unknown type, too few neighbors). + + Coordinate limitation: lat/lon come from postcode.parquet (one centroid per + postcode), so every property within a postcode is co-located. For a dense + postcode the "k nearest" therefore degenerates into an arbitrary + same-postcode subset whose membership is decided by KDTree index order + rather than true proximity. No property-level coordinates exist to fix this, + so the kNN signal is treated as a weak, noisy prior: the downstream guarded + blend (guarded_blend_estimates) only blends kNN when it is close to the + index estimate and otherwise discards it, bounding the impact of this + degeneracy. The result is deterministic for a fixed pool order. """ n = len(lat) result = np.full(n, np.nan) diff --git a/pipeline/transform/price_estimation/shrinkage.py b/pipeline/transform/price_estimation/shrinkage.py index 51101fe..a74d5e3 100644 --- a/pipeline/transform/price_estimation/shrinkage.py +++ b/pipeline/transform/price_estimation/shrinkage.py @@ -36,26 +36,43 @@ def _base_value(index: dict[int, float], base_year: int) -> float: return index[prior[-1]] -def reanchor_dict(index: dict[int, float], base_year: int) -> dict[int, float]: - """Re-anchor an index dict so index[base_year] == 0 (pure constant shift). +def lift_onto_parent( + child: dict[int, float], parent: dict[int, float] +) -> dict[int, float]: + """Lift a child index onto its parent's base before blending the two. - Subtracting the same constant from every year preserves all within-dict - year-to-year differences, so estimate.py's (current - sale) semantics are - unchanged; it only fixes the cross-dict level mismatch before blending. + solve_robust_index anchors every cell to log-index 0 at its OWN earliest + year, so a cell with a shorter history sits on a later origin than its + (wider) parent. Combining them key-by-key would average level-incompatible + numbers (a sector measured from 2008 blended with a district measured from + 1996). We add the parent's accumulated level at the child's first year, so + ``child[start] == parent[start]``: the child's own year-to-year moves are + layered on top of the parent's growth up to that point -- the same + assumption shrinkage already makes for years the child lacks. + + Re-basing on each cell's OWN earliest year (rather than the global base, + which the child cannot observe) is what makes this effective: subtracting + the child's value at the global base is always 0 and changes nothing. + + The shift is a single constant added to every year of the child, so the + child's own year-to-year differences are preserved. PRECONDITION for the + downstream estimate to be unaffected within the child's range: the parent's + year coverage must be a superset of the child's. This holds throughout + build_index, where each parent aggregates a superset of its children's sale + pairs, so shrink_dicts blends every child year against a present parent year + and the constant shift cancels in a within-range (current - sale) difference; + only comparisons that span the child's start year (e.g. a sale predating the + cell's own data) change. If a caller violates the precondition (a child year + the parent lacks), shrink_dicts passes that year through unshrunk and the + cancellation no longer holds. """ - if not index: - return index - shift = _base_value(index, base_year) - if shift == 0.0: - return index - return {y: v - shift for y, v in index.items()} - - -def reanchor_dicts( - indices: dict[str, dict[int, float]], base_year: int -) -> dict[str, dict[int, float]]: - """Re-anchor every index dict in a mapping to the common `base_year`.""" - return {key: reanchor_dict(idx, base_year) for key, idx in indices.items()} + if not child or not parent: + return child + child_start = min(child) + offset = _base_value(parent, child_start) - child[child_start] + if offset == 0.0: + return child + return {y: v + offset for y, v in child.items()} def shrink_dicts(raw: dict, parent: dict, n: int) -> dict: @@ -84,30 +101,40 @@ def hierarchical_shrinkage( sector_to_dist: dict[str, str], dist_to_area: dict[str, str], shrink_fn: Callable[[V, V, int], V], + lift_fn: Callable[[V, V], V] | None = None, ) -> dict[str, V]: """Top-down hierarchical shrinkage: area->top, district->area, sector->district. `top_level` is the ultimate fallback value (e.g. national shrunk toward hedonic, or just national). `shrink_fn(raw, parent, n)` blends raw toward parent. + `lift_fn(raw, parent)`, if given, re-bases raw onto its parent before blending + (see lift_onto_parent); pass None for category-keyed dicts where re-basing is + meaningless. """ + + def combine(raw: V, parent: V, n: int) -> V: + if lift_fn is not None: + raw = lift_fn(raw, parent) + return shrink_fn(raw, parent, n) + # Area -> top level area_shrunk = {} for area, val in area_vals.items(): - area_shrunk[area] = shrink_fn(val, top_level, area_n[area]) + area_shrunk[area] = combine(val, top_level, area_n[area]) # District -> area district_shrunk = {} for dist, val in district_vals.items(): a = dist_to_area.get(dist, "") parent = area_shrunk.get(a, top_level) - district_shrunk[dist] = shrink_fn(val, parent, district_n[dist]) + district_shrunk[dist] = combine(val, parent, district_n[dist]) # Sector -> district sector_shrunk = {} for sec, val in sector_vals.items(): d = sector_to_dist.get(sec, "") parent = district_shrunk.get(d, top_level) - sector_shrunk[sec] = shrink_fn(val, parent, sector_n[sec]) + sector_shrunk[sec] = combine(val, parent, sector_n[sec]) # Fill sectors without their own values for sec in all_sectors: diff --git a/pipeline/transform/price_estimation/test_index.py b/pipeline/transform/price_estimation/test_index.py new file mode 100644 index 0000000..4cc9e8e --- /dev/null +++ b/pipeline/transform/price_estimation/test_index.py @@ -0,0 +1,135 @@ +import numpy as np +import polars as pl + +from pipeline.transform.price_estimation import index as index_mod +from pipeline.transform.price_estimation.index import ( + compute_indices_for_level, + solve_robust_index, +) + + +def _pairs_from_path(true_levels: dict[int, float]): + """Build adjacent-year repeat-sale pairs that exactly trace a known path. + + Each consecutive pair's log_ratio is the difference of the true log-levels, + so the solver should recover the levels exactly (relative to the min year). + """ + years = sorted(true_levels) + y1, y2, lr, w = [], [], [], [] + for a, b in zip(years[:-1], years[1:]): + y1.append(a) + y2.append(b) + lr.append(true_levels[b] - true_levels[a]) + w.append(1.0) + return ( + np.array(y1, dtype=np.int32), + np.array(y2, dtype=np.int32), + np.array(lr, dtype=np.float64), + np.array(w, dtype=np.float64), + ) + + +def test_solver_recovers_contiguous_path(): + """A contiguous price path is recovered as log-levels relative to min_year. + + Proves the IRLS solver is correct (and unchanged) for contiguous data: the + spacing-aware penalty reduces to the standard [1,-2,1] for unit spacing. + """ + years = range(2010, 2021) + true = {y: 0.04 * (y - 2010) for y in years} # smooth (zero curvature) ramp + # Replicate each adjacent pair so MIN_PAIRS is comfortably met. + y1, y2, lr, w = _pairs_from_path(true) + y1 = np.tile(y1, 3) + y2 = np.tile(y2, 3) + lr = np.tile(lr, 3) + w = np.tile(w, 3) + + idx = solve_robust_index(y1, y2, lr, w) + + assert idx[2010] == 0.0 # baseline anchor + for y in years: + assert abs(idx[y] - (true[y] - true[2010])) < 1e-3 + + +def test_gap_spanning_level_jump_is_not_smoothed_into_a_ramp(): + """FIX #5: a sharp true level jump across a multi-year gap is preserved. + + Coverage is 2000,2001,2002 then 2015,2016 with cross-gap pairs encoding a + sharp jump at the gap. The uniform [1,-2,1] curvature penalty treats + (beta_2002, beta_2015, beta_2016) as three adjacent years and over-penalizes + the genuine level jump, biasing beta_2015 down toward a smooth ramp. The + spacing-aware second difference relaxes the penalty across the gap. + """ + # True log-levels relative to min_year (2000 anchored at 0). + true = { + 2000: 0.0, + 2001: 0.05, + 2002: 0.10, + 2015: 1.10, # sharp +1.0 jump across the gap + 2016: 1.15, + } + + y1, y2, lr, w = [], [], [], [] + + def add(a, b, n=4): + for _ in range(n): + y1.append(a) + y2.append(b) + lr.append(true[b] - true[a]) + w.append(1.0) + + # In-segment adjacent pairs. + add(2000, 2001) + add(2001, 2002) + add(2015, 2016) + # Cross-gap pairs consistent with the sharp jump. + add(2002, 2015) + add(2002, 2016) + + y1 = np.array(y1, dtype=np.int32) + y2 = np.array(y2, dtype=np.int32) + lr = np.array(lr, dtype=np.float64) + w = np.array(w, dtype=np.float64) + + # Use a strong penalty to make the smoothing bias obvious. + original = index_mod.TEMPORAL_SMOOTHNESS_LAMBDA + index_mod.TEMPORAL_SMOOTHNESS_LAMBDA = 1.0 + try: + idx = solve_robust_index(y1, y2, lr, w) + finally: + index_mod.TEMPORAL_SMOOTHNESS_LAMBDA = original + + assert idx[2000] == 0.0 # baseline anchor + # beta_2015 must stay near its true post-gap level, not get dragged down by a + # spurious curvature penalty that treats the gap as a single-year step. + assert abs(idx[2015] - true[2015]) < 0.05 + + +def test_n_pairs_counts_only_cross_year_pairs(): + """FIX #12: same-year pairs carry zero index information and must not inflate + the shrinkage weight; n_pairs counts only cross-year (year2 != year1) pairs.""" + rows = [] + + def add_pairs(group, year1, year2, n): + for _ in range(n): + rows.append( + { + "grp": group, + "year1": year1, + "year2": year2, + "log_ratio": 0.03 * (year2 - year1), + "weight": 1.0, + } + ) + + # 8 genuine cross-year pairs spanning enough years for a valid solve, plus 3 + # zero-information same-year pairs that must not be counted. + add_pairs("g", 2010, 2011, 4) + add_pairs("g", 2011, 2012, 4) + add_pairs("g", 2012, 2012, 3) # same-year, zero info + + pairs = pl.DataFrame(rows) + indices, n_pairs = compute_indices_for_level(pairs, "grp") + + assert "g" in indices + assert n_pairs["g"] == 8 # not 11 diff --git a/pipeline/transform/price_estimation/test_knn.py b/pipeline/transform/price_estimation/test_knn.py index c5309aa..3b147be 100644 --- a/pipeline/transform/price_estimation/test_knn.py +++ b/pipeline/transform/price_estimation/test_knn.py @@ -71,9 +71,49 @@ def test_knn_excludes_same_sale_and_uses_stable_comparables(): ), ) + # The five 900k same-postcode siblings share the target's (postcode, price, + # date) identity proxy, so they are all excluded as comparables, leaving the + # 200k/80sqm = 2_500 PSM neighbours. Removing same-identity siblings is an + # INTENTIONAL conservative leakage-prevention tradeoff (no per-property id + # exists to distinguish a target's own resale from a distinct bulk-block + # sibling sold same-day at the same price), not ideal behaviour -- see the + # _sale_identity_matches docstring. assert psm[0] == 2_500.0 +def test_knn_median_psm_is_deterministic(): + """Reproducibility guard (BUG #6): within-postcode neighbours are co-located + (one centroid per postcode), so the kNN result for dense postcodes depends on + an arbitrary same-postcode subset. That is acceptable, but it MUST be stable: + two identical calls against the same trees/inputs return identical output, so + future refactors cannot silently introduce run-to-run nondeterminism.""" + sale_date = date(2026, 1, 1) + rows = [ + { + "Postcode": "AA1 1AA", + "Property type": "Detached", + "lat": 51.5000 + i * 0.00001, + "lon": -0.1000, + "Total floor area (sqm)": 80.0, + "Last known price": 200_000.0 + i * 1_000.0, + "Date of last transaction": sale_date, + } + for i in range(40) + ] + df = pl.DataFrame(rows) + trees = build_knn_pool(df.lazy(), _flat_index(), 2026.0) + + args = dict( + lat=np.array([51.5000, 51.5002]), + lon=np.array([-0.1000, -0.1000]), + type_groups=np.array(["Detached", "Detached"]), + ) + first = knn_median_psm(trees, **args) + second = knn_median_psm(trees, **args) + + assert np.array_equal(first, second) + + def test_guarded_blend_routes_unstable_knn_to_index_and_caps_uplift(): blended = guarded_blend_estimates( index_est=np.array([120_000.0, 1_000_000.0]), diff --git a/pipeline/transform/price_estimation/test_shrinkage.py b/pipeline/transform/price_estimation/test_shrinkage.py index 06ab01f..5c8bed5 100644 --- a/pipeline/transform/price_estimation/test_shrinkage.py +++ b/pipeline/transform/price_estimation/test_shrinkage.py @@ -1,99 +1,117 @@ -"""Regression tests for common-base-year re-anchoring before blending. +"""Regression tests for parent-base lifting before hierarchical blending. -Each repeat-sales index dict is anchored to log-index 0 at its OWN earliest -year. shrink_dicts / blend_dicts combine dicts key-by-key, so dicts anchored to -different base years must be re-anchored to a single common base first, or the +solve_robust_index anchors every repeat-sales cell to log-index 0 at its OWN +earliest year, so a cell with a shorter history sits on a later origin than its +(wider) parent. shrink_dicts / blend_dicts combine dicts key-by-key, so a child +must first be lifted onto its parent's base at the child's first year, or the blend averages level-incompatible numbers (fix5-index-base-year). + +Note: re-anchoring each cell to the *global* base year is a no-op on real data +(a cell anchored to 0 at its own earliest year already reads 0 there, and the +global base is never later), which is why the fix lifts onto the *parent* at the +child's own start year instead. """ from pipeline.transform.price_estimation.shrinkage import ( - blend_dicts, - reanchor_dict, - reanchor_dicts, + hierarchical_shrinkage, + lift_onto_parent, shrink_dicts, ) +from pipeline.transform.price_estimation.utils import SHRINKAGE_K -def test_reanchor_is_pure_constant_shift_preserving_differences(): - """Re-anchoring only shifts the origin; year-to-year moves are unchanged.""" - # Anchored at its own earliest year 2008. - idx = {2008: 0.0, 2009: 0.10, 2010: 0.25, 2011: 0.40} +def test_lift_rebases_late_starting_child_onto_parent(): + """A child anchored at its own later start year is lifted to the parent's level there.""" + parent = {1996: 0.0, 2008: 0.80, 2016: 1.20, 2024: 1.50} + # Sector with its own repeat-sales data only from 2016, anchored at 2016 = 0. + sector = {2016: 0.0, 2024: 0.20} - reanchored = reanchor_dict(idx, 1996) - # 1996 is before this dict's history -> back-fill earliest value (0.0), - # so the shift is 0 and the dict is unchanged. - assert reanchored[2008] == 0.0 + lifted = lift_onto_parent(sector, parent) - # Same shape, different exact-hit base year: anchoring at 2010 subtracts 0.25. - reanchored_2010 = reanchor_dict(idx, 2010) - assert reanchored_2010[2010] == 0.0 - # All within-dict differences are preserved under the constant shift. - years = sorted(idx) - for a, b in zip(years, years[1:]): - assert abs((reanchored_2010[b] - reanchored_2010[a]) - (idx[b] - idx[a])) < 1e-12 + # child[start] now equals the parent's accumulated level at that year. + assert abs(lifted[2016] - parent[2016]) < 1e-12 # 1.20 + assert abs(lifted[2024] - (parent[2016] + 0.20)) < 1e-12 # 1.40 + # Pure constant shift: the child's own year-to-year move is preserved. + assert abs((lifted[2024] - lifted[2016]) - (sector[2024] - sector[2016])) < 1e-12 -def test_blend_different_base_years_needs_reanchoring(): - """Blending two dicts on different bases is biased unless re-anchored first. +def test_lift_is_noop_when_child_starts_at_parent_base(): + """A child whose earliest year is the parent's base (value 0) is unchanged.""" + parent = {1996: 0.0, 2008: 0.80, 2016: 1.20} + child = {1996: 0.0, 2008: 0.75, 2016: 1.10} + assert lift_onto_parent(child, parent) == child - Both cells observe the common base year 1996 but were anchored to DIFFERENT - origins (sectorA at 1996, sectorB at 2008, as solve_robust_index would do for - cells whose pair history starts at different years). They describe the SAME - true trajectory measured from 1996, so a 50/50 blend should reproduce that - common level. Pre-fix, blend_dicts mixes sectorB's 2008-relative numbers with - sectorA's 1996-relative numbers, level-shifting the smoothed result. + +def test_lift_handles_empty_inputs(): + assert lift_onto_parent({}, {2000: 0.0}) == {} + assert lift_onto_parent({2000: 0.0}, {}) == {2000: 0.0} + + +def test_lift_fixes_estimate_spanning_child_start_but_not_within_range(): + """The lift corrects comparisons that span the cell's start year, and ONLY those. + + A property sold in 2008 (before the sector's own data begins in 2016) and + valued in 2024: pre-lift the shrunk index mixes a 2016-based sector level + with 1996-based parent levels and badly understates the move. Comparisons + wholly inside the sector's own range (2016->2024) are unchanged, because the + lift is a pure constant shift that cancels in a within-cell difference. """ - base_year = 1996 + parent = {1996: 0.0, 2008: 0.80, 2016: 1.20, 2024: 1.50} + sector = {2016: 0.0, 2024: 0.20} # own data starts 2016 + n = 30 + w = n / (n + SHRINKAGE_K) - # True log-levels relative to 1996 (identical trajectory for both cells). - truth = {1996: 0.0, 2008: 0.80, 2012: 1.00} + raw = shrink_dicts(sector, parent, n) # pre-fix: blend without lifting + fixed = shrink_dicts(lift_onto_parent(sector, parent), parent, n) - # sectorA: anchored at 1996 (its earliest year) -> equals truth. - sector_a = dict(truth) - # sectorB: same trajectory but anchored at 2008 (subtract truth[2008] from - # every year), exactly how solve_robust_index would express a cell whose - # earliest year happened to be picked as 2008. - shift_b = truth[2008] - sector_b = {y: v - shift_b for y, v in truth.items()} + # Within the sector's own range the lift changes nothing. + assert abs((fixed[2024] - fixed[2016]) - (raw[2024] - raw[2016])) < 1e-12 - # --- Pre-fix behaviour: blend the raw dicts directly. --- - raw_blend = blend_dicts(sector_a, [sector_b], 0.5, [0.5]) - # Every year is pulled by half of shift_b (0.4) away from the truth. - assert abs(raw_blend[2012] - truth[2012]) > 0.3 - assert abs(raw_blend[1996] - truth[1996]) > 0.3 + # 2008 is parent-only in both (sector absent), so both read parent[2008]. + assert abs(raw[2008] - parent[2008]) < 1e-12 + assert abs(fixed[2008] - parent[2008]) < 1e-12 - # --- Post-fix behaviour: re-anchor to the common base, THEN blend. --- - reanchored = reanchor_dicts({"A": sector_a, "B": sector_b}, base_year) - fixed_blend = blend_dicts(reanchored["A"], [reanchored["B"]], 0.5, [0.5]) - # Both cells now read 0 at 1996 and the true level at every shared year. - for y in truth: - assert abs(fixed_blend[y] - truth[y]) < 1e-9 + raw_move = raw[2024] - raw[2008] + fixed_move = fixed[2024] - fixed[2008] + # Hand-computed: raw[2024] = w*0.20 + (1-w)*1.50; fixed[2024] = w*1.40 + (1-w)*1.50. + assert abs(raw_move - ((w * 0.20 + (1 - w) * 1.50) - 0.80)) < 1e-12 + assert abs(fixed_move - ((w * 1.40 + (1 - w) * 1.50) - 0.80)) < 1e-12 + # The fix raises the spanning move by exactly the parent growth to the + # sector's start year that the raw blend dropped (weighted by w). + assert abs((fixed_move - raw_move) - w * parent[2016]) < 1e-12 + # Fixed move is close to the true area-level move (0.70); raw badly understates it. + assert abs(fixed_move - 0.70) < 0.2 + assert raw_move < 0.4 * fixed_move -def test_shrink_dicts_after_reanchoring_is_consistent(): - """Shrinking a cell toward its parent must use a common origin.""" - base_year = 2000 - # Parent (national) anchored at 2000. - parent = {2000: 0.0, 2010: 0.50, 2020: 1.20} - # Sector tracking the parent exactly but anchored at 2010 (subtract 0.50 from - # every year), as solve_robust_index would express a cell whose earliest year - # is later. It still observes the 2000 base year (value -0.50). - sector = {2000: -0.50, 2010: 0.0, 2020: 0.70} - n = 0 # no own data weight -> result should equal parent after anchoring +def test_hierarchical_shrinkage_lift_fn_only_changes_spanning_comparisons(): + """Integration: passing lift_fn re-bases a late-starting sector via its parent chain.""" + top = {1996: 0.0, 2008: 0.80, 2016: 1.20, 2024: 1.50} + sector = {"AB1 1": {2016: 0.0, 2024: 0.20}} + sector_n = {"AB1 1": 300} + # No own area/district indices -> the sector shrinks straight toward `top`. + base_args = ( + sector, + sector_n, + {}, + {}, + {}, + {}, + top, + ["AB1 1"], + {"AB1 1": "AB1"}, + {"AB1": "AB"}, + shrink_dicts, + ) - reanchored_sector = reanchor_dict(sector, base_year) - # Exact hit on 2000 subtracts -0.50, putting the sector back on the parent's - # origin: 0.0 at 2000, 0.50 at 2010, 1.20 at 2020. - shrunk = shrink_dicts(reanchored_sector, parent, n) - assert abs(shrunk[2000] - 0.0) < 1e-9 - assert abs(shrunk[2010] - 0.50) < 1e-9 - assert abs(shrunk[2020] - 1.20) < 1e-9 + without_lift = hierarchical_shrinkage(*base_args)["AB1 1"] + with_lift = hierarchical_shrinkage(*base_args, lift_onto_parent)["AB1 1"] - -def test_reanchor_exact_hit_shifts_all_years(): - """When the base year is present, subtract its value from every year.""" - idx = {1996: 0.0, 2005: 0.30, 2015: 0.90} - reanchored = reanchor_dict(idx, 2005) - assert reanchored[2005] == 0.0 - assert abs(reanchored[1996] - (-0.30)) < 1e-12 - assert abs(reanchored[2015] - 0.60) < 1e-12 + # Within the sector's own range: identical (pure constant shift cancels). + assert abs( + (with_lift[2024] - with_lift[2016]) - (without_lift[2024] - without_lift[2016]) + ) < 1e-12 + # Spanning the sector's start year: the lift raises the 2008->2024 move. + assert (with_lift[2024] - with_lift[2008]) > ( + without_lift[2024] - without_lift[2008] + ) + 0.1 diff --git a/pipeline/transform/test_crime_spatial.py b/pipeline/transform/test_crime_spatial.py index fe9af06..d368e77 100644 --- a/pipeline/transform/test_crime_spatial.py +++ b/pipeline/transform/test_crime_spatial.py @@ -252,6 +252,47 @@ def test_avg_yr_is_simple_mean_of_year_bars(tmp_path): assert bars == {2023: pytest.approx(24.0, abs=0.05), 2024: pytest.approx(12.0, abs=0.05)} +def test_serious_rollup_avg_yr_equals_mean_of_rollup_bars(tmp_path): + # Two SERIOUS types occur in DISJOINT years for one postcode: Burglary only in + # 2014, Robbery only in 2024 (each a single full month -> 12/yr). The headline + # "Serious crime (avg/yr)" must equal the mean of the "Serious crime (by year)" + # bars (which span the UNION of years any serious type occurred), NOT the sum + # of the per-type means. Summing per-type means divides each type by its OWN + # years-present (1 each) -> 12 + 12 = 24; the consistent rollup divides the + # per-year serious total by the years any serious type occurred (2) -> 12. + units = tmp_path / "units" + _write_boundaries( + units, {"AB1": [_square_feature("AB1 1AA", 1000, 1000, 1010, 1010)]} + ) + + crime = tmp_path / "crime" + _write_month(crime, "2014-01", [_crime_row("2014-01", 1005, 1005, "Burglary")]) + _write_month(crime, "2024-01", [_crime_row("2024-01", 1005, 1005, "Robbery")]) + + output = tmp_path / "crime_by_postcode.parquet" + by_year = tmp_path / "crime_by_postcode_by_year.parquet" + transform_crime_spatial(crime, units, output, by_year, buffer_m=50.0) + + avg = pl.read_parquet(output).row(0, named=True) + # The precomputed rollup headline exists and equals the mean of the bars (12), + # not the sum of the per-type avg/yr values (Burglary 12 + Robbery 12 = 24). + assert "Serious crime (avg/yr)" in avg + assert avg["Burglary (avg/yr)"] == pytest.approx(12.0, abs=0.05) + assert avg["Robbery (avg/yr)"] == pytest.approx(12.0, abs=0.05) + assert avg["Serious crime (avg/yr)"] == pytest.approx(12.0, abs=0.05) + + serious_bars = { + p["year"]: p["count"] + for p in pl.read_parquet(by_year).row(0, named=True)["Serious crime (by year)"] + } + assert serious_bars == { + 2014: pytest.approx(12.0, abs=0.05), + 2024: pytest.approx(12.0, abs=0.05), + } + mean_of_bars = sum(serious_bars.values()) / len(serious_bars) + assert avg["Serious crime (avg/yr)"] == pytest.approx(mean_of_bars, abs=0.05) + + def test_avg_yr_denominator_is_per_postcode_not_global(tmp_path): # P (AB1 1AA) has burglaries only in its single most-recent year (2024); Q # (AB1 1AB), far away, has a burglary in 2014. The type therefore spans TWO diff --git a/pipeline/transform/test_join_epc_pp.py b/pipeline/transform/test_join_epc_pp.py index e10fde1..bd78db0 100644 --- a/pipeline/transform/test_join_epc_pp.py +++ b/pipeline/transform/test_join_epc_pp.py @@ -58,7 +58,7 @@ def test_scan_epc_certificates_supports_legacy_uppercase_csv(tmp_path: Path): "potential_energy_rating": "B", "epc_property_type": "House", "built_form": "Mid-Terrace", - "inspection_date": "2024-01-02", + "inspection_date": date(2024, 1, 2), "total_floor_area": 84.5, "number_habitable_rooms": None, "floor_height": 2.4, @@ -179,6 +179,65 @@ def test_run_joins_domestic_zip_with_price_paid(tmp_path: Path): assert df.get_column("historical_prices").list.len().to_list() == [2] +def test_run_dedup_prefers_valid_dated_cert_over_garbled_date(tmp_path: Path): + # Two certificates for the same property. The cert with the garbled, + # unparseable inspection_date must NOT be chosen as "latest": a string sort + # nulls-first would have picked it, attaching a stale rating/floor area. The + # valid-dated cert wins, so its rating ("C") and floor area (85) survive. + zip_path = tmp_path / "domestic-csv.zip" + with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as archive: + csv_buffer = io.StringIO() + writer = csv.DictWriter(csv_buffer, fieldnames=EPC_SOURCE_COLUMNS) + writer.writeheader() + writer.writerows( + [ + _row( + current_energy_rating="c", + inspection_date="2024-01-01", + total_floor_area="85", + ), + # Same property; an unparseable date (OCR/garbled). Under a raw + # string descending sort "not-a-date" outranks the ISO date and + # wins the dedup, but as a null Date it loses. + _row( + current_energy_rating="g", + inspection_date="not-a-date", + total_floor_area="40", + ), + ] + ) + archive.writestr("certificates-2024.csv", csv_buffer.getvalue()) + + price_paid_path = tmp_path / "price-paid.parquet" + pl.DataFrame( + { + "price": [250_000], + "date_of_transfer": [date(2024, 2, 3)], + "property_type": ["T"], + "postcode": ["AA1 1AA"], + "paon": ["1"], + "saon": [None], + "street": ["Example Street"], + "locality": [None], + "town_city": ["Exampletown"], + "duration": ["F"], + "old_new": ["N"], + "ppd_category": ["A"], + } + ).write_parquet(price_paid_path) + + output_path = tmp_path / "epc-pp.parquet" + _run(zip_path, price_paid_path, output_path, tmp_path) + + df = pl.read_parquet(output_path) + + assert df.height == 1 + # The valid-dated cert's facts are kept; the garbled-date cert is NOT chosen. + assert df.select("current_energy_rating", "total_floor_area").to_dicts() == [ + {"current_energy_rating": "C", "total_floor_area": 85.0} + ] + + def test_run_excludes_price_paid_rows_without_full_postcode(tmp_path: Path): zip_path = tmp_path / "domestic-csv.zip" with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as archive: diff --git a/pipeline/transform/test_merge.py b/pipeline/transform/test_merge.py index 482cc1c..3d4589e 100644 --- a/pipeline/transform/test_merge.py +++ b/pipeline/transform/test_merge.py @@ -14,6 +14,7 @@ from pipeline.transform.merge import ( _build_unmatched_listing_seed_rows, _canonical_postcode_expr, _coalesce_direct_epc_columns, + _dedupe_collapsed_properties, _filter_to_active_english_postcodes, _join_area_side_tables, _finalize_listings, @@ -193,6 +194,159 @@ def test_postcode_feature_validation_rejects_unsupported_or_ungeocoded_rows() -> _validate_postcode_feature_output(postcode_df, expected_postcode_count=2) +def test_postcode_feature_validation_rejects_wrong_count() -> None: + # The universe-size invariant: the postcode feature output must contain + # EXACTLY the active-England universe. Too few rows (silently dropped + # postcodes) and too many / duplicated rows (a join fan-out) must both fail, + # so neither a truncated build nor a one-to-many join can ship. + too_few = pl.DataFrame( + { + "Postcode": ["AA1 1AA"], + "lat": [51.0], + "lon": [-0.1], + "ctry25cd": ["E92000001"], + } + ) + with pytest.raises(ValueError, match="active England postcode universe"): + _validate_postcode_feature_output(too_few, expected_postcode_count=2) + + too_many = pl.DataFrame( + { + "Postcode": ["AA1 1AA", "BB1 1BB", "CC1 1CC"], + "lat": [51.0, 52.0, 53.0], + "lon": [-0.1, -0.2, -0.3], + "ctry25cd": ["E92000001"] * 3, + } + ) + with pytest.raises(ValueError, match="active England postcode universe"): + _validate_postcode_feature_output(too_many, expected_postcode_count=2) + + # Right row count but a duplicated key (n_unique < height) -- the signature of + # a join fan-out. + duplicated = pl.DataFrame( + { + "Postcode": ["AA1 1AA", "AA1 1AA"], + "lat": [51.0, 51.0], + "lon": [-0.1, -0.1], + "ctry25cd": ["E92000001", "E92000001"], + } + ) + with pytest.raises(ValueError, match="active England postcode universe"): + _validate_postcode_feature_output(duplicated, expected_postcode_count=2) + + +def test_join_area_side_tables_does_not_fan_out_on_unique_keys() -> None: + # Soundness: with side tables unique on their join key, the per-postcode + # feature joins emit exactly one row per postcode (no fan-out). A fan-out here + # would inflate the postcode universe above the active-England count -- the + # failure the universe assertion above is the backstop for. + base = pl.LazyFrame( + { + "postcode": ["AA1 1AA", "BB2 2BB"], + "lsoa21": ["E01000001", "E01000002"], + "Local Authority District code (2024)": ["E09000001", "E09000002"], + "pcon": ["E14000001", "E14000002"], + } + ) + + def _by_postcode(extra: dict) -> pl.LazyFrame: + return pl.LazyFrame({"postcode": ["AA1 1AA", "BB2 2BB"], **extra}) + + crime = pl.LazyFrame( + { + "postcode": ["AA1 1AA", "BB2 2BB"], + "Serious crime (avg/yr)": [1.0, 2.0], + "Minor crime (avg/yr)": [3.0, 4.0], + } + ) + joined = _join_area_side_tables( + base, + iod=pl.LazyFrame({"LSOA code (2021)": ["E01000001", "E01000002"]}), + ethnicity=pl.LazyFrame({"Geography_code": ["E09000001", "E09000002"]}), + crime=crime, + median_age=pl.LazyFrame({"lsoa21": ["E01000001", "E01000002"]}), + election=pl.LazyFrame({"pcon": ["E14000001", "E14000002"]}), + poi_counts=_by_postcode({}), + noise=_by_postcode({}), + school_proximity=_by_postcode({}), + conservation_areas=_by_postcode({CONSERVATION_AREA_FEATURE: ["Yes", "No"]}), + tree_density=None, + broadband=pl.LazyFrame( + { + "bb_postcode": ["AA1 1AA", "BB2 2BB"], + "max_download_speed": pl.Series([100, 300], dtype=pl.UInt16), + } + ), + ).collect() + + # One row per postcode in -> one row out; the universe is not inflated. + assert joined.height == 2 + assert sorted(joined["postcode"].to_list()) == ["AA1 1AA", "BB2 2BB"] + + +def test_join_area_side_tables_normalizes_broadband_postcode_key() -> None: + # Broadband comes straight from Ofcom's CSV, so its postcode can drift in + # spacing/casing from the NSPL `pcds` base key. Both sides must be reduced + # to the same canonical form so a real postcode populates + # `max_download_speed` instead of silently missing the left join. + base = pl.LazyFrame( + { + "postcode": ["AB1 2CD", "EF3 4GH"], + "lsoa21": ["E01000001", "E01000002"], + "Local Authority District code (2024)": ["E09000001", "E09000002"], + "pcon": ["E14000001", "E14000002"], + } + ) + + def _by_postcode(extra: dict) -> pl.LazyFrame: + return pl.LazyFrame({"postcode": ["AB1 2CD", "EF3 4GH"], **extra}) + + crime = pl.LazyFrame( + { + "postcode": ["AB1 2CD", "EF3 4GH"], + "Serious crime (avg/yr)": [1.0, 2.0], + "Minor crime (avg/yr)": [3.0, 4.0], + } + ) + # AB1 2CD arrives lowercase + un-spaced; EF3 4GH arrives under two distinct + # raw spellings that canonicalize to one key (the max speed must win, with + # no fan-out of the base row). + broadband = pl.LazyFrame( + { + "bb_postcode": ["ab1 2cd", "ef34gh", "EF3 4GH"], + "max_download_speed": pl.Series([300, 30, 1000], dtype=pl.UInt16), + } + ) + joined = _join_area_side_tables( + base, + iod=pl.LazyFrame({"LSOA code (2021)": ["E01000001", "E01000002"]}), + ethnicity=pl.LazyFrame({"Geography_code": ["E09000001", "E09000002"]}), + crime=crime, + median_age=pl.LazyFrame({"lsoa21": ["E01000001", "E01000002"]}), + election=pl.LazyFrame({"pcon": ["E14000001", "E14000002"]}), + poi_counts=_by_postcode({}), + noise=_by_postcode({}), + school_proximity=_by_postcode({}), + conservation_areas=_by_postcode({CONSERVATION_AREA_FEATURE: ["Yes", "No"]}), + tree_density=None, + broadband=broadband, + ).collect() + + # No fan-out: still one row per base postcode. + assert joined.height == 2 + speeds = dict( + zip(joined["postcode"].to_list(), joined["max_download_speed"].to_list()) + ) + # Spacing/casing drift still joins. + assert speeds["AB1 2CD"] == 300 + # Two raw spellings collapse to one canonical key; the max wins. + assert speeds["EF3 4GH"] == 1000 + # The temporary canonical join key is not leaked into the output schema. + assert "_base_canonical_postcode" not in joined.columns + assert "_bb_canonical_postcode" not in joined.columns + assert "bb_postcode" not in joined.columns + + def test_listed_building_feature_is_property_level() -> None: assert LISTED_BUILDING_FEATURE not in _AREA_COLUMNS @@ -758,8 +912,10 @@ def test_coalesce_direct_epc_was_council_house_prefers_yes() -> None: def test_join_area_side_tables_preserves_missing_crime_as_null() -> None: # The crime table is LEFT-joined per postcode; a postcode absent from it - # must NOT be fabricated as "zero crime" (the safest value). When every - # per-type column is null the Serious/Minor rollups must stay null. + # must NOT be fabricated as "zero crime" (the safest value). The Serious/Minor + # rollups are precomputed in crime_spatial (the mean of the by-year rollup + # bars), so the merge reads them straight through; a missing postcode leaves + # them null. base = pl.LazyFrame( { "postcode": ["AA1 1AA", "BB2 2BB"], @@ -772,7 +928,10 @@ def test_join_area_side_tables_preserves_missing_crime_as_null() -> None: def _by_postcode(extra: dict) -> pl.LazyFrame: return pl.LazyFrame({"postcode": ["AA1 1AA", "BB2 2BB"], **extra}) - # Crime is present only for AA1 1AA; BB2 2BB is absent from the table. + # Crime is present only for AA1 1AA; BB2 2BB is absent from the table. The + # rollup headlines are precomputed values (deliberately NOT the per-type sum, + # which would be 10.0 each) so this test proves the merge consumes the + # precomputed column rather than re-summing per-type columns. crime = pl.LazyFrame( { "postcode": ["AA1 1AA"], @@ -790,6 +949,8 @@ def test_join_area_side_tables_preserves_missing_crime_as_null() -> None: "Public order (avg/yr)": [1.0], "Drugs (avg/yr)": [1.0], "Other crime (avg/yr)": [1.0], + "Serious crime (avg/yr)": [7.5], + "Minor crime (avg/yr)": [4.2], } ) @@ -805,7 +966,12 @@ def test_join_area_side_tables_preserves_missing_crime_as_null() -> None: school_proximity=_by_postcode({}), conservation_areas=_by_postcode({CONSERVATION_AREA_FEATURE: ["Yes", "No"]}), tree_density=None, - broadband=pl.LazyFrame({"bb_postcode": ["AA1 1AA", "BB2 2BB"]}), + broadband=pl.LazyFrame( + { + "bb_postcode": ["AA1 1AA", "BB2 2BB"], + "max_download_speed": pl.Series([100, 300], dtype=pl.UInt16), + } + ), ).collect() by_postcode = { @@ -814,14 +980,50 @@ def test_join_area_side_tables_preserves_missing_crime_as_null() -> None: "postcode", "serious_crime_avg_yr", "minor_crime_avg_yr" ).iter_rows(named=True) } - # Present postcode: rollups are the component sums (1+2+3+4, 10×1). - assert by_postcode["AA1 1AA"]["serious_crime_avg_yr"] == 10.0 - assert by_postcode["AA1 1AA"]["minor_crime_avg_yr"] == 10.0 + # Present postcode: rollups are the precomputed headline values, read through + # unchanged (NOT the per-type sum of 10.0). + assert by_postcode["AA1 1AA"]["serious_crime_avg_yr"] == 7.5 + assert by_postcode["AA1 1AA"]["minor_crime_avg_yr"] == 4.2 # Missing postcode: rollups stay null rather than fabricating 0.0. assert by_postcode["BB2 2BB"]["serious_crime_avg_yr"] is None assert by_postcode["BB2 2BB"]["minor_crime_avg_yr"] is None +def test_dedupe_collapsed_properties_keeps_most_recent_per_address() -> None: + # The terminated-postcode remap can merge two distinct postcodes onto one + # active successor, collapsing the same physical address onto a single + # (postcode, pp_address) key with conflicting sale records. The dedup must + # keep exactly one row per (postcode, pp_address) -- the most recent + # transaction -- and must not collapse genuinely distinct addresses. + from datetime import datetime + + wide = pl.LazyFrame( + { + "postcode": ["SW3 3JY", "SW3 3JY", "SW3 3JY"], + "pp_address": ["45 ELYSTAN PLACE", "45 ELYSTAN PLACE", "9 OTHER ROAD"], + "date_of_transfer": [ + datetime(1990, 1, 1), + datetime(2015, 6, 1), + datetime(2000, 1, 1), + ], + "latest_price": [1_587_700, 4_500_000, 250_000], + } + ) + + out = _dedupe_collapsed_properties(wide).collect() + + # One row per (postcode, pp_address): the two ELYSTAN PLACE rows collapse to one. + assert out.height == 2 + assert out.select(["postcode", "pp_address"]).is_unique().all() + by_addr = {r["pp_address"]: r for r in out.iter_rows(named=True)} + # The kept ELYSTAN PLACE row is the most recent transaction (2015 @ 4.5M), + # not an arbitrary one. + assert by_addr["45 ELYSTAN PLACE"]["date_of_transfer"] == datetime(2015, 6, 1) + assert by_addr["45 ELYSTAN PLACE"]["latest_price"] == 4_500_000 + # A genuinely distinct address in the same postcode is untouched. + assert by_addr["9 OTHER ROAD"]["latest_price"] == 250_000 + + def _property_candidates(rows: list[dict]) -> pl.DataFrame: base = { "postcode": "AA1 1AA", diff --git a/pipeline/transform/test_noise_overlay_tiles.py b/pipeline/transform/test_noise_overlay_tiles.py new file mode 100644 index 0000000..149a08a --- /dev/null +++ b/pipeline/transform/test_noise_overlay_tiles.py @@ -0,0 +1,110 @@ +import numpy as np +import rasterio +from rasterio.transform import from_origin +from rasterio.warp import transform_bounds + +from pipeline.transform import noise_overlay_tiles +from pipeline.transform.noise_overlay_tiles import RasterInfo, _read_noise_tile + + +def _write_corridor_raster(path, nodata=-96.0): + """A small EPSG:27700 raster: a column of 70 dB cells adjacent to genuine + 0.0 (quiet) cells. Bilinear blending of the 0 cells would fabricate a halo + of intermediate dB values between 0 and 70.""" + # 8x8 grid: leftmost two columns are 70 dB, the rest are genuine quiet 0.0. + data = np.zeros((8, 8), dtype=np.float32) + data[:, 0:2] = 70.0 + # Place one true nodata cell to make sure it is also masked out. + data[0, 7] = nodata + + # 10m cells anchored somewhere inside England's BNG extent. + left = 300_000.0 + top = 300_080.0 + transform = from_origin(left, top, 10.0, 10.0) + with rasterio.open( + path, + "w", + driver="GTiff", + height=data.shape[0], + width=data.shape[1], + count=1, + dtype=data.dtype, + crs="EPSG:27700", + transform=transform, + nodata=nodata, + ) as dataset: + dataset.write(data, 1) + return path + + +def test_read_noise_tile_does_not_fabricate_halo(tmp_path): + raster_path = _write_corridor_raster(tmp_path / "corridor.tif") + + with rasterio.open(raster_path) as dataset: + bounds_27700 = dataset.bounds + bounds_mercator = transform_bounds( + dataset.crs, + noise_overlay_tiles.WEB_MERCATOR_CRS, + *bounds_27700, + densify_pts=21, + ) + + info = RasterInfo(path=raster_path, bounds_mercator=bounds_mercator) + + # Render at high resolution so any bilinear halo would surface as + # intermediate dB values along the corridor/quiet seam. + tile_size = 64 + tile = _read_noise_tile([info], bounds_mercator, tile_size) + + finite = tile[np.isfinite(tile)] + # Every finite cell must be the genuine corridor value (~70). There must be + # NO fabricated halo strictly between 0 and 70. + halo = finite[(finite > 0.0) & (finite < 70.0 - 1e-3)] + assert halo.size == 0, f"fabricated halo values present: {np.unique(halo)}" + # Sanity: the corridor itself must still be rendered. + assert finite.size > 0 + assert np.all(finite >= 70.0 - 1e-3) + + +def test_read_noise_tile_preserves_peak_under_downsample(tmp_path): + # 8x8 EPSG:27700 raster: a single loud 75 dB cell in a 50 dB field. + # Downsampling into a smaller tile with bilinear would dilute the peak + # (arithmetic dB averaging); Resampling.max must keep the worst-case dB. + data = np.full((8, 8), 50.0, dtype=np.float32) + data[4, 4] = 75.0 + transform = from_origin(300_000.0, 300_080.0, 10.0, 10.0) + raster_path = tmp_path / "peak.tif" + with rasterio.open( + raster_path, + "w", + driver="GTiff", + height=data.shape[0], + width=data.shape[1], + count=1, + dtype=data.dtype, + crs="EPSG:27700", + transform=transform, + nodata=-96.0, + ) as dataset: + dataset.write(data, 1) + + with rasterio.open(raster_path) as dataset: + bounds_mercator = transform_bounds( + dataset.crs, + noise_overlay_tiles.WEB_MERCATOR_CRS, + *dataset.bounds, + densify_pts=21, + ) + + info = RasterInfo(path=raster_path, bounds_mercator=bounds_mercator) + + # Render the 8x8 source into a 4x4 tile: this downsamples, so bilinear + # would average the 75 dB peak away. + tile = _read_noise_tile([info], bounds_mercator, 4) + finite = tile[np.isfinite(tile)] + + assert finite.size > 0 + # The loud peak must survive the downsample (max, not arithmetic mean). + assert finite.max() >= 75.0 - 1e-3, f"peak diluted to {finite.max()}" + # Max resampling must never invent a value louder than the source. + assert finite.max() <= 75.0 + 1e-3 diff --git a/pipeline/transform/test_transform_poi.py b/pipeline/transform/test_transform_poi.py index b6078a3..023d464 100644 --- a/pipeline/transform/test_transform_poi.py +++ b/pipeline/transform/test_transform_poi.py @@ -1,12 +1,115 @@ +import json + import polars as pl from pipeline.transform.transform_poi import ( _load_ofsted_ratings, _school_icon_category_expr, + transform, transform_grocery_retail_points, ) +def _write_boundary(tmp_path): + """A FeatureCollection whose single feature covers the London-area test + coords used by the transform() fixtures, so in_england_mask keeps them.""" + boundary_path = tmp_path / "england.geojson" + coords = [[-1.0, 51.0], [1.0, 51.0], [1.0, 52.0], [-1.0, 52.0], [-1.0, 51.0]] + boundary_path.write_text( + json.dumps( + { + "type": "FeatureCollection", + "features": [ + { + "type": "Feature", + "properties": {}, + "geometry": {"type": "Polygon", "coordinates": [coords]}, + } + ], + } + ) + ) + return boundary_path + + +def _write_transform_inputs(tmp_path, raw_pois: pl.DataFrame): + """Materialise the parquet inputs transform() requires around a given raw + OSM POIs frame. NaPTAN / grocery / GIAS / Ofsted are minimal but valid.""" + input_path = tmp_path / "pois.parquet" + raw_pois.write_parquet(input_path) + + naptan_path = tmp_path / "naptan.parquet" + pl.DataFrame( + { + "id": ["naptan-1"], + "name": ["Test Rail Station"], + "category": ["Rail station"], + "lat": [51.51], + "lng": [-0.13], + } + ).write_parquet(naptan_path) + + grocery_path = tmp_path / "grocery.parquet" + pl.DataFrame( + { + "id": list(range(1, 6)), + "retailer": ["Tesco"] * 5, + "fascia": ["Tesco"] * 5, + "store_name": [f"Tesco Test {i}" for i in range(1, 6)], + "long_wgs": [-0.14] * 5, + "lat_wgs": [51.52] * 5, + } + ).write_parquet(grocery_path) + + gias_path = tmp_path / "gias.parquet" + pl.DataFrame( + { + "urn": [1001], + "name": ["Test Primary School"], + "phase": ["Primary"], + "type": ["Community school"], + "type_group": ["Local authority maintained schools"], + "age_range": ["4–11"], + "gender": ["Mixed"], + "religious_character": [None], + "admissions_policy": ["Comprehensive"], + "nursery_provision": ["No"], + "sixth_form": ["No"], + "capacity": [200], + "pupils": [180], + "fsm_percent": [12.5], + "trust": [None], + "address": ["1 Test Street"], + "postcode": ["E1 1AA"], + "local_authority": ["Test LA"], + "website": [None], + "telephone": ["02012345678"], + "head_name": ["Jane Doe"], + "lat": [51.53], + "lng": [-0.12], + } + ).write_parquet(gias_path) + + ofsted_path = tmp_path / "ofsted.parquet" + pl.DataFrame( + { + "URN": [1001], + "Latest OEIF overall effectiveness": ["2"], + "Ungraded inspection overall outcome": [None], + } + ).write_parquet(ofsted_path) + + boundary_path = _write_boundary(tmp_path) + return { + "input_path": input_path, + "naptan_path": naptan_path, + "boundary_path": boundary_path, + "grocery_retail_points_path": grocery_path, + "gias_path": gias_path, + "ofsted_path": ofsted_path, + } + + def test_transform_grocery_retail_points_outputs_chain_categories(): raw = pl.DataFrame( { @@ -292,3 +395,79 @@ def test_school_icon_category_handles_one_sided_age_ranges(): "Primary school", "School", ] + + +def test_transform_dedupes_multi_tag_pois(tmp_path): + # One OSM object can carry several tag keys that map to the SAME friendly + # category, so pois.py emits one raw row per key with the SAME id. + # "amenity/pharmacy" and "shop/chemist" both map to "Pharmacy". + raw = pl.DataFrame( + { + "id": ["n42", "n42"], + "name": ["Boots", "Boots"], + "category": ["amenity/pharmacy", "shop/chemist"], + "lat": [51.50, 51.50], + "lng": [-0.10, -0.10], + } + ) + inputs = _write_transform_inputs(tmp_path, raw) + + out = transform(**inputs).collect() + + # No (id, category) pair appears more than once. + assert out.group_by("id", "category").len()["len"].max() == 1 + # The single physical pharmacy is present exactly once. + pharmacies = out.filter( + (pl.col("id") == "n42") & (pl.col("category") == "Pharmacy") + ) + assert pharmacies.height == 1 + + +def test_osm_supermarkets_dropped(tmp_path): + # GEOLYTIX is authoritative for supermarkets; an OSM "shop/supermarket" row + # must not flow through as a second Groceries/Supermarket pin. A + # complementary grocery category (Convenience Store) must still survive. + raw = pl.DataFrame( + { + "id": ["n1", "n2"], + "name": ["Some Supermarket", "Corner Shop"], + "category": ["shop/supermarket", "shop/convenience"], + "lat": [51.50, 51.51], + "lng": [-0.10, -0.11], + } + ) + inputs = _write_transform_inputs(tmp_path, raw) + + out = transform(**inputs).collect() + + osm_supermarkets = out.filter( + (pl.col("group") == "Groceries") & (pl.col("category") == "Supermarket") + ) + assert osm_supermarkets.height == 0 + # Complementary OSM grocery category survives. + convenience = out.filter(pl.col("category") == "Convenience Store") + assert convenience.height == 1 + + +def test_transform_output_unique_per_id_category(tmp_path): + # Soundness: the full transform() output has at most one row per + # (id, category) overall, across every source. + raw = pl.DataFrame( + { + "id": ["n42", "n42", "n7", "n8"], + "name": ["Boots", "Boots", "St Mary's", "St Mary's"], + "category": [ + "amenity/pharmacy", + "shop/chemist", + "amenity/place_of_worship", + "building/church", + ], + "lat": [51.50, 51.50, 51.55, 51.55], + "lng": [-0.10, -0.10, -0.15, -0.15], + } + ) + inputs = _write_transform_inputs(tmp_path, raw) + + out = transform(**inputs).collect() + + assert out.group_by("id", "category").len()["len"].max() == 1 diff --git a/pipeline/transform/transform_poi.py b/pipeline/transform/transform_poi.py index 8109d8a..7bfa304 100644 --- a/pipeline/transform/transform_poi.py +++ b/pipeline/transform/transform_poi.py @@ -6,6 +6,10 @@ import polars as pl from pipeline.utils.england_geometry import in_england_mask DROP_CATEGORIES = { + # GEOLYTIX Grocery Retail Points is the authoritative supermarket source + # (transform_grocery_retail_points), so drop OSM supermarkets to avoid + # double-counting each store as both a GEOLYTIX brand and an OSM "Supermarket". + "shop/supermarket", # Street furniture & infrastructure "amenity/advice", "amenity/atm", @@ -364,14 +368,6 @@ _CATEGORIES: list[tuple[str, str, str, list[str]]] = [ "leisure/yes", ], ), - ( - "Groceries", - "Supermarket", - "🛒", - [ - "shop/supermarket", - ], - ), ( "Groceries", "Convenience Store", @@ -1534,6 +1530,14 @@ def transform( pl.col("category").replace_strict(emoji_mapping).alias("emoji"), ) + # A single OSM object can carry several tag keys that map to the same + # friendly category (e.g. amenity/pharmacy + shop/chemist -> "Pharmacy"), + # which pois.py emits as multiple raw rows sharing one id. Collapse those + # duplicates so they don't inflate downstream proximity counts; rows sharing + # an id with DIFFERENT categories are preserved. Other sources are + # pre-deduplicated. + lf = lf.unique(subset=["id", "category"], keep="first", maintain_order=True) + naptan_df = pl.scan_parquet(naptan_path).collect() mask = in_england_mask( boundary_path, diff --git a/pipeline/utils/__init__.py b/pipeline/utils/__init__.py index 74596c6..043291b 100644 --- a/pipeline/utils/__init__.py +++ b/pipeline/utils/__init__.py @@ -5,6 +5,7 @@ from .fuzzy_join import ( normalize_postcode_key, ) from .haversine import haversine_km, haversine_km_expr +from .nspl_schema import code_col_overrides from .poi_counts import count_pois_per_postcode from .postcode_mapping import build_postcode_mapping @@ -16,6 +17,7 @@ __all__ = [ "normalize_postcode_key", "haversine_km", "haversine_km_expr", + "code_col_overrides", "count_pois_per_postcode", "build_postcode_mapping", ] diff --git a/pipeline/utils/nspl_schema.py b/pipeline/utils/nspl_schema.py new file mode 100644 index 0000000..4e972ed --- /dev/null +++ b/pipeline/utils/nspl_schema.py @@ -0,0 +1,30 @@ +"""Suffix-agnostic schema overrides for ONS NSPL/NSUL classification columns. + +NSPL/NSUL embed the source year in classification-index column names +(e.g. ruc21ind, oac11ind, imd20ind) and ONS bumps those suffixes with each +release. These columns look numeric in early rows but contain string codes +like "UN1" (Unclassified) further down, so they must be forced to String +before scanning — otherwise polars infers Int64 and crashes mid-stream. + +Hard-coding the year suffix is fragile: polars silently ignores overrides for +columns that don't exist, so a renamed suffix would no-op and reintroduce the +crash. Match on the suffix-free stem instead. +""" + +import re + +import polars as pl + +# Matches ruc/oac/imd classification-index columns regardless of year suffix: +# ruc21ind, oac11ind, imd20ind, imd25ind, oacind, ... (case-insensitive). +CODE_COL_PATTERN = re.compile(r"^(ruc|oac|imd)\d*ind$", re.IGNORECASE) + + +def code_col_overrides(names: list[str]) -> dict[str, type[pl.String]]: + """Build a String schema-override dict for NSPL/NSUL code columns. + + Given the column names of an NSPL/NSUL CSV, return overrides forcing every + RUC/OAC/IMD classification-index column to String, independent of the year + suffix ONS happens to use this release. + """ + return {name: pl.String for name in names if CODE_COL_PATTERN.match(name)} diff --git a/pipeline/utils/test_nspl_schema.py b/pipeline/utils/test_nspl_schema.py new file mode 100644 index 0000000..40acbe8 --- /dev/null +++ b/pipeline/utils/test_nspl_schema.py @@ -0,0 +1,57 @@ +import polars as pl + +from pipeline.utils.nspl_schema import CODE_COL_PATTERN, code_col_overrides + + +def test_matches_current_and_renamed_suffixes(): + names = ["pcd", "ruc21ind", "oac11ind", "imd20ind", "lat", "long"] + overrides = code_col_overrides(names) + assert overrides == { + "ruc21ind": pl.String, + "oac11ind": pl.String, + "imd20ind": pl.String, + } + + +def test_catches_future_suffix_bump(): + # The regression: ONS bumps imd20ind -> imd25ind. A hard-coded dict would + # no-op here; the stem match must still catch it. + names = ["pcd", "ruc25ind", "oac21ind", "imd25ind"] + overrides = code_col_overrides(names) + assert set(overrides) == {"ruc25ind", "oac21ind", "imd25ind"} + assert all(dtype is pl.String for dtype in overrides.values()) + + +def test_is_case_insensitive(): + overrides = code_col_overrides(["RUC21IND", "Oac11Ind", "IMD20ind"]) + assert set(overrides) == {"RUC21IND", "Oac11Ind", "IMD20ind"} + + +def test_matches_suffixless_stem(): + assert set(code_col_overrides(["rucind", "oacind", "imdind"])) == { + "rucind", + "oacind", + "imdind", + } + + +def test_ignores_unrelated_columns(): + names = [ + "pcd", + "laua", + "imdscore", # not an *ind column + "indicator", # ends in nothing relevant, no ruc/oac/imd stem + "ruc21indx", # extra trailing char -> not a code column + "xruc21ind", # leading char -> not anchored at start + ] + assert code_col_overrides(names) == {} + + +def test_empty_names(): + assert code_col_overrides([]) == {} + + +def test_pattern_anchored(): + assert CODE_COL_PATTERN.match("imd25ind") + assert not CODE_COL_PATTERN.match("oac11indicator") + assert not CODE_COL_PATTERN.match("region_imd20ind") diff --git a/pipeline/validate_outputs.py b/pipeline/validate_outputs.py index 360b65b..8dc2d59 100644 --- a/pipeline/validate_outputs.py +++ b/pipeline/validate_outputs.py @@ -352,6 +352,50 @@ def _failures_for_active_postcode_boundary_match(spec: str) -> list[str]: return failures +def _failures_for_postcode_universe(spec: str) -> list[str]: + """Validate that a postcode-features parquet's postcode set is exactly the + active-English NSPL/ArcGIS universe. Guards against a truncated or stale + postcode.parquet (e.g. an interrupted merge that wrote only a fraction of the + ~1.49M rows, all otherwise valid) silently passing the build gate, since + `_failures_for_postcode_features` only checks per-row validity, not the count. + """ + arcgis_path, postcodes_path = _split_pair(spec, "postcode universe") + failures = _failures_for_parquet(arcgis_path) + _failures_for_parquet( + postcodes_path + ) + if failures: + return failures + + try: + active = _active_english_arcgis_postcodes(arcgis_path) + got = _parquet_postcodes(postcodes_path) + except Exception as exc: + return [ + f"{arcgis_path} / {postcodes_path}: postcode universe check failed: {exc}" + ] + + failures = [] + if len(got) != len(active): + failures.append( + f"{postcodes_path}: postcode count {len(got):,} != active-English NSPL " + f"universe {len(active):,} (from {arcgis_path})" + ) + + missing = active - got + extra = got - active + if missing: + failures.append( + f"{postcodes_path}: {len(missing):,} active English postcodes from " + f"{arcgis_path} are missing; sample: {_sample(missing)}" + ) + if extra: + failures.append( + f"{postcodes_path}: {len(extra):,} postcodes are not active English " + f"postcodes in {arcgis_path}; sample: {_sample(extra)}" + ) + return failures + + def _failures_for_postcode_features(path: Path) -> list[str]: """Validate the postcode feature output: unique Postcode, non-null lat/lon inside the England bbox, ctry25cd == E92000001, and every '% ' column in @@ -565,6 +609,15 @@ def main() -> int: "lat/lon in England, ctry25cd=E92000001, '% ' columns in [0,100]" ), ) + parser.add_argument( + "--postcode-universe", + action="append", + default=[], + help=( + "Require postcode parquet keys to equal the active-English NSPL " + "universe: ARCGIS::POSTCODES" + ), + ) parser.add_argument( "--properties-subset", action="append", @@ -599,6 +652,8 @@ def main() -> int: failures.extend(_failures_for_active_postcode_boundary_match(spec)) for path in args.postcode_features: failures.extend(_failures_for_postcode_features(path)) + for spec in args.postcode_universe: + failures.extend(_failures_for_postcode_universe(spec)) for spec in args.properties_subset: failures.extend(_failures_for_properties_subset(spec)) for path in args.price_index: From d6d20ccd37bbd83dc9e96d93b03c828fb3173ed0 Mon Sep 17 00:00:00 2001 From: Andras Schmelczer <andras@schmelczer.dev> Date: Thu, 4 Jun 2026 20:40:42 +0100 Subject: [PATCH 8/9] don't crash --- Makefile.data | 2 +- analyses/online_listings_buy.ipynb | 5829 ++++++----------- pipeline/download/median_age.py | 21 + pipeline/download/noise.py | 8 +- pipeline/download/test_median_age.py | 15 + .../transform/postcode_boundaries/geometry.py | 123 + .../postcode_boundaries/greenspace.py | 7 +- .../transform/postcode_boundaries/output.py | 97 +- .../postcode_boundaries/process_oa.py | 79 +- .../test_postcode_boundaries.py | 276 + .../transform/postcode_boundaries/voronoi.py | 9 +- pipeline/transform/test_tree_density.py | 47 + pipeline/transform/tree_density.py | 41 +- 13 files changed, 2630 insertions(+), 3924 deletions(-) create mode 100644 pipeline/transform/postcode_boundaries/geometry.py diff --git a/Makefile.data b/Makefile.data index 31a3c03..af3a1f3 100644 --- a/Makefile.data +++ b/Makefile.data @@ -115,7 +115,7 @@ MAP_ASSETS_DEPS := pipeline/download/map_assets.py pipeline/transform/transform_ transform-school-proximity transform-tree-density \ generate-postcode-boundaries generate-travel-times enrich-actual-listings -prepare: $(PRICES_STAMP) download-places tiles satellite-tiles overlay-tiles property-border-tiles generate-postcode-boundaries download-map-assets generate-travel-times | $(POSTCODES_PQ) $(PROPERTIES_PQ) $(PRICE_INDEX) +prepare: $(PRICES_STAMP) download-places tiles satellite-tiles overlay-tiles property-border-tiles tree-overlay-tiles crime-hotspot-tiles property-border-tiles generate-postcode-boundaries download-map-assets generate-travel-times | $(POSTCODES_PQ) $(PROPERTIES_PQ) $(PRICE_INDEX) $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) --parquet $(PRICE_INDEX) --postcode-boundary-match "$(POSTCODES_PQ)::$(PC_BOUNDARIES)" --postcode-features $(POSTCODES_PQ) --postcode-universe "$(ARCGIS)::$(POSTCODES_PQ)" --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" --price-index $(PRICE_INDEX) merge: $(MERGE_STAMP) | $(POSTCODES_PQ) $(PROPERTIES_PQ) $(VALIDATE_OUTPUTS) --parquet $(POSTCODES_PQ) --parquet $(PROPERTIES_PQ) --postcode-features $(POSTCODES_PQ) --postcode-universe "$(ARCGIS)::$(POSTCODES_PQ)" --properties-subset "$(PROPERTIES_PQ)::$(POSTCODES_PQ)" diff --git a/analyses/online_listings_buy.ipynb b/analyses/online_listings_buy.ipynb index 6f461c2..44dba93 100644 --- a/analyses/online_listings_buy.ipynb +++ b/analyses/online_listings_buy.ipynb @@ -2,68 +2,99 @@ "cells": [ { "cell_type": "markdown", - "id": "55bc43ad", + "id": "21f27a93", "metadata": {}, "source": [ - "# Online Buy Listings\n", + "# Online Buy Listings — data quality & cleanup\n", "\n", - "Analysis of `finder/data/online_listings_buy.parquet`." + "Source: `finder/data/online_listings_buy.parquet` — ~112k UK *for-sale* property listings\n", + "(Greater London) scraped from **Rightmove**, **OnTheMarket** and **Zoopla** and merged by the\n", + "`finder` pipeline (`transform.py` / `onthemarket.py` / `zoopla.py` → `storage.py`).\n", + "\n", + "This notebook:\n", + "1. **Profiles** the raw data (shape, schema, missingness by provider).\n", + "2. **Demonstrates each data-quality issue** found in the audit, with the query that proves it.\n", + "3. **Cleans** the data (cell block in §4), adding provenance/flag columns rather than silently dropping where possible.\n", + "4. **Re-shows the stats** so the fixes are visible (§5), incl. a before/after summary table.\n", + "\n", + "Every count below is computed live from the file." ] }, { "cell_type": "code", "execution_count": 1, - "id": "1560f01a", + "id": "075fbea3", "metadata": { "execution": { - "iopub.execute_input": "2026-05-17T10:23:47.594553Z", - "iopub.status.busy": "2026-05-17T10:23:47.594488Z", - "iopub.status.idle": "2026-05-17T10:23:47.858517Z", - "shell.execute_reply": "2026-05-17T10:23:47.858194Z" + "iopub.execute_input": "2026-06-03T07:34:30.479194Z", + "iopub.status.busy": "2026-06-03T07:34:30.479121Z", + "iopub.status.idle": "2026-06-03T07:34:30.900789Z", + "shell.execute_reply": "2026-06-03T07:34:30.900538Z" } }, - "outputs": [], + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'matplotlib'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m pathlib \u001b[38;5;28;01mimport\u001b[39;00m Path\n\u001b[32m 2\u001b[39m \n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m matplotlib.pyplot \u001b[38;5;28;01mas\u001b[39;00m plt\n\u001b[32m 4\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m numpy \u001b[38;5;28;01mas\u001b[39;00m np\n\u001b[32m 5\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m polars \u001b[38;5;28;01mas\u001b[39;00m pl\n\u001b[32m 6\u001b[39m \n", + "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'matplotlib'" + ] + } + ], "source": [ "from pathlib import Path\n", "\n", - "import plotly.express as px\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", "import polars as pl\n", "\n", - "pl.Config.set_tbl_rows(45)\n", - "pl.Config.set_fmt_str_lengths(80)\n", + "%matplotlib inline\n", + "plt.rcParams[\"figure.dpi\"] = 110\n", + "pl.Config.set_tbl_rows(40)\n", + "pl.Config.set_fmt_str_lengths(90)\n", + "pl.Config.set_tbl_cols(30)\n", "\n", - "DATA_PATH = Path(\"/volumes/projects/perfect-postcode/finder/data/test/online_listings_buy.parquet\")" + "DATA_PATH = Path(\"/volumes/projects/perfect-postcode/finder/data/online_listings_buy.parquet\")\n", + "\n", + "# Provider derived from the listing URL domain (mirrors the existing analysis convention).\n", + "PROVIDER = (\n", + " pl.when(pl.col(\"Listing URL\").str.contains(\"rightmove.co.uk\", literal=True)).then(pl.lit(\"Rightmove\"))\n", + " .when(pl.col(\"Listing URL\").str.contains(\"onthemarket.com\", literal=True)).then(pl.lit(\"OnTheMarket\"))\n", + " .when(pl.col(\"Listing URL\").str.contains(\"zoopla.co.uk\", literal=True)).then(pl.lit(\"Zoopla\"))\n", + " .otherwise(pl.lit(\"Unknown\"))\n", + " .alias(\"provider\")\n", + ")\n", + "\n", + "raw = pl.read_parquet(DATA_PATH).with_columns(PROVIDER)\n", + "print(f\"Rows: {raw.height:,} Columns: {len(raw.columns)}\")\n", + "raw.group_by(\"provider\").len().sort(\"len\", descending=True)" ] }, { "cell_type": "markdown", - "id": "6c5d1f0a", + "id": "8d632ad4", "metadata": {}, "source": [ - "## Load" + "## 1 · Overview" ] }, { "cell_type": "code", - "execution_count": 2, - "id": "09a54208", + "execution_count": null, + "id": "692830dd", "metadata": { "execution": { - "iopub.execute_input": "2026-05-17T10:23:47.859716Z", - "iopub.status.busy": "2026-05-17T10:23:47.859600Z", - "iopub.status.idle": "2026-05-17T10:23:47.955592Z", - "shell.execute_reply": "2026-05-17T10:23:47.955345Z" + "iopub.execute_input": "2026-06-03T07:34:30.901690Z", + "iopub.status.busy": "2026-06-03T07:34:30.901608Z", + "iopub.status.idle": "2026-06-03T07:34:30.903798Z", + "shell.execute_reply": "2026-06-03T07:34:30.903603Z" } }, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Rows: 242\n", - "Columns: 25\n" - ] - }, { "data": { "text/html": [ @@ -74,183 +105,63 @@ " white-space: pre-wrap;\n", "}\n", "</style>\n", - "<small>shape: (3, 2)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>provider</th><th>len</th></tr><tr><td>str</td><td>u32</td></tr></thead><tbody><tr><td>"OnTheMarket"</td><td>85</td></tr><tr><td>"Rightmove"</td><td>99</td></tr><tr><td>"Zoopla"</td><td>58</td></tr></tbody></table></div>" + "<small>shape: (25, 2)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>column</th><th>dtype</th></tr><tr><td>str</td><td>str</td></tr></thead><tbody><tr><td>"Bedrooms"</td><td>"Int32"</td></tr><tr><td>"Bathrooms"</td><td>"Int32"</td></tr><tr><td>"Number of bedrooms & living rooms"</td><td>"Int32"</td></tr><tr><td>"lon"</td><td>"Float64"</td></tr><tr><td>"lat"</td><td>"Float64"</td></tr><tr><td>"Postcode"</td><td>"String"</td></tr><tr><td>"Postcode source"</td><td>"String"</td></tr><tr><td>"Extracted postcode"</td><td>"String"</td></tr><tr><td>"Inferred postcode"</td><td>"String"</td></tr><tr><td>"Listing raw address"</td><td>"String"</td></tr><tr><td>"Address per Property Register"</td><td>"String"</td></tr><tr><td>"UPRN"</td><td>"String"</td></tr><tr><td>"Property number or name"</td><td>"String"</td></tr><tr><td>"Leasehold/Freehold"</td><td>"String"</td></tr><tr><td>"Property type"</td><td>"String"</td></tr><tr><td>"Property sub-type"</td><td>"String"</td></tr><tr><td>"Price qualifier"</td><td>"String"</td></tr><tr><td>"Total floor area (sqm)"</td><td>"Float64"</td></tr><tr><td>"Listing URL"</td><td>"String"</td></tr><tr><td>"Listing features"</td><td>"List(String)"</td></tr><tr><td>"Listing date"</td><td>"Datetime(time_unit='us', time_zone=None)"</td></tr><tr><td>"Listing status"</td><td>"String"</td></tr><tr><td>"Asking price"</td><td>"Int64"</td></tr><tr><td>"Asking price per sqm"</td><td>"Int32"</td></tr><tr><td>"provider"</td><td>"String"</td></tr></tbody></table></div>" ], "text/plain": [ - "shape: (3, 2)\n", - "┌─────────────┬─────┐\n", - "│ provider ┆ len │\n", - "│ --- ┆ --- │\n", - "│ str ┆ u32 │\n", - "╞═════════════╪═════╡\n", - "│ OnTheMarket ┆ 85 │\n", - "│ Rightmove ┆ 99 │\n", - "│ Zoopla ┆ 58 │\n", - "└─────────────┴─────┘" + "shape: (25, 2)\n", + "┌───────────────────────────────────┬──────────────────────────────────────────┐\n", + "│ column ┆ dtype │\n", + "│ --- ┆ --- │\n", + "│ str ┆ str │\n", + "╞═══════════════════════════════════╪══════════════════════════════════════════╡\n", + "│ Bedrooms ┆ Int32 │\n", + "│ Bathrooms ┆ Int32 │\n", + "│ Number of bedrooms & living rooms ┆ Int32 │\n", + "│ lon ┆ Float64 │\n", + "│ lat ┆ Float64 │\n", + "│ Postcode ┆ String │\n", + "│ Postcode source ┆ String │\n", + "│ Extracted postcode ┆ String │\n", + "│ Inferred postcode ┆ String │\n", + "│ Listing raw address ┆ String │\n", + "│ Address per Property Register ┆ String │\n", + "│ UPRN ┆ String │\n", + "│ Property number or name ┆ String │\n", + "│ Leasehold/Freehold ┆ String │\n", + "│ Property type ┆ String │\n", + "│ Property sub-type ┆ String │\n", + "│ Price qualifier ┆ String │\n", + "│ Total floor area (sqm) ┆ Float64 │\n", + "│ Listing URL ┆ String │\n", + "│ Listing features ┆ List(String) │\n", + "│ Listing date ┆ Datetime(time_unit='us', time_zone=None) │\n", + "│ Listing status ┆ String │\n", + "│ Asking price ┆ Int64 │\n", + "│ Asking price per sqm ┆ Int32 │\n", + "│ provider ┆ String │\n", + "└───────────────────────────────────┴──────────────────────────────────────────┘" ] }, + "execution_count": 2, "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<div><style>\n", - ".dataframe > thead > tr,\n", - ".dataframe > tbody > tr {\n", - " text-align: right;\n", - " white-space: pre-wrap;\n", - "}\n", - "</style>\n", - "<small>shape: (45, 25)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>provider</th><th>Bedrooms</th><th>Bathrooms</th><th>Number of bedrooms & living rooms</th><th>lon</th><th>lat</th><th>Postcode</th><th>Postcode source</th><th>Extracted postcode</th><th>Inferred postcode</th><th>Listing raw address</th><th>Address per Property Register</th><th>UPRN</th><th>Property number or name</th><th>Leasehold/Freehold</th><th>Property type</th><th>Property sub-type</th><th>Price qualifier</th><th>Total floor area (sqm)</th><th>Listing URL</th><th>Listing features</th><th>Listing date</th><th>Listing status</th><th>Asking price</th><th>Asking price per sqm</th></tr><tr><td>str</td><td>i32</td><td>i32</td><td>i32</td><td>f64</td><td>f64</td><td>str</td><td>str</td><td>str</td><td>str</td><td>str</td><td>str</td><td>str</td><td>str</td><td>str</td><td>str</td><td>str</td><td>str</td><td>f64</td><td>str</td><td>list[str]</td><td>datetime[μs]</td><td>str</td><td>i64</td><td>i32</td></tr></thead><tbody><tr><td>"OnTheMarket"</td><td>1</td><td>1</td><td>2</td><td>-0.129102</td><td>51.463636</td><td>"SW4 7EF"</td><td>"coordinates"</td><td>null</td><td>"SW4 7EF"</td><td>"Bedford Road, London"</td><td>"Bedford Road, London"</td><td>null</td><td>null</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Apartment"</td><td>""</td><td>null</td><td>"https://www.onthemarket.com/details/19209711/"</td><td>["Tenure: Leasehold (111 years remaining)", "Top floor one-bedroom apartment within a modern development completed in 2021", … "Generous double bedroom, contemporary bathroom and separate utility/storage room"]</td><td>null</td><td>"For sale"</td><td>525000</td><td>null</td></tr><tr><td>"OnTheMarket"</td><td>1</td><td>1</td><td>2</td><td>-0.100233</td><td>51.466129</td><td>"SE5 9AA"</td><td>"coordinates"</td><td>null</td><td>"SE5 9AA"</td><td>"Padfield Road, London, SE5"</td><td>"Padfield Road, London"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>null</td><td>"https://www.onthemarket.com/details/19522441/"</td><td>["Tenure: Share of freehold (999 years remaining)", "One Bedroom"]</td><td>null</td><td>"For sale"</td><td>275000</td><td>null</td></tr><tr><td>"OnTheMarket"</td><td>4</td><td>1</td><td>5</td><td>-0.108913</td><td>51.471775</td><td>"SW9 6NN"</td><td>"coordinates"</td><td>null</td><td>"SW9 6NN"</td><td>"Lord Holland Lane, Myatts Fields South, London"</td><td>"Lord Holland Lane, Myatts Fields South, London"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Terraced"</td><td>"Terraced House"</td><td>"Offers in excess of"</td><td>null</td><td>"https://www.onthemarket.com/details/18847208/"</td><td>["Tenure: Freehold", "Four Bedrooms", … "Superb Condition"]</td><td>null</td><td>"For sale"</td><td>600000</td><td>null</td></tr><tr><td>"OnTheMarket"</td><td>1</td><td>1</td><td>2</td><td>-0.107904</td><td>51.473026</td><td>"SW9 6BF"</td><td>"coordinates"</td><td>null</td><td>"SW9 6BF"</td><td>"Mostyn Road, London SW9"</td><td>"Mostyn Road, London"</td><td>null</td><td>null</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>null</td><td>"https://www.onthemarket.com/details/19305103/"</td><td>["Tenure: Leasehold", "One bedroom"]</td><td>null</td><td>"For sale"</td><td>350000</td><td>null</td></tr><tr><td>"OnTheMarket"</td><td>1</td><td>1</td><td>2</td><td>-0.115372</td><td>51.475374</td><td>"SW9 0RG"</td><td>"coordinates"</td><td>null</td><td>"SW9 0RG"</td><td>"Hackford Road, London SW9"</td><td>"Hackford Road, London"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>null</td><td>"https://www.onthemarket.com/details/19601952/"</td><td>["Tenure: Share of freehold", "Separate dining and living room", … "Study"]</td><td>null</td><td>"For sale"</td><td>475000</td><td>null</td></tr><tr><td>"OnTheMarket"</td><td>0</td><td>1</td><td>1</td><td>-0.117911</td><td>51.476212</td><td>"SW9 0HP"</td><td>"coordinates"</td><td>null</td><td>"SW9 0HP"</td><td>"Clapham Road, London SW9"</td><td>"Clapham Road, London"</td><td>null</td><td>null</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>null</td><td>"https://www.onthemarket.com/details/19601638/"</td><td>["Tenure: Leasehold", "Nearest station 0.3mi."]</td><td>null</td><td>"For sale"</td><td>225000</td><td>null</td></tr><tr><td>"OnTheMarket"</td><td>2</td><td>2</td><td>4</td><td>-0.105579</td><td>51.463969</td><td>"SW9 8SE"</td><td>"coordinates"</td><td>null</td><td>"SW9 8SE"</td><td>"Coldharbour Lane, Brixton, London, SW9"</td><td>"Coldharbour Lane, Brixton, London"</td><td>null</td><td>null</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>null</td><td>"https://www.onthemarket.com/details/19601141/"</td><td>["Tenure: Leasehold", "Fantastic two bedroom period flat"]</td><td>null</td><td>"For sale"</td><td>575000</td><td>null</td></tr><tr><td>"OnTheMarket"</td><td>1</td><td>1</td><td>2</td><td>-0.116437</td><td>51.466426</td><td>"SW9 9FX"</td><td>"coordinates"</td><td>null</td><td>"SW9 9FX"</td><td>"Stockwell Road, SW9"</td><td>"Stockwell Road"</td><td>null</td><td>null</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>null</td><td>"https://www.onthemarket.com/details/19599310/"</td><td>["Tenure: Leasehold (120 years remaining)", "One double bedroom", "Chain-free"]</td><td>null</td><td>"For sale"</td><td>435000</td><td>null</td></tr><tr><td>"OnTheMarket"</td><td>2</td><td>2</td><td>4</td><td>-0.102355</td><td>51.46566</td><td>"SW9 8RU"</td><td>"coordinates"</td><td>null</td><td>"SW9 8RU"</td><td>"Coldharbour Lane, SW9"</td><td>"Coldharbour Lane"</td><td>null</td><td>null</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>"Offers over"</td><td>null</td><td>"https://www.onthemarket.com/details/19599313/"</td><td>["Tenure: Leasehold (127 years remaining)", "Two double bedrooms", "Chain-free"]</td><td>null</td><td>"For sale"</td><td>450000</td><td>null</td></tr><tr><td>"OnTheMarket"</td><td>2</td><td>2</td><td>4</td><td>-0.114496</td><td>51.466421</td><td>"SW9 0FH"</td><td>"coordinates"</td><td>null</td><td>"SW9 0FH"</td><td>"Stockwell Park Walk, London, SW9"</td><td>"Stockwell Park Walk, London"</td><td>null</td><td>null</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>"Offers in excess of"</td><td>null</td><td>"https://www.onthemarket.com/details/18060975/"</td><td>["Tenure: Leasehold (113 years remaining)", "Stylish and well-presented two-bedroom, two-bathroom apartment", "Study"]</td><td>null</td><td>"For sale"</td><td>500000</td><td>null</td></tr><tr><td>"OnTheMarket"</td><td>2</td><td>2</td><td>4</td><td>-0.126918</td><td>51.469851</td><td>"SW4 6BF"</td><td>"coordinates"</td><td>null</td><td>"SW4 6BF"</td><td>"20 Fergusson Mews, London, SW4"</td><td>"20 Fergusson Mews, London"</td><td>null</td><td>null</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>"Offers in excess of"</td><td>null</td><td>"https://www.onthemarket.com/details/19266851/"</td><td>["Tenure: Leasehold", "Gated Development", … "Chain-free"]</td><td>null</td><td>"For sale"</td><td>650000</td><td>null</td></tr><tr><td>"OnTheMarket"</td><td>1</td><td>1</td><td>2</td><td>-0.116535</td><td>51.466385</td><td>"SW9 9FX"</td><td>"coordinates"</td><td>null</td><td>"SW9 9FX"</td><td>"Stockwell Road, Stockwell, London, SW9"</td><td>"Stockwell Road, Stockwell, London"</td><td>null</td><td>null</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>"Offers in excess of"</td><td>null</td><td>"https://www.onthemarket.com/details/19167472/"</td><td>["Tenure: Leasehold (125 years remaining)", "Stylish finish", … "Chain-free"]</td><td>null</td><td>"For sale"</td><td>450000</td><td>null</td></tr><tr><td>"OnTheMarket"</td><td>1</td><td>1</td><td>2</td><td>-0.1109</td><td>51.462364</td><td>"SW9 8GA"</td><td>"coordinates"</td><td>null</td><td>"SW9 8GA"</td><td>"Milles Square, Brixton, London, SW9"</td><td>"Milles Square, Brixton, London"</td><td>null</td><td>null</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>null</td><td>"https://www.onthemarket.com/details/19592532/"</td><td>["Tenure: Leasehold (155 years remaining)", "Neatly presented 1 bedroom flat in a convenient location"]</td><td>null</td><td>"For sale"</td><td>340000</td><td>null</td></tr><tr><td>"OnTheMarket"</td><td>2</td><td>1</td><td>3</td><td>-0.110269</td><td>51.46006</td><td>"SE24 0LW"</td><td>"coordinates"</td><td>null</td><td>"SE24 0LW"</td><td>"Railton Road, London SE24"</td><td>"Railton Road, London"</td><td>null</td><td>null</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>null</td><td>"https://www.onthemarket.com/details/19591254/"</td><td>["Tenure: Leasehold", "Two Double Bedrooms", "Chain-free"]</td><td>null</td><td>"For sale"</td><td>500000</td><td>null</td></tr><tr><td>"OnTheMarket"</td><td>1</td><td>1</td><td>2</td><td>-0.126297</td><td>51.466742</td><td>"SW9 9LE"</td><td>"coordinates"</td><td>null</td><td>"SW9 9LE"</td><td>"Hemberton Road, London SW9"</td><td>"Hemberton Road, London"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>null</td><td>"https://www.onthemarket.com/details/19591126/"</td><td>["Tenure: Share of freehold", "Chain Free", … "Study"]</td><td>null</td><td>"For sale"</td><td>550000</td><td>null</td></tr><tr><td>"Rightmove"</td><td>1</td><td>1</td><td>2</td><td>-0.121569</td><td>51.471079</td><td>"SW9 9EU"</td><td>"coordinates"</td><td>null</td><td>"SW9 9EU"</td><td>"Stockwell Road, London, SW9"</td><td>"Stockwell Road, London"</td><td>null</td><td>null</td><td>null</td><td>"Flats/Maisonettes"</td><td>"Apartment"</td><td>"Guide Price"</td><td>null</td><td>"https://www.rightmove.co.uk/properties/89076063#/?channel=RES_BUY"</td><td>["Within easy reach of local amenities, green spaces and transport connections", "Excellent value-add opportunity for owner-occupiers and investors", … "Well-proportioned one-bedroom apartment in a popular SW9 location"]</td><td>2026-05-29 14:30:37</td><td>"For sale"</td><td>310000</td><td>null</td></tr><tr><td>"Rightmove"</td><td>5</td><td>4</td><td>9</td><td>-0.11817</td><td>51.47115</td><td>"SW9 0DG"</td><td>"coordinates"</td><td>null</td><td>"SW9 0DG"</td><td>"Stockwell Park Crescent II, London SW9"</td><td>"Stockwell Park Crescent II, London"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Semi-Detached"</td><td>"Semi-Detached"</td><td>""</td><td>310.6</td><td>"https://www.rightmove.co.uk/properties/174610352#/?channel=RES_BUY"</td><td>[]</td><td>2026-04-17 18:34:21</td><td>"For sale"</td><td>2595000</td><td>8355</td></tr><tr><td>"Rightmove"</td><td>6</td><td>3</td><td>9</td><td>-0.114727</td><td>51.473247</td><td>"SW9 0AR"</td><td>"coordinates"</td><td>null</td><td>"SW9 0AR"</td><td>"Groveway, Stockwell"</td><td>"Groveway, Stockwell"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Detached"</td><td>"Detached"</td><td>""</td><td>null</td><td>"https://www.rightmove.co.uk/properties/174282005#/?channel=RES_BUY"</td><td>["Early Victorian Family Home", "Grade II Listed", … "Wonderful Potential"]</td><td>2026-04-10 11:17:35</td><td>"For sale"</td><td>2295000</td><td>null</td></tr><tr><td>"Rightmove"</td><td>4</td><td>2</td><td>6</td><td>-0.116603</td><td>51.472141</td><td>"SW9 0DD"</td><td>"coordinates"</td><td>null</td><td>"SW9 0DD"</td><td>"Stockwell Park Road, London, SW9"</td><td>"Stockwell Park Road, London"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Semi-Detached"</td><td>"Semi-Detached"</td><td>""</td><td>216.1</td><td>"https://www.rightmove.co.uk/properties/170781485#/?channel=RES_BUY"</td><td>["4 bedrooms", "2 reception rooms", … "Semi-Detached"]</td><td>2026-01-02 17:30:39</td><td>"For sale"</td><td>2250000</td><td>10412</td></tr><tr><td>"Rightmove"</td><td>2</td><td>2</td><td>4</td><td>-0.11247</td><td>51.46428</td><td>"SW9 7QH"</td><td>"coordinates"</td><td>null</td><td>"SW9 7QH"</td><td>"St Johns Buildings, London SW9"</td><td>"St Johns Buildings, London"</td><td>null</td><td>null</td><td>null</td><td>"Terraced"</td><td>"Terraced"</td><td>""</td><td>213.4</td><td>"https://www.rightmove.co.uk/properties/174206714#/?channel=RES_BUY"</td><td>[]</td><td>2026-04-08 17:23:59</td><td>"For sale"</td><td>2100000</td><td>9841</td></tr><tr><td>"Rightmove"</td><td>4</td><td>3</td><td>7</td><td>-0.116765</td><td>51.47089</td><td>"SW9 0DB"</td><td>"coordinates"</td><td>null</td><td>"SW9 0DB"</td><td>"Stockwell Park Road, London SW9"</td><td>"Stockwell Park Road, London"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Terraced"</td><td>"Terraced"</td><td>"Guide Price"</td><td>197.5</td><td>"https://www.rightmove.co.uk/properties/88435821#/?channel=RES_BUY"</td><td>["4 bedrooms", "2 reception rooms", … "Garden"]</td><td>2026-05-13 16:21:42</td><td>"For sale"</td><td>2100000</td><td>10633</td></tr><tr><td>"Rightmove"</td><td>5</td><td>3</td><td>8</td><td>-0.113111</td><td>51.478768</td><td>"SW9 0LJ"</td><td>"coordinates"</td><td>null</td><td>"SW9 0LJ"</td><td>"Crewdson Road, London SW9"</td><td>"Crewdson Road, London"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Terraced"</td><td>"Terraced"</td><td>""</td><td>246.7</td><td>"https://www.rightmove.co.uk/properties/174798002#/?channel=RES_BUY"</td><td>["5 bedrooms", "1 reception room", … "Garden"]</td><td>2026-04-22 16:04:47</td><td>"For sale"</td><td>1900000</td><td>7702</td></tr><tr><td>"Rightmove"</td><td>3</td><td>3</td><td>6</td><td>-0.11805</td><td>51.47091</td><td>"SW9 0DG"</td><td>"coordinates"</td><td>null</td><td>"SW9 0DG"</td><td>"Stockwell Park Crescent, Stockwell, London, SW9"</td><td>"Stockwell Park Crescent, Stockwell, London"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Detached"</td><td>"House"</td><td>""</td><td>156.8</td><td>"https://www.rightmove.co.uk/properties/88376967#/?channel=RES_BUY"</td><td>["Wonderful 2-bedroom semi-detached house situated over 3 floors", "Spacious kitchen", … "Well located for the local shops and amenities of Clapham and Stockwell Road"]</td><td>2026-05-12 16:14:48</td><td>"For sale"</td><td>1695000</td><td>10810</td></tr><tr><td>"Rightmove"</td><td>5</td><td>3</td><td>8</td><td>-0.119192</td><td>51.474381</td><td>"SW9 0RU"</td><td>"coordinates"</td><td>null</td><td>"SW9 0RU"</td><td>"Stockwell Park Road, London, SW9"</td><td>"Stockwell Park Road, London"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Semi-Detached"</td><td>"Semi-Detached"</td><td>""</td><td>193.2</td><td>"https://www.rightmove.co.uk/properties/167893637#/?channel=RES_BUY"</td><td>[]</td><td>2025-10-07 09:57:34</td><td>"For sale"</td><td>1695000</td><td>8773</td></tr><tr><td>"Rightmove"</td><td>2</td><td>2</td><td>4</td><td>-0.11778</td><td>51.470774</td><td>"SW9 0DG"</td><td>"coordinates"</td><td>null</td><td>"SW9 0DG"</td><td>"Stockwell Park Crescent, Stockwell"</td><td>"Stockwell Park Crescent, Stockwell"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Semi-Detached"</td><td>"Semi-Detached"</td><td>""</td><td>null</td><td>"https://www.rightmove.co.uk/properties/173668991#/?channel=RES_BUY"</td><td>["Georgian Home", "Excellent Condition", … "No Onward Chain"]</td><td>2026-03-25 09:55:49</td><td>"For sale"</td><td>1695000</td><td>null</td></tr><tr><td>"Rightmove"</td><td>4</td><td>3</td><td>7</td><td>-0.121041</td><td>51.465546</td><td>"SW9 9RF"</td><td>"coordinates"</td><td>null</td><td>"SW9 9RF"</td><td>"Hargwyne Street, London, SW9"</td><td>"Hargwyne Street, London"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Terraced"</td><td>"Terraced"</td><td>""</td><td>165.7</td><td>"https://www.rightmove.co.uk/properties/174050450#/?channel=RES_BUY"</td><td>[]</td><td>2026-04-02 16:51:56</td><td>"For sale"</td><td>1650000</td><td>9958</td></tr><tr><td>"Rightmove"</td><td>5</td><td>2</td><td>7</td><td>-0.119194</td><td>51.470986</td><td>"SW9 0SW"</td><td>"coordinates"</td><td>null</td><td>"SW9 0SW"</td><td>"Burnley Road, London, SW9"</td><td>"Burnley Road, London"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Terraced"</td><td>"Terraced"</td><td>"Guide Price"</td><td>199.5</td><td>"https://www.rightmove.co.uk/properties/88367181#/?channel=RES_BUY"</td><td>["Quiet Residential Street", "Versatile Accommodation", … "Period Features"]</td><td>2026-05-12 14:23:19</td><td>"For sale"</td><td>1595000</td><td>7995</td></tr><tr><td>"Rightmove"</td><td>5</td><td>3</td><td>8</td><td>-0.118914</td><td>51.475262</td><td>"SW9 0QQ"</td><td>"coordinates"</td><td>null</td><td>"SW9 0QQ"</td><td>"Clapham Road, Stockwell"</td><td>"Clapham Road, Stockwell"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Terraced"</td><td>"Terraced"</td><td>""</td><td>null</td><td>"https://www.rightmove.co.uk/properties/172178081#/?channel=RES_BUY"</td><td>["Georgian Townhouse", "Five Double Bedrooms", … "2617sq.ft"]</td><td>2026-02-13 14:31:16</td><td>"For sale"</td><td>1550000</td><td>null</td></tr><tr><td>"Rightmove"</td><td>8</td><td>1</td><td>9</td><td>-0.114329</td><td>51.465359</td><td>"SW9 7AW"</td><td>"coordinates"</td><td>null</td><td>"SW9 7AW"</td><td>"Brixton Road, Brixton High Street"</td><td>"Brixton Road, Brixton High Street"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Terraced"</td><td>"Terraced"</td><td>"Guide Price"</td><td>44.0</td><td>"https://www.rightmove.co.uk/properties/88139847#/?channel=RES_BUY"</td><td>["FREEHOLD MIXED USE COMMERCIAL & RESIDENTIAL", "GROUND FLOOR TAKE-AWAY - LEASE EXPIRING 2030", … "NEAR BRIXTON UNDERGROUND & OVERGROUND STATIONS"]</td><td>2026-05-06 17:31:38</td><td>"For sale"</td><td>1550000</td><td>35227</td></tr><tr><td>"Rightmove"</td><td>4</td><td>2</td><td>6</td><td>-0.118903</td><td>51.461726</td><td>"SW9 8DR"</td><td>"coordinates"</td><td>null</td><td>"SW9 8DR"</td><td>"Trinity Gardens, LONDON"</td><td>"Trinity Gardens, LONDON"</td><td>null</td><td>null</td><td>"Freehold"</td><td>"Terraced"</td><td>"Terraced"</td><td>"Guide Price"</td><td>114.5</td><td>"https://www.rightmove.co.uk/properties/174274454#/?channel=RES_BUY"</td><td>["Victorian House", "Mid Terraced", … "Central Location"]</td><td>2026-04-10 09:39:04</td><td>"For sale"</td><td>1500000</td><td>13100</td></tr><tr><td>"Zoopla"</td><td>4</td><td>2</td><td>6</td><td>-0.116819</td><td>51.477238</td><td>"SW9 0HD"</td><td>"detail_address"</td><td>null</td><td>"SW9 0HU"</td><td>"Caldwell Street, Stockwell SW9"</td><td>"1, Caldwell Street, Stockwell"</td><td>"100021818679"</td><td>"1"</td><td>"Freehold"</td><td>"Other"</td><td>"Property"</td><td>""</td><td>114.0</td><td>"https://www.zoopla.co.uk/for-sale/details/73326946/"</td><td>[]</td><td>null</td><td>"For sale"</td><td>995000</td><td>8728</td></tr><tr><td>"Zoopla"</td><td>2</td><td>1</td><td>3</td><td>-0.118798</td><td>51.468221</td><td>"SW9 0TZ"</td><td>"detail_address"</td><td>null</td><td>"SW9 9PU"</td><td>"Stockwell Road, Stockwell, London SW9"</td><td>"Flat 27, Addington House,, Stockwell Road, Stockwell, London"</td><td>"100021894599"</td><td>"Flat 27, Addington House,"</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>77.9</td><td>"https://www.zoopla.co.uk/for-sale/details/72554891/"</td><td>[]</td><td>null</td><td>"For sale"</td><td>350000</td><td>4493</td></tr><tr><td>"Zoopla"</td><td>5</td><td>3</td><td>8</td><td>-0.119192</td><td>51.474381</td><td>"SW9 0AP"</td><td>"detail_address"</td><td>null</td><td>"SW9 0RU"</td><td>"Stockwell Park Road, London SW9"</td><td>"1, Stockwell Park Road, London"</td><td>"100023386020"</td><td>"1"</td><td>"Freehold"</td><td>"Semi-Detached"</td><td>"Semi Detached"</td><td>""</td><td>194.9</td><td>"https://www.zoopla.co.uk/for-sale/details/69392186/"</td><td>[]</td><td>null</td><td>"For sale"</td><td>1695000</td><td>8697</td></tr><tr><td>"Zoopla"</td><td>3</td><td>2</td><td>5</td><td>-0.122658</td><td>51.469424</td><td>"SW9 9HG"</td><td>"detail_address"</td><td>null</td><td>"SW9 9HE"</td><td>"Lingham Street, Stockwell, London SW9"</td><td>"Flat 11 Beale House, 45, Lingham Street, Stockwell, London"</td><td>"100021894650"</td><td>"Flat 11 Beale House, 45"</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>102.9</td><td>"https://www.zoopla.co.uk/for-sale/details/73306789/"</td><td>[]</td><td>null</td><td>"For sale"</td><td>525000</td><td>5102</td></tr><tr><td>"Zoopla"</td><td>2</td><td>2</td><td>4</td><td>-0.129002</td><td>51.46795</td><td>"SW9 9AN"</td><td>"detail_address"</td><td>null</td><td>"SW9 9AN"</td><td>"Houghton Square, London SW9"</td><td>"17, Houghton Square, London"</td><td>"10008788775"</td><td>"17"</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>72.0</td><td>"https://www.zoopla.co.uk/for-sale/details/73302918/"</td><td>[]</td><td>null</td><td>"For sale"</td><td>500000</td><td>6944</td></tr><tr><td>"Zoopla"</td><td>2</td><td>1</td><td>3</td><td>-0.115029</td><td>51.477508</td><td>"SW9 0ET"</td><td>"detail_address"</td><td>null</td><td>"SW9 0EN"</td><td>"Cleveland House, Hackford Road, London SW9"</td><td>"Flat 4,, Cleveland House, Hackford Road, London"</td><td>"100021847214"</td><td>"Flat 4,"</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>55.0</td><td>"https://www.zoopla.co.uk/for-sale/details/73302851/"</td><td>[]</td><td>null</td><td>"For sale"</td><td>515000</td><td>9364</td></tr><tr><td>"Zoopla"</td><td>2</td><td>1</td><td>3</td><td>-0.125681</td><td>51.466593</td><td>"SW9 9LF"</td><td>"detail_address"</td><td>null</td><td>"SW9 9LF"</td><td>"Hemberton Road, Clapham North, London SW9"</td><td>"chpk0226649, Hemberton Road, Clapham North, London"</td><td>null</td><td>"chpk0226649"</td><td>null</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>49.7</td><td>"https://www.zoopla.co.uk/for-sale/details/71215394/"</td><td>[]</td><td>null</td><td>"For sale"</td><td>475000</td><td>9557</td></tr><tr><td>"Zoopla"</td><td>1</td><td>1</td><td>2</td><td>-0.117086</td><td>51.466529</td><td>"SW9 9FX"</td><td>"detail_address"</td><td>null</td><td>"SW9 9TG"</td><td>"Stockwell Road SW9"</td><td>"Flat 59, 151, Stockwell Road"</td><td>"10094957235"</td><td>"Flat 59, 151"</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>52.0</td><td>"https://www.zoopla.co.uk/for-sale/details/73250562/"</td><td>[]</td><td>null</td><td>"For sale"</td><td>465000</td><td>8942</td></tr><tr><td>"Zoopla"</td><td>2</td><td>1</td><td>3</td><td>-0.12876</td><td>51.464473</td><td>"SW9 9NW"</td><td>"detail_address"</td><td>null</td><td>"SW9 9PG"</td><td>"Fenwick Place SW9"</td><td>"First Floor Flat, 70, Fenwick Place"</td><td>null</td><td>"First Floor Flat, 70"</td><td>null</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>70.2</td><td>"https://www.zoopla.co.uk/for-sale/details/73268982/"</td><td>[]</td><td>null</td><td>"For sale"</td><td>599950</td><td>8546</td></tr><tr><td>"Zoopla"</td><td>1</td><td>1</td><td>2</td><td>-0.108771</td><td>51.470695</td><td>"SW9 7SB"</td><td>"detail_address"</td><td>null</td><td>"SW9 7JX"</td><td>"Loughborough Road SW9"</td><td>"Flat C, 58, Loughborough Road"</td><td>null</td><td>"Flat C, 58"</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>44.1</td><td>"https://www.zoopla.co.uk/for-sale/details/73268027/"</td><td>[]</td><td>null</td><td>"For sale"</td><td>375000</td><td>8503</td></tr><tr><td>"Zoopla"</td><td>2</td><td>2</td><td>4</td><td>-0.108351</td><td>51.475345</td><td>"SW9 7RH"</td><td>"detail_address"</td><td>null</td><td>"SW9 7BN"</td><td>"Eythorne Road, Oval SW9"</td><td>"Flat 7, 5, Eythorne Road, Oval"</td><td>null</td><td>"Flat 7, 5"</td><td>null</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>null</td><td>"https://www.zoopla.co.uk/for-sale/details/73266802/"</td><td>[]</td><td>null</td><td>"For sale"</td><td>575000</td><td>null</td></tr><tr><td>"Zoopla"</td><td>2</td><td>1</td><td>3</td><td>-0.12142</td><td>51.472181</td><td>"SW9 9AU"</td><td>"detail_address"</td><td>null</td><td>"SW9 9AU"</td><td>"Yates Court, Stockwell, London SW9"</td><td>"chpk3677610, Yates Court, Stockwell, London"</td><td>null</td><td>"chpk3677610"</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>72.0</td><td>"https://www.zoopla.co.uk/for-sale/details/73261921/"</td><td>[]</td><td>null</td><td>"For sale"</td><td>475000</td><td>6597</td></tr><tr><td>"Zoopla"</td><td>2</td><td>2</td><td>4</td><td>-0.10787</td><td>51.476628</td><td>"SW9 6HP"</td><td>"detail_address"</td><td>null</td><td>"SW9 6SB"</td><td>"Beam, Lambeth SW9, New home"</td><td>"Beam, Lambeth SW9, New home"</td><td>null</td><td>null</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>74.4</td><td>"https://www.zoopla.co.uk/new-homes/details/73247019/"</td><td>[]</td><td>null</td><td>"For sale"</td><td>580000</td><td>7796</td></tr><tr><td>"Zoopla"</td><td>2</td><td>2</td><td>4</td><td>-0.10787</td><td>51.476628</td><td>"SW9 6HP"</td><td>"detail_address"</td><td>null</td><td>"SW9 6SB"</td><td>"Beam, Lambeth SW9, New home"</td><td>"Beam, Lambeth SW9, New home"</td><td>null</td><td>null</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>74.4</td><td>"https://www.zoopla.co.uk/new-homes/details/73246935/"</td><td>[]</td><td>null</td><td>"For sale"</td><td>595000</td><td>7997</td></tr><tr><td>"Zoopla"</td><td>2</td><td>2</td><td>4</td><td>-0.122738</td><td>51.467418</td><td>"SW9 9FX"</td><td>"detail_address"</td><td>null</td><td>"SW9 9DG"</td><td>"Stockwell Road, Brixton SW9, New home"</td><td>"Stockwell Road, Brixton SW9, New home"</td><td>"10094957206"</td><td>null</td><td>"Leasehold"</td><td>"Flats/Maisonettes"</td><td>"Flat"</td><td>""</td><td>72.0</td><td>"https://www.zoopla.co.uk/new-homes/details/73239981/"</td><td>[]</td><td>null</td><td>"For sale"</td><td>575000</td><td>7986</td></tr></tbody></table></div>" - ], - "text/plain": [ - "shape: (45, 25)\n", - "┌───────────┬──────────┬───────────┬───────────┬───┬───────────┬───────────┬───────────┬───────────┐\n", - "│ provider ┆ Bedrooms ┆ Bathrooms ┆ Number of ┆ … ┆ Listing ┆ Listing ┆ Asking ┆ Asking │\n", - "│ --- ┆ --- ┆ --- ┆ bedrooms ┆ ┆ date ┆ status ┆ price ┆ price per │\n", - "│ str ┆ i32 ┆ i32 ┆ & living ┆ ┆ --- ┆ --- ┆ --- ┆ sqm │\n", - "│ ┆ ┆ ┆ rooms ┆ ┆ datetime[ ┆ str ┆ i64 ┆ --- │\n", - "│ ┆ ┆ ┆ --- ┆ ┆ μs] ┆ ┆ ┆ i32 │\n", - "│ ┆ ┆ ┆ i32 ┆ ┆ ┆ ┆ ┆ │\n", - "╞═══════════╪══════════╪═══════════╪═══════════╪═══╪═══════════╪═══════════╪═══════════╪═══════════╡\n", - "│ OnTheMark ┆ 1 ┆ 1 ┆ 2 ┆ … ┆ null ┆ For sale ┆ 525000 ┆ null │\n", - "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", - "│ OnTheMark ┆ 1 ┆ 1 ┆ 2 ┆ … ┆ null ┆ For sale ┆ 275000 ┆ null │\n", - "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", - "│ OnTheMark ┆ 4 ┆ 1 ┆ 5 ┆ … ┆ null ┆ For sale ┆ 600000 ┆ null │\n", - "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", - "│ OnTheMark ┆ 1 ┆ 1 ┆ 2 ┆ … ┆ null ┆ For sale ┆ 350000 ┆ null │\n", - "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", - "│ OnTheMark ┆ 1 ┆ 1 ┆ 2 ┆ … ┆ null ┆ For sale ┆ 475000 ┆ null │\n", - "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", - "│ OnTheMark ┆ 0 ┆ 1 ┆ 1 ┆ … ┆ null ┆ For sale ┆ 225000 ┆ null │\n", - "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", - "│ OnTheMark ┆ 2 ┆ 2 ┆ 4 ┆ … ┆ null ┆ For sale ┆ 575000 ┆ null │\n", - "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", - "│ OnTheMark ┆ 1 ┆ 1 ┆ 2 ┆ … ┆ null ┆ For sale ┆ 435000 ┆ null │\n", - "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", - "│ OnTheMark ┆ 2 ┆ 2 ┆ 4 ┆ … ┆ null ┆ For sale ┆ 450000 ┆ null │\n", - "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", - "│ OnTheMark ┆ 2 ┆ 2 ┆ 4 ┆ … ┆ null ┆ For sale ┆ 500000 ┆ null │\n", - "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", - "│ OnTheMark ┆ 2 ┆ 2 ┆ 4 ┆ … ┆ null ┆ For sale ┆ 650000 ┆ null │\n", - "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", - "│ OnTheMark ┆ 1 ┆ 1 ┆ 2 ┆ … ┆ null ┆ For sale ┆ 450000 ┆ null │\n", - "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", - "│ OnTheMark ┆ 1 ┆ 1 ┆ 2 ┆ … ┆ null ┆ For sale ┆ 340000 ┆ null │\n", - "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", - "│ OnTheMark ┆ 2 ┆ 1 ┆ 3 ┆ … ┆ null ┆ For sale ┆ 500000 ┆ null │\n", - "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", - "│ OnTheMark ┆ 1 ┆ 1 ┆ 2 ┆ … ┆ null ┆ For sale ┆ 550000 ┆ null │\n", - "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", - "│ Rightmove ┆ 1 ┆ 1 ┆ 2 ┆ … ┆ 2026-05-2 ┆ For sale ┆ 310000 ┆ null │\n", - "│ ┆ ┆ ┆ ┆ ┆ 9 ┆ ┆ ┆ │\n", - "│ ┆ ┆ ┆ ┆ ┆ 14:30:37 ┆ ┆ ┆ │\n", - "│ Rightmove ┆ 5 ┆ 4 ┆ 9 ┆ … ┆ 2026-04-1 ┆ For sale ┆ 2595000 ┆ 8355 │\n", - "│ ┆ ┆ ┆ ┆ ┆ 7 ┆ ┆ ┆ │\n", - "│ ┆ ┆ ┆ ┆ ┆ 18:34:21 ┆ ┆ ┆ │\n", - "│ Rightmove ┆ 6 ┆ 3 ┆ 9 ┆ … ┆ 2026-04-1 ┆ For sale ┆ 2295000 ┆ null │\n", - "│ ┆ ┆ ┆ ┆ ┆ 0 ┆ ┆ ┆ │\n", - "│ ┆ ┆ ┆ ┆ ┆ 11:17:35 ┆ ┆ ┆ │\n", - "│ Rightmove ┆ 4 ┆ 2 ┆ 6 ┆ … ┆ 2026-01-0 ┆ For sale ┆ 2250000 ┆ 10412 │\n", - "│ ┆ ┆ ┆ ┆ ┆ 2 ┆ ┆ ┆ │\n", - "│ ┆ ┆ ┆ ┆ ┆ 17:30:39 ┆ ┆ ┆ │\n", - "│ Rightmove ┆ 2 ┆ 2 ┆ 4 ┆ … ┆ 2026-04-0 ┆ For sale ┆ 2100000 ┆ 9841 │\n", - "│ ┆ ┆ ┆ ┆ ┆ 8 ┆ ┆ ┆ │\n", - "│ ┆ ┆ ┆ ┆ ┆ 17:23:59 ┆ ┆ ┆ │\n", - "│ Rightmove ┆ 4 ┆ 3 ┆ 7 ┆ … ┆ 2026-05-1 ┆ For sale ┆ 2100000 ┆ 10633 │\n", - "│ ┆ ┆ ┆ ┆ ┆ 3 ┆ ┆ ┆ │\n", - "│ ┆ ┆ ┆ ┆ ┆ 16:21:42 ┆ ┆ ┆ │\n", - "│ Rightmove ┆ 5 ┆ 3 ┆ 8 ┆ … ┆ 2026-04-2 ┆ For sale ┆ 1900000 ┆ 7702 │\n", - "│ ┆ ┆ ┆ ┆ ┆ 2 ┆ ┆ ┆ │\n", - "│ ┆ ┆ ┆ ┆ ┆ 16:04:47 ┆ ┆ ┆ │\n", - "│ Rightmove ┆ 3 ┆ 3 ┆ 6 ┆ … ┆ 2026-05-1 ┆ For sale ┆ 1695000 ┆ 10810 │\n", - "│ ┆ ┆ ┆ ┆ ┆ 2 ┆ ┆ ┆ │\n", - "│ ┆ ┆ ┆ ┆ ┆ 16:14:48 ┆ ┆ ┆ │\n", - "│ Rightmove ┆ 5 ┆ 3 ┆ 8 ┆ … ┆ 2025-10-0 ┆ For sale ┆ 1695000 ┆ 8773 │\n", - "│ ┆ ┆ ┆ ┆ ┆ 7 ┆ ┆ ┆ │\n", - "│ ┆ ┆ ┆ ┆ ┆ 09:57:34 ┆ ┆ ┆ │\n", - "│ Rightmove ┆ 2 ┆ 2 ┆ 4 ┆ … ┆ 2026-03-2 ┆ For sale ┆ 1695000 ┆ null │\n", - "│ ┆ ┆ ┆ ┆ ┆ 5 ┆ ┆ ┆ │\n", - "│ ┆ ┆ ┆ ┆ ┆ 09:55:49 ┆ ┆ ┆ │\n", - "│ Rightmove ┆ 4 ┆ 3 ┆ 7 ┆ … ┆ 2026-04-0 ┆ For sale ┆ 1650000 ┆ 9958 │\n", - "│ ┆ ┆ ┆ ┆ ┆ 2 ┆ ┆ ┆ │\n", - "│ ┆ ┆ ┆ ┆ ┆ 16:51:56 ┆ ┆ ┆ │\n", - "│ Rightmove ┆ 5 ┆ 2 ┆ 7 ┆ … ┆ 2026-05-1 ┆ For sale ┆ 1595000 ┆ 7995 │\n", - "│ ┆ ┆ ┆ ┆ ┆ 2 ┆ ┆ ┆ │\n", - "│ ┆ ┆ ┆ ┆ ┆ 14:23:19 ┆ ┆ ┆ │\n", - "│ Rightmove ┆ 5 ┆ 3 ┆ 8 ┆ … ┆ 2026-02-1 ┆ For sale ┆ 1550000 ┆ null │\n", - "│ ┆ ┆ ┆ ┆ ┆ 3 ┆ ┆ ┆ │\n", - "│ ┆ ┆ ┆ ┆ ┆ 14:31:16 ┆ ┆ ┆ │\n", - "│ Rightmove ┆ 8 ┆ 1 ┆ 9 ┆ … ┆ 2026-05-0 ┆ For sale ┆ 1550000 ┆ 35227 │\n", - "│ ┆ ┆ ┆ ┆ ┆ 6 ┆ ┆ ┆ │\n", - "│ ┆ ┆ ┆ ┆ ┆ 17:31:38 ┆ ┆ ┆ │\n", - "│ Rightmove ┆ 4 ┆ 2 ┆ 6 ┆ … ┆ 2026-04-1 ┆ For sale ┆ 1500000 ┆ 13100 │\n", - "│ ┆ ┆ ┆ ┆ ┆ 0 ┆ ┆ ┆ │\n", - "│ ┆ ┆ ┆ ┆ ┆ 09:39:04 ┆ ┆ ┆ │\n", - "│ Zoopla ┆ 4 ┆ 2 ┆ 6 ┆ … ┆ null ┆ For sale ┆ 995000 ┆ 8728 │\n", - "│ Zoopla ┆ 2 ┆ 1 ┆ 3 ┆ … ┆ null ┆ For sale ┆ 350000 ┆ 4493 │\n", - "│ Zoopla ┆ 5 ┆ 3 ┆ 8 ┆ … ┆ null ┆ For sale ┆ 1695000 ┆ 8697 │\n", - "│ Zoopla ┆ 3 ┆ 2 ┆ 5 ┆ … ┆ null ┆ For sale ┆ 525000 ┆ 5102 │\n", - "│ Zoopla ┆ 2 ┆ 2 ┆ 4 ┆ … ┆ null ┆ For sale ┆ 500000 ┆ 6944 │\n", - "│ Zoopla ┆ 2 ┆ 1 ┆ 3 ┆ … ┆ null ┆ For sale ┆ 515000 ┆ 9364 │\n", - "│ Zoopla ┆ 2 ┆ 1 ┆ 3 ┆ … ┆ null ┆ For sale ┆ 475000 ┆ 9557 │\n", - "│ Zoopla ┆ 1 ┆ 1 ┆ 2 ┆ … ┆ null ┆ For sale ┆ 465000 ┆ 8942 │\n", - "│ Zoopla ┆ 2 ┆ 1 ┆ 3 ┆ … ┆ null ┆ For sale ┆ 599950 ┆ 8546 │\n", - "│ Zoopla ┆ 1 ┆ 1 ┆ 2 ┆ … ┆ null ┆ For sale ┆ 375000 ┆ 8503 │\n", - "│ Zoopla ┆ 2 ┆ 2 ┆ 4 ┆ … ┆ null ┆ For sale ┆ 575000 ┆ null │\n", - "│ Zoopla ┆ 2 ┆ 1 ┆ 3 ┆ … ┆ null ┆ For sale ┆ 475000 ┆ 6597 │\n", - "│ Zoopla ┆ 2 ┆ 2 ┆ 4 ┆ … ┆ null ┆ For sale ┆ 580000 ┆ 7796 │\n", - "│ Zoopla ┆ 2 ┆ 2 ┆ 4 ┆ … ┆ null ┆ For sale ┆ 595000 ┆ 7997 │\n", - "│ Zoopla ┆ 2 ┆ 2 ┆ 4 ┆ … ┆ null ┆ For sale ┆ 575000 ┆ 7986 │\n", - "└───────────┴──────────┴───────────┴───────────┴───┴───────────┴───────────┴───────────┴───────────┘" - ] - }, - "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "df = (\n", - " pl.read_parquet(DATA_PATH)\n", - " .with_columns(\n", - " pl.when(pl.col(\"Listing URL\").str.contains(\"rightmove.co.uk\", literal=True))\n", - " .then(pl.lit(\"Rightmove\"))\n", - " .when(pl.col(\"Listing URL\").str.contains(\"onthemarket.com\", literal=True))\n", - " .then(pl.lit(\"OnTheMarket\"))\n", - " .when(pl.col(\"Listing URL\").str.contains(\"zoopla.co.uk\", literal=True))\n", - " .then(pl.lit(\"Zoopla\"))\n", - " .otherwise(pl.lit(\"Unknown\"))\n", - " .alias(\"provider\")\n", - " )\n", - " .filter(pl.col(\"provider\").is_in([\"Rightmove\", \"OnTheMarket\", \"Zoopla\"]))\n", - ")\n", - "\n", - "print(f\"Rows: {df.height:,}\")\n", - "print(f\"Columns: {len(df.columns):,}\")\n", - "display(df.group_by(\"provider\").len().sort(\"provider\"))\n", - "display(df.group_by(\"provider\", maintain_order=False).head(15).sort(\"provider\"))" - ] - }, - { - "cell_type": "markdown", - "id": "e775e26e", - "metadata": {}, - "source": [ - "## NA Counts By Provider" + "# Schema\n", + "pl.DataFrame({\"column\": raw.columns, \"dtype\": [str(t) for t in raw.dtypes]})" ] }, { "cell_type": "code", - "execution_count": 3, - "id": "059462d2", + "execution_count": null, + "id": "8c4641b6", "metadata": { "execution": { - "iopub.execute_input": "2026-05-17T10:23:47.956431Z", - "iopub.status.busy": "2026-05-17T10:23:47.956358Z", - "iopub.status.idle": "2026-05-17T10:23:47.979826Z", - "shell.execute_reply": "2026-05-17T10:23:47.979565Z" + "iopub.execute_input": "2026-06-03T07:34:30.904380Z", + "iopub.status.busy": "2026-06-03T07:34:30.904313Z", + "iopub.status.idle": "2026-06-03T07:34:30.907029Z", + "shell.execute_reply": "2026-06-03T07:34:30.906739Z" } }, "outputs": [ @@ -264,23 +175,1688 @@ " white-space: pre-wrap;\n", "}\n", "</style>\n", - "<small>shape: (3, 25)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>provider</th><th>Bedrooms</th><th>Bathrooms</th><th>Number of bedrooms & living rooms</th><th>lon</th><th>lat</th><th>Postcode</th><th>Postcode source</th><th>Extracted postcode</th><th>Inferred postcode</th><th>Listing raw address</th><th>Address per Property Register</th><th>UPRN</th><th>Property number or name</th><th>Leasehold/Freehold</th><th>Property type</th><th>Property sub-type</th><th>Price qualifier</th><th>Total floor area (sqm)</th><th>Listing URL</th><th>Listing features</th><th>Listing date</th><th>Listing status</th><th>Asking price</th><th>Asking price per sqm</th></tr><tr><td>str</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td></tr></thead><tbody><tr><td>"OnTheMarket"</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>84</td><td>0</td><td>0</td><td>0</td><td>85</td><td>85</td><td>0</td><td>0</td><td>0</td><td>0</td><td>82</td><td>0</td><td>0</td><td>85</td><td>0</td><td>0</td><td>82</td></tr><tr><td>"Rightmove"</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>98</td><td>0</td><td>0</td><td>0</td><td>99</td><td>99</td><td>17</td><td>0</td><td>0</td><td>0</td><td>34</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>34</td></tr><tr><td>"Zoopla"</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>58</td><td>0</td><td>0</td><td>0</td><td>25</td><td>11</td><td>14</td><td>0</td><td>0</td><td>0</td><td>5</td><td>0</td><td>0</td><td>58</td><td>0</td><td>0</td><td>5</td></tr></tbody></table></div>" + "<small>shape: (8, 10)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>provider</th><th>Postcode</th><th>Property type</th><th>Property sub-type</th><th>Bedrooms</th><th>Bathrooms</th><th>Asking price</th><th>Total floor area (sqm)</th><th>Price qualifier</th><th>Listing date</th></tr><tr><td>str</td><td>str</td><td>str</td><td>str</td><td>i32</td><td>i32</td><td>i64</td><td>f64</td><td>str</td><td>datetime[μs]</td></tr></thead><tbody><tr><td>"Rightmove"</td><td>"BR1 5RW"</td><td>"Semi-Detached"</td><td>"Semi-Detached"</td><td>3</td><td>1</td><td>550000</td><td>null</td><td>""</td><td>2025-11-12 13:58:41</td></tr><tr><td>"Rightmove"</td><td>"BR1 2PF"</td><td>"Detached"</td><td>"Detached"</td><td>6</td><td>4</td><td>3000000</td><td>361.8</td><td>""</td><td>2026-01-22 10:22:09</td></tr><tr><td>"Rightmove"</td><td>"BR1 2QD"</td><td>"Detached"</td><td>"Detached"</td><td>5</td><td>5</td><td>3000000</td><td>null</td><td>"Guide Price"</td><td>2026-03-24 10:55:03</td></tr><tr><td>"Rightmove"</td><td>"BR1 3LU"</td><td>"Detached"</td><td>"Detached"</td><td>6</td><td>0</td><td>2750000</td><td>322.1</td><td>""</td><td>2026-04-25 11:59:31</td></tr><tr><td>"Rightmove"</td><td>"BR1 3AR"</td><td>"Detached"</td><td>"Detached"</td><td>6</td><td>4</td><td>2695000</td><td>483.6</td><td>""</td><td>2026-01-06 21:38:25</td></tr><tr><td>"Rightmove"</td><td>"BR1 2AY"</td><td>"Detached"</td><td>"Detached"</td><td>5</td><td>5</td><td>2500000</td><td>402.8</td><td>"Offers in Excess of"</td><td>2026-02-20 11:48:01</td></tr><tr><td>"Rightmove"</td><td>"BR1 2HG"</td><td>"Detached"</td><td>"Detached"</td><td>5</td><td>4</td><td>2500000</td><td>457.5</td><td>"Guide Price"</td><td>2026-02-07 18:12:38</td></tr><tr><td>"Rightmove"</td><td>"BR1 2JG"</td><td>"Detached"</td><td>"Detached"</td><td>5</td><td>3</td><td>2350000</td><td>null</td><td>""</td><td>2026-05-01 11:14:35</td></tr></tbody></table></div>" + ], + "text/plain": [ + "shape: (8, 10)\n", + "┌─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬────────┐\n", + "│ provide ┆ Postcod ┆ Propert ┆ Propert ┆ Bedroom ┆ Bathroo ┆ Asking ┆ Total ┆ Price ┆ Listin │\n", + "│ r ┆ e ┆ y type ┆ y sub-t ┆ s ┆ ms ┆ price ┆ floor ┆ qualifi ┆ g date │\n", + "│ --- ┆ --- ┆ --- ┆ ype ┆ --- ┆ --- ┆ --- ┆ area ┆ er ┆ --- │\n", + "│ str ┆ str ┆ str ┆ --- ┆ i32 ┆ i32 ┆ i64 ┆ (sqm) ┆ --- ┆ dateti │\n", + "│ ┆ ┆ ┆ str ┆ ┆ ┆ ┆ --- ┆ str ┆ me[μs] │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ ┆ │\n", + "╞═════════╪═════════╪═════════╪═════════╪═════════╪═════════╪═════════╪═════════╪═════════╪════════╡\n", + "│ Rightmo ┆ BR1 5RW ┆ Semi-De ┆ Semi-De ┆ 3 ┆ 1 ┆ 550000 ┆ null ┆ ┆ 2025-1 │\n", + "│ ve ┆ ┆ tached ┆ tached ┆ ┆ ┆ ┆ ┆ ┆ 1-12 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 13:58: │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 41 │\n", + "│ Rightmo ┆ BR1 2PF ┆ Detache ┆ Detache ┆ 6 ┆ 4 ┆ 3000000 ┆ 361.8 ┆ ┆ 2026-0 │\n", + "│ ve ┆ ┆ d ┆ d ┆ ┆ ┆ ┆ ┆ ┆ 1-22 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 10:22: │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 09 │\n", + "│ Rightmo ┆ BR1 2QD ┆ Detache ┆ Detache ┆ 5 ┆ 5 ┆ 3000000 ┆ null ┆ Guide ┆ 2026-0 │\n", + "│ ve ┆ ┆ d ┆ d ┆ ┆ ┆ ┆ ┆ Price ┆ 3-24 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 10:55: │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 03 │\n", + "│ Rightmo ┆ BR1 3LU ┆ Detache ┆ Detache ┆ 6 ┆ 0 ┆ 2750000 ┆ 322.1 ┆ ┆ 2026-0 │\n", + "│ ve ┆ ┆ d ┆ d ┆ ┆ ┆ ┆ ┆ ┆ 4-25 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 11:59: │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 31 │\n", + "│ Rightmo ┆ BR1 3AR ┆ Detache ┆ Detache ┆ 6 ┆ 4 ┆ 2695000 ┆ 483.6 ┆ ┆ 2026-0 │\n", + "│ ve ┆ ┆ d ┆ d ┆ ┆ ┆ ┆ ┆ ┆ 1-06 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 21:38: │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 25 │\n", + "│ Rightmo ┆ BR1 2AY ┆ Detache ┆ Detache ┆ 5 ┆ 5 ┆ 2500000 ┆ 402.8 ┆ Offers ┆ 2026-0 │\n", + "│ ve ┆ ┆ d ┆ d ┆ ┆ ┆ ┆ ┆ in ┆ 2-20 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ Excess ┆ 11:48: │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ of ┆ 01 │\n", + "│ Rightmo ┆ BR1 2HG ┆ Detache ┆ Detache ┆ 5 ┆ 4 ┆ 2500000 ┆ 457.5 ┆ Guide ┆ 2026-0 │\n", + "│ ve ┆ ┆ d ┆ d ┆ ┆ ┆ ┆ ┆ Price ┆ 2-07 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 18:12: │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 38 │\n", + "│ Rightmo ┆ BR1 2JG ┆ Detache ┆ Detache ┆ 5 ┆ 3 ┆ 2350000 ┆ null ┆ ┆ 2026-0 │\n", + "│ ve ┆ ┆ d ┆ d ┆ ┆ ┆ ┆ ┆ ┆ 5-01 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 11:14: │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 35 │\n", + "└─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴────────┘" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# A few rows\n", + "raw.select(\n", + " \"provider\", \"Postcode\", \"Property type\", \"Property sub-type\",\n", + " \"Bedrooms\", \"Bathrooms\", \"Asking price\", \"Total floor area (sqm)\",\n", + " \"Price qualifier\", \"Listing date\",\n", + ").head(8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d44013c8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:30.907698Z", + "iopub.status.busy": "2026-06-03T07:34:30.907610Z", + "iopub.status.idle": "2026-06-03T07:34:30.912246Z", + "shell.execute_reply": "2026-06-03T07:34:30.911979Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "<div><style>\n", + ".dataframe > thead > tr,\n", + ".dataframe > tbody > tr {\n", + " text-align: right;\n", + " white-space: pre-wrap;\n", + "}\n", + "</style>\n", + "<small>shape: (9, 9)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>statistic</th><th>Bedrooms</th><th>Bathrooms</th><th>Number of bedrooms & living rooms</th><th>Asking price</th><th>Total floor area (sqm)</th><th>Asking price per sqm</th><th>lat</th><th>lon</th></tr><tr><td>str</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td></tr></thead><tbody><tr><td>"count"</td><td>112605.0</td><td>112605.0</td><td>112605.0</td><td>112241.0</td><td>56914.0</td><td>56914.0</td><td>112605.0</td><td>112605.0</td></tr><tr><td>"null_count"</td><td>0.0</td><td>0.0</td><td>0.0</td><td>364.0</td><td>55691.0</td><td>55691.0</td><td>0.0</td><td>0.0</td></tr><tr><td>"mean"</td><td>2.39191</td><td>1.567399</td><td>3.959309</td><td>921922.833465</td><td>113.720136</td><td>9283.323295</td><td>51.500839</td><td>-0.147325</td></tr><tr><td>"std"</td><td>1.400247</td><td>1.013846</td><td>2.225019</td><td>1.6093e6</td><td>108.288173</td><td>7445.316463</td><td>0.083935</td><td>0.166763</td></tr><tr><td>"min"</td><td>0.0</td><td>0.0</td><td>0.0</td><td>1.0</td><td>5.0</td><td>4.0</td><td>51.242629</td><td>-0.593469</td></tr><tr><td>"25%"</td><td>1.0</td><td>1.0</td><td>2.0</td><td>375000.0</td><td>60.0</td><td>5624.0</td><td>51.450302</td><td>-0.245267</td></tr><tr><td>"50%"</td><td>2.0</td><td>1.0</td><td>4.0</td><td>550000.0</td><td>81.8</td><td>7301.0</td><td>51.5008</td><td>-0.15191</td></tr><tr><td>"75%"</td><td>3.0</td><td>2.0</td><td>5.0</td><td>875000.0</td><td>126.0</td><td>10492.0</td><td>51.550221</td><td>-0.05151</td></tr><tr><td>"max"</td><td>20.0</td><td>20.0</td><td>40.0</td><td>1e8</td><td>1893.1</td><td>410959.0</td><td>51.781074</td><td>0.452373</td></tr></tbody></table></div>" + ], + "text/plain": [ + "shape: (9, 9)\n", + "┌──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┐\n", + "│ statisti ┆ Bedrooms ┆ Bathroom ┆ Number ┆ Asking ┆ Total ┆ Asking ┆ lat ┆ lon │\n", + "│ c ┆ --- ┆ s ┆ of ┆ price ┆ floor ┆ price ┆ --- ┆ --- │\n", + "│ --- ┆ f64 ┆ --- ┆ bedrooms ┆ --- ┆ area ┆ per sqm ┆ f64 ┆ f64 │\n", + "│ str ┆ ┆ f64 ┆ & living ┆ f64 ┆ (sqm) ┆ --- ┆ ┆ │\n", + "│ ┆ ┆ ┆ rooms ┆ ┆ --- ┆ f64 ┆ ┆ │\n", + "│ ┆ ┆ ┆ --- ┆ ┆ f64 ┆ ┆ ┆ │\n", + "│ ┆ ┆ ┆ f64 ┆ ┆ ┆ ┆ ┆ │\n", + "╞══════════╪══════════╪══════════╪══════════╪══════════╪══════════╪══════════╪══════════╪══════════╡\n", + "│ count ┆ 112605.0 ┆ 112605.0 ┆ 112605.0 ┆ 112241.0 ┆ 56914.0 ┆ 56914.0 ┆ 112605.0 ┆ 112605.0 │\n", + "│ null_cou ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 364.0 ┆ 55691.0 ┆ 55691.0 ┆ 0.0 ┆ 0.0 │\n", + "│ nt ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ mean ┆ 2.39191 ┆ 1.567399 ┆ 3.959309 ┆ 921922.8 ┆ 113.7201 ┆ 9283.323 ┆ 51.50083 ┆ -0.14732 │\n", + "│ ┆ ┆ ┆ ┆ 33465 ┆ 36 ┆ 295 ┆ 9 ┆ 5 │\n", + "│ std ┆ 1.400247 ┆ 1.013846 ┆ 2.225019 ┆ 1.6093e6 ┆ 108.2881 ┆ 7445.316 ┆ 0.083935 ┆ 0.166763 │\n", + "│ ┆ ┆ ┆ ┆ ┆ 73 ┆ 463 ┆ ┆ │\n", + "│ min ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 1.0 ┆ 5.0 ┆ 4.0 ┆ 51.24262 ┆ -0.59346 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 9 ┆ 9 │\n", + "│ 25% ┆ 1.0 ┆ 1.0 ┆ 2.0 ┆ 375000.0 ┆ 60.0 ┆ 5624.0 ┆ 51.45030 ┆ -0.24526 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 2 ┆ 7 │\n", + "│ 50% ┆ 2.0 ┆ 1.0 ┆ 4.0 ┆ 550000.0 ┆ 81.8 ┆ 7301.0 ┆ 51.5008 ┆ -0.15191 │\n", + "│ 75% ┆ 3.0 ┆ 2.0 ┆ 5.0 ┆ 875000.0 ┆ 126.0 ┆ 10492.0 ┆ 51.55022 ┆ -0.05151 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 1 ┆ │\n", + "│ max ┆ 20.0 ┆ 20.0 ┆ 40.0 ┆ 1e8 ┆ 1893.1 ┆ 410959.0 ┆ 51.78107 ┆ 0.452373 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 4 ┆ │\n", + "└──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┘" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Numeric summary\n", + "raw.select(\n", + " \"Bedrooms\", \"Bathrooms\", \"Number of bedrooms & living rooms\",\n", + " \"Asking price\", \"Total floor area (sqm)\", \"Asking price per sqm\", \"lat\", \"lon\",\n", + ").describe()" + ] + }, + { + "cell_type": "markdown", + "id": "bc5e4659", + "metadata": {}, + "source": [ + "## 2 · Missingness (null **or** empty-string) by provider\n", + "\n", + "Note the *structural* gaps: `UPRN` & `Listing date` are populated by only one or two portals,\n", + "and `Total floor area` is ~half-missing with a strong portal skew." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6a41dce1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:30.912874Z", + "iopub.status.busy": "2026-06-03T07:34:30.912800Z", + "iopub.status.idle": "2026-06-03T07:34:30.930428Z", + "shell.execute_reply": "2026-06-03T07:34:30.930051Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "<div><style>\n", + ".dataframe > thead > tr,\n", + ".dataframe > tbody > tr {\n", + " text-align: right;\n", + " white-space: pre-wrap;\n", + "}\n", + "</style>\n", + "<small>shape: (3, 25)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>provider</th><th>Bedrooms</th><th>Bathrooms</th><th>Number of bedrooms & living rooms</th><th>lon</th><th>lat</th><th>Postcode</th><th>Postcode source</th><th>Extracted postcode</th><th>Inferred postcode</th><th>Listing raw address</th><th>Address per Property Register</th><th>UPRN</th><th>Property number or name</th><th>Leasehold/Freehold</th><th>Property type</th><th>Property sub-type</th><th>Price qualifier</th><th>Total floor area (sqm)</th><th>Listing URL</th><th>Listing features</th><th>Listing date</th><th>Listing status</th><th>Asking price</th><th>Asking price per sqm</th></tr><tr><td>str</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td></tr></thead><tbody><tr><td>"OnTheMarket"</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>95.9</td><td>0.0</td><td>0.0</td><td>0.1</td><td>100.0</td><td>100.0</td><td>11.2</td><td>0.0</td><td>0.0</td><td>60.9</td><td>86.9</td><td>0.0</td><td>0.0</td><td>100.0</td><td>0.0</td><td>0.1</td><td>86.9</td></tr><tr><td>"Rightmove"</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>95.1</td><td>0.0</td><td>0.0</td><td>0.0</td><td>100.0</td><td>100.0</td><td>14.2</td><td>0.0</td><td>0.0</td><td>58.8</td><td>46.8</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>46.8</td></tr><tr><td>"Zoopla"</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>100.0</td><td>0.0</td><td>40.1</td><td>40.2</td><td>70.7</td><td>61.5</td><td>50.2</td><td>0.0</td><td>0.0</td><td>100.0</td><td>16.8</td><td>0.0</td><td>0.0</td><td>100.0</td><td>0.0</td><td>4.9</td><td>16.8</td></tr></tbody></table></div>" ], "text/plain": [ "shape: (3, 25)\n", - "┌────────────┬──────────┬───────────┬────────────┬───┬────────────┬───────────┬────────┬───────────┐\n", - "│ provider ┆ Bedrooms ┆ Bathrooms ┆ Number of ┆ … ┆ Listing ┆ Listing ┆ Asking ┆ Asking │\n", - "│ --- ┆ --- ┆ --- ┆ bedrooms & ┆ ┆ date ┆ status ┆ price ┆ price per │\n", - "│ str ┆ u32 ┆ u32 ┆ living ┆ ┆ --- ┆ --- ┆ --- ┆ sqm │\n", - "│ ┆ ┆ ┆ rooms ┆ ┆ u32 ┆ u32 ┆ u32 ┆ --- │\n", - "│ ┆ ┆ ┆ --- ┆ ┆ ┆ ┆ ┆ u32 │\n", - "│ ┆ ┆ ┆ u32 ┆ ┆ ┆ ┆ ┆ │\n", - "╞════════════╪══════════╪═══════════╪════════════╪═══╪════════════╪═══════════╪════════╪═══════════╡\n", - "│ OnTheMarke ┆ 0 ┆ 0 ┆ 0 ┆ … ┆ 85 ┆ 0 ┆ 0 ┆ 82 │\n", - "│ t ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", - "│ Rightmove ┆ 0 ┆ 0 ┆ 0 ┆ … ┆ 0 ┆ 0 ┆ 0 ┆ 34 │\n", - "│ Zoopla ┆ 0 ┆ 0 ┆ 0 ┆ … ┆ 58 ┆ 0 ┆ 0 ┆ 5 │\n", - "└────────────┴──────────┴───────────┴────────────┴───┴────────────┴───────────┴────────┴───────────┘" + "┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐\n", + "│ pro ┆ Bed ┆ Bat ┆ Num ┆ lon ┆ lat ┆ Pos ┆ Pos ┆ Ext ┆ Inf ┆ Lis ┆ Add ┆ UPR ┆ Pro ┆ Lea ┆ Pro ┆ Pro ┆ Pri ┆ Tot ┆ Lis ┆ Lis ┆ Lis ┆ Lis ┆ Ask ┆ Ask │\n", + "│ vid ┆ roo ┆ hro ┆ ber ┆ --- ┆ --- ┆ tco ┆ tco ┆ rac ┆ err ┆ tin ┆ res ┆ N ┆ per ┆ seh ┆ per ┆ per ┆ ce ┆ al ┆ tin ┆ tin ┆ tin ┆ tin ┆ ing ┆ ing │\n", + "│ er ┆ ms ┆ oms ┆ of ┆ f64 ┆ f64 ┆ de ┆ de ┆ ted ┆ ed ┆ g ┆ s ┆ --- ┆ ty ┆ old ┆ ty ┆ ty ┆ qua ┆ flo ┆ g ┆ g ┆ g ┆ g ┆ pri ┆ pri │\n", + "│ --- ┆ --- ┆ --- ┆ bed ┆ ┆ ┆ --- ┆ sou ┆ pos ┆ pos ┆ raw ┆ per ┆ f64 ┆ num ┆ /Fr ┆ typ ┆ sub ┆ lif ┆ or ┆ URL ┆ fea ┆ dat ┆ sta ┆ ce ┆ ce │\n", + "│ str ┆ f64 ┆ f64 ┆ roo ┆ ┆ ┆ f64 ┆ rce ┆ tco ┆ tco ┆ add ┆ Pro ┆ ┆ ber ┆ eeh ┆ e ┆ -ty ┆ ier ┆ are ┆ --- ┆ tur ┆ e ┆ tus ┆ --- ┆ per │\n", + "│ ┆ ┆ ┆ ms ┆ ┆ ┆ ┆ --- ┆ de ┆ de ┆ res ┆ per ┆ ┆ or ┆ old ┆ --- ┆ pe ┆ --- ┆ a ┆ f64 ┆ es ┆ --- ┆ --- ┆ f64 ┆ sqm │\n", + "│ ┆ ┆ ┆ & ┆ ┆ ┆ ┆ f64 ┆ --- ┆ --- ┆ s ┆ ty ┆ ┆ nam ┆ --- ┆ f64 ┆ --- ┆ f64 ┆ (sq ┆ ┆ --- ┆ f64 ┆ f64 ┆ ┆ --- │\n", + "│ ┆ ┆ ┆ liv ┆ ┆ ┆ ┆ ┆ f64 ┆ f64 ┆ --- ┆ Reg ┆ ┆ e ┆ f64 ┆ ┆ f64 ┆ ┆ m) ┆ ┆ f64 ┆ ┆ ┆ ┆ f64 │\n", + "│ ┆ ┆ ┆ ing ┆ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ ist ┆ ┆ --- ┆ ┆ ┆ ┆ ┆ --- ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ ┆ ┆ ┆ roo ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ er ┆ ┆ f64 ┆ ┆ ┆ ┆ ┆ f64 ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ ┆ ┆ ┆ ms ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ --- ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ ┆ ┆ ┆ --- ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ ┆ ┆ ┆ f64 ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "╞═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╡\n", + "│ OnT ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 95. ┆ 0.0 ┆ 0.0 ┆ 0.1 ┆ 100 ┆ 100 ┆ 11. ┆ 0.0 ┆ 0.0 ┆ 60. ┆ 86. ┆ 0.0 ┆ 0.0 ┆ 100 ┆ 0.0 ┆ 0.1 ┆ 86. │\n", + "│ heM ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 9 ┆ ┆ ┆ ┆ .0 ┆ .0 ┆ 2 ┆ ┆ ┆ 9 ┆ 9 ┆ ┆ ┆ .0 ┆ ┆ ┆ 9 │\n", + "│ ark ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ Rig ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 95. ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 100 ┆ 100 ┆ 14. ┆ 0.0 ┆ 0.0 ┆ 58. ┆ 46. ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 46. │\n", + "│ htm ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 1 ┆ ┆ ┆ ┆ .0 ┆ .0 ┆ 2 ┆ ┆ ┆ 8 ┆ 8 ┆ ┆ ┆ ┆ ┆ ┆ 8 │\n", + "│ ove ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ Zoo ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 100 ┆ 0.0 ┆ 40. ┆ 40. ┆ 70. ┆ 61. ┆ 50. ┆ 0.0 ┆ 0.0 ┆ 100 ┆ 16. ┆ 0.0 ┆ 0.0 ┆ 100 ┆ 0.0 ┆ 4.9 ┆ 16. │\n", + "│ pla ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ .0 ┆ ┆ 1 ┆ 2 ┆ 7 ┆ 5 ┆ 2 ┆ ┆ ┆ .0 ┆ 8 ┆ ┆ ┆ .0 ┆ ┆ ┆ 8 │\n", + "└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def missing_count(col: str, dtype) -> pl.Expr:\n", + " m = pl.col(col).is_null()\n", + " if dtype in (pl.Float32, pl.Float64):\n", + " m = m | pl.col(col).is_nan().fill_null(False)\n", + " if dtype == pl.String:\n", + " m = m | (pl.col(col).str.strip_chars() == \"\")\n", + " return m.sum().alias(col)\n", + "\n", + "value_cols = [c for c in raw.columns if c != \"provider\"]\n", + "miss = (\n", + " raw.group_by(\"provider\")\n", + " .agg([missing_count(c, raw.schema[c]) for c in value_cols] + [pl.len().alias(\"__rows\")])\n", + " .sort(\"provider\")\n", + ")\n", + "miss_pct = miss.select(\n", + " [\"provider\"] + [(pl.col(c) / pl.col(\"__rows\") * 100).round(1).alias(c) for c in value_cols]\n", + ")\n", + "miss_pct" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1c09cfb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:30.931519Z", + "iopub.status.busy": "2026-06-03T07:34:30.931390Z", + "iopub.status.idle": "2026-06-03T07:34:31.040814Z", + "shell.execute_reply": "2026-06-03T07:34:31.040504Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1650x308 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Heatmap of % missing (null or empty) per column per provider\n", + "mat = miss_pct.select(value_cols).to_numpy()\n", + "fig, ax = plt.subplots(figsize=(15, 2.8))\n", + "im = ax.imshow(mat, aspect=\"auto\", cmap=\"Reds\", vmin=0, vmax=100)\n", + "ax.set_xticks(range(len(value_cols)))\n", + "ax.set_xticklabels(value_cols, rotation=65, ha=\"right\", fontsize=7)\n", + "ax.set_yticks(range(miss_pct.height))\n", + "ax.set_yticklabels(miss_pct[\"provider\"].to_list())\n", + "for (i, j), v in np.ndenumerate(mat):\n", + " if v > 0:\n", + " ax.text(j, i, f\"{v:.0f}\", ha=\"center\", va=\"center\", fontsize=6,\n", + " color=\"white\" if v > 55 else \"black\")\n", + "fig.colorbar(im, ax=ax, label=\"% missing\", fraction=0.025, pad=0.01)\n", + "ax.set_title(\"Missing (null or empty-string) % by provider\")\n", + "plt.tight_layout(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ac443ace", + "metadata": {}, + "source": [ + "## 3 · Data issues\n", + "\n", + "Each subsection demonstrates one issue group. Severity tags (🔴 high / 🟠 medium / 🟡 low) match the audit." + ] + }, + { + "cell_type": "markdown", + "id": "7ea9293c", + "metadata": {}, + "source": [ + "### 3.1 · 🔴 Mislabeled column — `Number of bedrooms & living rooms` is actually `Bedrooms + Bathrooms`\n", + "\n", + "The column name promises *living rooms / receptions*, but `storage.py` recomputes it as\n", + "`Bedrooms + Bathrooms` for **every** row of **every** portal (Zoopla's `+ receptions` line is\n", + "dead code, overwritten at write time). It carries no living-room information." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b4844918", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.041972Z", + "iopub.status.busy": "2026-06-03T07:34:31.041873Z", + "iopub.status.idle": "2026-06-03T07:34:31.050408Z", + "shell.execute_reply": "2026-06-03T07:34:31.050059Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fraction of rows where col == Bedrooms + Bathrooms: 1.0000\n" + ] + }, + { + "data": { + "text/html": [ + "<div><style>\n", + ".dataframe > thead > tr,\n", + ".dataframe > tbody > tr {\n", + " text-align: right;\n", + " white-space: pre-wrap;\n", + "}\n", + "</style>\n", + "<small>shape: (3, 2)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>provider</th><th>frac == beds+baths</th></tr><tr><td>str</td><td>f64</td></tr></thead><tbody><tr><td>"OnTheMarket"</td><td>1.0</td></tr><tr><td>"Rightmove"</td><td>1.0</td></tr><tr><td>"Zoopla"</td><td>1.0</td></tr></tbody></table></div>" + ], + "text/plain": [ + "shape: (3, 2)\n", + "┌─────────────┬────────────────────┐\n", + "│ provider ┆ frac == beds+baths │\n", + "│ --- ┆ --- │\n", + "│ str ┆ f64 │\n", + "╞═════════════╪════════════════════╡\n", + "│ OnTheMarket ┆ 1.0 │\n", + "│ Rightmove ┆ 1.0 │\n", + "│ Zoopla ┆ 1.0 │\n", + "└─────────────┴────────────────────┘" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "share = raw.select(\n", + " (pl.col(\"Number of bedrooms & living rooms\") == pl.col(\"Bedrooms\") + pl.col(\"Bathrooms\")).mean()\n", + ").item()\n", + "print(f\"Fraction of rows where col == Bedrooms + Bathrooms: {share:.4f}\")\n", + "raw.group_by(\"provider\").agg(\n", + " (pl.col(\"Number of bedrooms & living rooms\") == pl.col(\"Bedrooms\") + pl.col(\"Bathrooms\"))\n", + " .mean().round(4).alias(\"frac == beds+baths\")\n", + ").sort(\"provider\")" + ] + }, + { + "cell_type": "markdown", + "id": "c59f527f", + "metadata": {}, + "source": [ + "### 3.2 · 🔴 Price integrity\n", + "\n", + "- **Shared-ownership / part-buy** listings store the *share* price as `Asking price`, not full value\n", + " (median ~£146k vs ~£550k) — corrupts any price / £-per-sqm aggregate.\n", + "- **38% of rows carry a non-firm qualifier** (Guide / Offers Over / OIEO / From / Shared); `Asking price`\n", + " is stored identically regardless.\n", + "- A `<£10k` tail of auction land/garage lots + two `£1` placeholders; 364 nulls (price ≤ 0 → null)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e713c7a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.051474Z", + "iopub.status.busy": "2026-06-03T07:34:31.051346Z", + "iopub.status.idle": "2026-06-03T07:34:31.070546Z", + "shell.execute_reply": "2026-06-03T07:34:31.070206Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shared-ownership / part-buy rows : 1,404\n", + "Non-firm price qualifier rows : 42,734 (38.0%)\n", + "Asking price null : 364\n", + "Asking price < £10k : 39\n", + "Asking price >= £20M : 124 (max = £100,000,000)\n" + ] + }, + { + "data": { + "text/html": [ + "<div><style>\n", + ".dataframe > thead > tr,\n", + ".dataframe > tbody > tr {\n", + " text-align: right;\n", + " white-space: pre-wrap;\n", + "}\n", + "</style>\n", + "<small>shape: (2, 4)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>shared_ownership</th><th>rows</th><th>median_price</th><th>median_£/sqm</th></tr><tr><td>bool</td><td>u32</td><td>f64</td><td>f64</td></tr></thead><tbody><tr><td>false</td><td>111201</td><td>550000.0</td><td>7323.0</td></tr><tr><td>true</td><td>1404</td><td>146250.0</td><td>2163.5</td></tr></tbody></table></div>" + ], + "text/plain": [ + "shape: (2, 4)\n", + "┌──────────────────┬────────┬──────────────┬──────────────┐\n", + "│ shared_ownership ┆ rows ┆ median_price ┆ median_£/sqm │\n", + "│ --- ┆ --- ┆ --- ┆ --- │\n", + "│ bool ┆ u32 ┆ f64 ┆ f64 │\n", + "╞══════════════════╪════════╪══════════════╪══════════════╡\n", + "│ false ┆ 111201 ┆ 550000.0 ┆ 7323.0 │\n", + "│ true ┆ 1404 ┆ 146250.0 ┆ 2163.5 │\n", + "└──────────────────┴────────┴──────────────┴──────────────┘" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SHARED = pl.col(\"Price qualifier\").str.to_lowercase().str.contains(\"shared|part buy|part-buy\")\n", + "NONFIRM = pl.col(\"Price qualifier\").str.to_lowercase().str.contains(\n", + " \"offers|from|guide|region|shared|part buy|part-buy|invited\"\n", + ")\n", + "print(f\"Shared-ownership / part-buy rows : {raw.filter(SHARED).height:,}\")\n", + "print(f\"Non-firm price qualifier rows : {raw.filter(NONFIRM).height:,} \"\n", + " f\"({raw.filter(NONFIRM).height / raw.height:.1%})\")\n", + "print(f\"Asking price null : {raw['Asking price'].null_count():,}\")\n", + "print(f\"Asking price < £10k : {raw.filter(pl.col('Asking price') < 10_000).height:,}\")\n", + "print(f\"Asking price >= £20M : {raw.filter(pl.col('Asking price') >= 20_000_000).height:,}\"\n", + " f\" (max = £{raw['Asking price'].max():,})\")\n", + "\n", + "raw.with_columns(SHARED.alias(\"shared_ownership\")).group_by(\"shared_ownership\").agg(\n", + " pl.len().alias(\"rows\"),\n", + " pl.col(\"Asking price\").median().alias(\"median_price\"),\n", + " pl.col(\"Asking price per sqm\").median().alias(\"median_£/sqm\"),\n", + ").sort(\"shared_ownership\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e5a61f92", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.071403Z", + "iopub.status.busy": "2026-06-03T07:34:31.071326Z", + "iopub.status.idle": "2026-06-03T07:34:31.155910Z", + "shell.execute_reply": "2026-06-03T07:34:31.155577Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 990x352 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Asking-price distribution (log scale) with the implausible tails marked\n", + "prices = raw[\"Asking price\"].drop_nulls().to_numpy().astype(float)\n", + "fig, ax = plt.subplots(figsize=(9, 3.2))\n", + "ax.hist(np.log10(np.clip(prices, 1, None)), bins=90, color=\"#2563eb\")\n", + "for v, lab in [(10_000, \"£10k\"), (20_000_000, \"£20M\"), (100_000_000, \"£100M\")]:\n", + " ax.axvline(np.log10(v), color=\"red\", ls=\"--\", lw=1)\n", + " ax.text(np.log10(v), ax.get_ylim()[1] * 0.92, lab, rotation=90, fontsize=7,\n", + " color=\"red\", va=\"top\")\n", + "ax.set_xlabel(\"log10(Asking price)\"); ax.set_ylabel(\"count\")\n", + "ax.set_title(\"Asking price distribution (log scale)\")\n", + "plt.tight_layout(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "238478fd", + "metadata": {}, + "source": [ + "### 3.3 · 🔴 Floor area & price-per-sqm\n", + "\n", + "- ~49% of `Total floor area (sqm)` is null (OnTheMarket ~87%).\n", + "- **Impossible tiny areas**: rows under 20 m² with ≥2 bedrooms (single-room dimensions parsed as total).\n", + "- **Suspiciously large areas** (>400 m²) — likely sq ft never converted to m².\n", + "- `Asking price per sqm` is mechanically correct but faithfully amplifies bad areas (max £410,959/m²)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "acfba0f8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.156976Z", + "iopub.status.busy": "2026-06-03T07:34:31.156880Z", + "iopub.status.idle": "2026-06-03T07:34:31.164246Z", + "shell.execute_reply": "2026-06-03T07:34:31.163925Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Floor area null : 55,691 (49.5%)\n", + "Impossible (area<20 & beds>=2): 89\n", + "Suspiciously large (area>400) : 1,310\n", + "£/sqm > £30k : 969 (max = £410,959/sqm)\n" + ] + }, + { + "data": { + "text/html": [ + "<div><style>\n", + ".dataframe > thead > tr,\n", + ".dataframe > tbody > tr {\n", + " text-align: right;\n", + " white-space: pre-wrap;\n", + "}\n", + "</style>\n", + "<small>shape: (6, 5)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>provider</th><th>Bedrooms</th><th>Total floor area (sqm)</th><th>Asking price</th><th>Asking price per sqm</th></tr><tr><td>str</td><td>i32</td><td>f64</td><td>i64</td><td>i32</td></tr></thead><tbody><tr><td>"Zoopla"</td><td>2</td><td>6.1</td><td>1270000</td><td>208197</td></tr><tr><td>"Zoopla"</td><td>2</td><td>6.1</td><td>1270000</td><td>208197</td></tr><tr><td>"Zoopla"</td><td>2</td><td>6.1</td><td>1270000</td><td>208197</td></tr><tr><td>"Rightmove"</td><td>2</td><td>6.8</td><td>1400000</td><td>205882</td></tr><tr><td>"Zoopla"</td><td>2</td><td>6.1</td><td>1250000</td><td>204918</td></tr><tr><td>"Rightmove"</td><td>2</td><td>7.2</td><td>1250000</td><td>173611</td></tr></tbody></table></div>" + ], + "text/plain": [ + "shape: (6, 5)\n", + "┌───────────┬──────────┬────────────────────────┬──────────────┬──────────────────────┐\n", + "│ provider ┆ Bedrooms ┆ Total floor area (sqm) ┆ Asking price ┆ Asking price per sqm │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ --- │\n", + "│ str ┆ i32 ┆ f64 ┆ i64 ┆ i32 │\n", + "╞═══════════╪══════════╪════════════════════════╪══════════════╪══════════════════════╡\n", + "│ Zoopla ┆ 2 ┆ 6.1 ┆ 1270000 ┆ 208197 │\n", + "│ Zoopla ┆ 2 ┆ 6.1 ┆ 1270000 ┆ 208197 │\n", + "│ Zoopla ┆ 2 ┆ 6.1 ┆ 1270000 ┆ 208197 │\n", + "│ Rightmove ┆ 2 ┆ 6.8 ┆ 1400000 ┆ 205882 │\n", + "│ Zoopla ┆ 2 ┆ 6.1 ┆ 1250000 ┆ 204918 │\n", + "│ Rightmove ┆ 2 ┆ 7.2 ┆ 1250000 ┆ 173611 │\n", + "└───────────┴──────────┴────────────────────────┴──────────────┴──────────────────────┘" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fa = pl.col(\"Total floor area (sqm)\")\n", + "print(f\"Floor area null : {raw['Total floor area (sqm)'].null_count():,} \"\n", + " f\"({raw['Total floor area (sqm)'].null_count() / raw.height:.1%})\")\n", + "print(f\"Impossible (area<20 & beds>=2): {raw.filter((fa < 20) & (pl.col('Bedrooms') >= 2)).height:,}\")\n", + "print(f\"Suspiciously large (area>400) : {raw.filter(fa > 400).height:,}\")\n", + "print(f\"£/sqm > £30k : {raw.filter(pl.col('Asking price per sqm') > 30_000).height:,}\"\n", + " f\" (max = £{raw['Asking price per sqm'].max():,}/sqm)\")\n", + "raw.filter((fa < 20) & (pl.col(\"Bedrooms\") >= 2)).select(\n", + " \"provider\", \"Bedrooms\", \"Total floor area (sqm)\", \"Asking price\", \"Asking price per sqm\",\n", + ").sort(\"Asking price per sqm\", descending=True).head(6)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bc4faa65", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.165062Z", + "iopub.status.busy": "2026-06-03T07:34:31.164982Z", + "iopub.status.idle": "2026-06-03T07:34:31.550386Z", + "shell.execute_reply": "2026-06-03T07:34:31.550028Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 990x440 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Floor area vs bedrooms — red points are physically impossible (area < beds * 8 m²)\n", + "s = raw.filter(fa.is_not_null() & (fa < 160)).select(\"Bedrooms\", \"Total floor area (sqm)\")\n", + "rng = np.random.default_rng(0)\n", + "xb = s[\"Bedrooms\"].to_numpy().astype(float)\n", + "x = xb + (rng.random(s.height) - 0.5) * 0.35\n", + "y = s[\"Total floor area (sqm)\"].to_numpy()\n", + "impossible = y < np.maximum(10.0, xb * 8.0)\n", + "fig, ax = plt.subplots(figsize=(9, 4))\n", + "ax.scatter(x[~impossible], y[~impossible], s=4, alpha=0.15, color=\"#2563eb\", label=\"plausible\")\n", + "ax.scatter(x[impossible], y[impossible], s=14, alpha=0.8, color=\"red\", label=\"impossible (area < beds×8)\")\n", + "xs = np.linspace(0, x.max(), 60)\n", + "ax.plot(xs, np.maximum(10, xs * 8), \"k--\", lw=1, label=\"area = beds × 8 m²\")\n", + "ax.set_xlabel(\"Bedrooms\"); ax.set_ylabel(\"Total floor area (m²)\")\n", + "ax.set_title(\"Floor area vs bedrooms (≤160 m²)\"); ax.legend(fontsize=8)\n", + "plt.tight_layout(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d1a7f09b", + "metadata": {}, + "source": [ + "### 3.4 · 🔴/🟠 Zero bedrooms / bathrooms conflation\n", + "\n", + "`storage.py` maps missing **and** capped-implausible values to literal `0`, so `Bedrooms == 0` mixes\n", + "genuine studios, missing data, and capped outliers (e.g. a £29.9M 0-bed \"Detached\"). Same for bathrooms." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6c41b90f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.551560Z", + "iopub.status.busy": "2026-06-03T07:34:31.551429Z", + "iopub.status.idle": "2026-06-03T07:34:31.560471Z", + "shell.execute_reply": "2026-06-03T07:34:31.560043Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bedrooms == 0 : 5,495 of which Studio sub-type: 1,407\n", + "Bathrooms == 0: 6,448 with >=3 beds: 1,057\n" + ] + }, + { + "data": { + "text/html": [ + "<div><style>\n", + ".dataframe > thead > tr,\n", + ".dataframe > tbody > tr {\n", + " text-align: right;\n", + " white-space: pre-wrap;\n", + "}\n", + "</style>\n", + "<small>shape: (5, 8)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>provider</th><th>Property type</th><th>Property sub-type</th><th>Bedrooms</th><th>Bathrooms</th><th>Asking price</th><th>Total floor area (sqm)</th><th>Address per Property Register</th></tr><tr><td>str</td><td>str</td><td>str</td><td>i32</td><td>i32</td><td>i64</td><td>f64</td><td>str</td></tr></thead><tbody><tr><td>"OnTheMarket"</td><td>"Other"</td><td>"Land"</td><td>0</td><td>0</td><td>null</td><td>null</td><td>"Sutton Road, Hounslow, Greater London"</td></tr><tr><td>"Zoopla"</td><td>"Other"</td><td>"Property"</td><td>0</td><td>0</td><td>null</td><td>null</td><td>""</td></tr><tr><td>"Zoopla"</td><td>"Other"</td><td>"Property"</td><td>0</td><td>0</td><td>null</td><td>null</td><td>""</td></tr><tr><td>"Zoopla"</td><td>"Other"</td><td>"Property"</td><td>0</td><td>0</td><td>null</td><td>null</td><td>""</td></tr><tr><td>"Zoopla"</td><td>"Other"</td><td>"Property"</td><td>0</td><td>0</td><td>null</td><td>null</td><td>""</td></tr></tbody></table></div>" + ], + "text/plain": [ + "shape: (5, 8)\n", + "┌─────────────┬─────────────┬────────────┬──────────┬───────────┬────────┬────────────┬────────────┐\n", + "│ provider ┆ Property ┆ Property ┆ Bedrooms ┆ Bathrooms ┆ Asking ┆ Total ┆ Address │\n", + "│ --- ┆ type ┆ sub-type ┆ --- ┆ --- ┆ price ┆ floor area ┆ per │\n", + "│ str ┆ --- ┆ --- ┆ i32 ┆ i32 ┆ --- ┆ (sqm) ┆ Property │\n", + "│ ┆ str ┆ str ┆ ┆ ┆ i64 ┆ --- ┆ Register │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ --- │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ str │\n", + "╞═════════════╪═════════════╪════════════╪══════════╪═══════════╪════════╪════════════╪════════════╡\n", + "│ OnTheMarket ┆ Other ┆ Land ┆ 0 ┆ 0 ┆ null ┆ null ┆ Sutton │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ Road, │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ Hounslow, │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ Greater │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ London │\n", + "│ Zoopla ┆ Other ┆ Property ┆ 0 ┆ 0 ┆ null ┆ null ┆ │\n", + "│ Zoopla ┆ Other ┆ Property ┆ 0 ┆ 0 ┆ null ┆ null ┆ │\n", + "│ Zoopla ┆ Other ┆ Property ┆ 0 ┆ 0 ┆ null ┆ null ┆ │\n", + "│ Zoopla ┆ Other ┆ Property ┆ 0 ┆ 0 ┆ null ┆ null ┆ │\n", + "└─────────────┴─────────────┴────────────┴──────────┴───────────┴────────┴────────────┴────────────┘" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "zb = raw.filter(pl.col(\"Bedrooms\") == 0)\n", + "print(f\"Bedrooms == 0 : {zb.height:,} of which Studio sub-type: \"\n", + " f\"{zb.filter(pl.col('Property sub-type') == 'Studio').height:,}\")\n", + "print(f\"Bathrooms == 0: {raw.filter(pl.col('Bathrooms') == 0).height:,} with >=3 beds: \"\n", + " f\"{raw.filter((pl.col('Bathrooms') == 0) & (pl.col('Bedrooms') >= 3)).height:,}\")\n", + "zb.filter(pl.col(\"Property sub-type\") != \"Studio\").sort(\"Asking price\", descending=True).select(\n", + " \"provider\", \"Property type\", \"Property sub-type\", \"Bedrooms\", \"Bathrooms\",\n", + " \"Asking price\", \"Total floor area (sqm)\", \"Address per Property Register\",\n", + ").head(5)" + ] + }, + { + "cell_type": "markdown", + "id": "589d9960", + "metadata": {}, + "source": [ + "### 3.5 · 🟠 Geo & postcode precision\n", + "\n", + "- ~11% of rows have coordinates not confirmed by an address. **Outcode-only** rows (Zoopla) are pinned\n", + " to one arbitrary postcode per outcode and stamped with a plausible-looking *fake* unit postcode\n", + " (e.g. all SW6 listings → `SW6 1AA`).\n", + "- Development/building **centroid collisions**: many *distinct* properties share one exact coordinate." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3026540e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.561309Z", + "iopub.status.busy": "2026-06-03T07:34:31.561230Z", + "iopub.status.idle": "2026-06-03T07:34:31.574626Z", + "shell.execute_reply": "2026-06-03T07:34:31.574256Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "shape: (6, 2)\n", + "┌────────────────────┬────────┐\n", + "│ Postcode source ┆ count │\n", + "│ --- ┆ --- │\n", + "│ str ┆ u32 │\n", + "╞════════════════════╪════════╡\n", + "│ detail_address ┆ 100274 │\n", + "│ coordinates ┆ 8903 │\n", + "│ search_outcode ┆ 2748 │\n", + "│ detail_coordinates ┆ 564 │\n", + "│ address ┆ 102 │\n", + "│ address_outcode ┆ 14 │\n", + "└────────────────────┴────────┘\n", + "\n", + "Outcode-only rows: 2,762 -> distinct coordinates: 204 (one fake point per outcode)\n", + "Coordinates shared by >1 DISTINCT property: 8,122 points / 27,080 rows (max 44 distinct properties on one point)\n" + ] + } + ], + "source": [ + "print(raw[\"Postcode source\"].value_counts(sort=True))\n", + "oc = raw.filter(pl.col(\"Postcode source\").is_in([\"search_outcode\", \"address_outcode\"]))\n", + "print(f\"\\nOutcode-only rows: {oc.height:,} -> distinct coordinates: \"\n", + " f\"{oc.select(['lat', 'lon']).unique().height:,} (one fake point per outcode)\")\n", + "coll = (\n", + " raw.group_by([\"lat\", \"lon\"])\n", + " .agg(pl.struct(\"Asking price\", \"Bedrooms\").n_unique().alias(\"distinct_props\"), pl.len().alias(\"n\"))\n", + " .filter(pl.col(\"distinct_props\") > 1)\n", + ")\n", + "print(f\"Coordinates shared by >1 DISTINCT property: {coll.height:,} points / {coll['n'].sum():,} rows \"\n", + " f\"(max {coll['distinct_props'].max()} distinct properties on one point)\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1487ffb4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.575601Z", + "iopub.status.busy": "2026-06-03T07:34:31.575519Z", + "iopub.status.idle": "2026-06-03T07:34:31.709176Z", + "shell.execute_reply": "2026-06-03T07:34:31.708781Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 880x770 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Listings by provider (downsampled) — shows London footprint + centroid clusters\n", + "g = raw.sample(min(25_000, raw.height), seed=0).select(\"lat\", \"lon\", \"provider\")\n", + "colors = {\"Rightmove\": \"#2563eb\", \"OnTheMarket\": \"#16a34a\", \"Zoopla\": \"#dc2626\"}\n", + "fig, ax = plt.subplots(figsize=(8, 7))\n", + "for prov, c in colors.items():\n", + " gp = g.filter(pl.col(\"provider\") == prov)\n", + " ax.scatter(gp[\"lon\"], gp[\"lat\"], s=2, alpha=0.30, color=c, label=prov)\n", + "ax.set_xlabel(\"lon\"); ax.set_ylabel(\"lat\"); ax.set_aspect(\"equal\", adjustable=\"datalim\")\n", + "ax.set_title(\"Listing coordinates by provider (25k sample)\"); ax.legend(markerscale=4, fontsize=8)\n", + "plt.tight_layout(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6edd8876", + "metadata": {}, + "source": [ + "### 3.6 · 🔴 Duplicate listings\n", + "\n", + "No cross-source identity resolution: the same physical property appears across portals, and is\n", + "re-listed multiple times within a portal (especially Zoopla). `UPRN` (Zoopla-only, 1.8% coverage)\n", + "is not 1:1 — 405 UPRNs repeat up to 7×, breaking the intended exact EPC join." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bd1bf199", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.711042Z", + "iopub.status.busy": "2026-06-03T07:34:31.710934Z", + "iopub.status.idle": "2026-06-03T07:34:31.723397Z", + "shell.execute_reply": "2026-06-03T07:34:31.723059Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cross-portal duplicate groups : 2,589 -> 5,304 rows\n", + "Intra-portal re-list groups : 2,863 -> 3,261 extra rows\n", + "UPRN coverage: 2,060 (1.8%) distinct: 1,547 repeated UPRNs: 405 (max 7×)\n" + ] + } + ], + "source": [ + "key = [\"lat\", \"lon\", \"Asking price\", \"Bedrooms\"]\n", + "dups = (\n", + " raw.filter(pl.col(\"Asking price\").is_not_null())\n", + " .group_by(key)\n", + " .agg(pl.len().alias(\"n\"), pl.col(\"provider\").n_unique().alias(\"providers\"))\n", + ")\n", + "cross = dups.filter((pl.col(\"n\") > 1) & (pl.col(\"providers\") > 1))\n", + "intra = dups.filter((pl.col(\"n\") > 1) & (pl.col(\"providers\") == 1))\n", + "print(f\"Cross-portal duplicate groups : {cross.height:,} -> {cross['n'].sum():,} rows\")\n", + "print(f\"Intra-portal re-list groups : {intra.height:,} -> {(intra['n'] - 1).sum():,} extra rows\")\n", + "u = raw.filter(pl.col(\"UPRN\").is_not_null())\n", + "rep = u.group_by(\"UPRN\").len().filter(pl.col(\"len\") > 1)\n", + "print(f\"UPRN coverage: {u.height:,} ({u.height / raw.height:.1%}) distinct: {u['UPRN'].n_unique():,} \"\n", + " f\"repeated UPRNs: {rep.height:,} (max {rep['len'].max() if rep.height else 0}×)\")" + ] + }, + { + "cell_type": "markdown", + "id": "29057e83", + "metadata": {}, + "source": [ + "### 3.7 · 🟠/🟡 Categorical normalization & dead columns\n", + "\n", + "- `Listing status` is a constant `\"For sale\"` (dead column).\n", + "- `Property sub-type` has 79 values with portal-spelling variants (`Apartment`↔`Flat`, `X House`↔`X`, …).\n", + "- `Price qualifier` has case-only duplicate pairs (Rightmove TitleCase vs OTM sentence-case).\n", + "- Missing values are encoded inconsistently — empty-string in some columns, `null` in others." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "04084e7d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.724469Z", + "iopub.status.busy": "2026-06-03T07:34:31.724385Z", + "iopub.status.idle": "2026-06-03T07:34:31.743743Z", + "shell.execute_reply": "2026-06-03T07:34:31.743363Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Listing status distinct : ['For sale']\n", + "Property sub-type distinct: 79\n", + "\n", + "Price-qualifier values that differ only by casing:\n" + ] + }, + { + "data": { + "text/html": [ + "<div><style>\n", + ".dataframe > thead > tr,\n", + ".dataframe > tbody > tr {\n", + " text-align: right;\n", + " white-space: pre-wrap;\n", + "}\n", + "</style>\n", + "<small>shape: (6, 3)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>norm</th><th>variants</th><th>rows</th></tr><tr><td>str</td><td>u32</td><td>u32</td></tr></thead><tbody><tr><td>"guide price"</td><td>2</td><td>23851</td></tr><tr><td>"offers in excess of"</td><td>2</td><td>11832</td></tr><tr><td>"offers over"</td><td>2</td><td>3449</td></tr><tr><td>"offers in region of"</td><td>2</td><td>1963</td></tr><tr><td>"fixed price"</td><td>2</td><td>464</td></tr><tr><td>"shared equity"</td><td>2</td><td>7</td></tr></tbody></table></div>" + ], + "text/plain": [ + "shape: (6, 3)\n", + "┌─────────────────────┬──────────┬───────┐\n", + "│ norm ┆ variants ┆ rows │\n", + "│ --- ┆ --- ┆ --- │\n", + "│ str ┆ u32 ┆ u32 │\n", + "╞═════════════════════╪══════════╪═══════╡\n", + "│ guide price ┆ 2 ┆ 23851 │\n", + "│ offers in excess of ┆ 2 ┆ 11832 │\n", + "│ offers over ┆ 2 ┆ 3449 │\n", + "│ offers in region of ┆ 2 ┆ 1963 │\n", + "│ fixed price ┆ 2 ┆ 464 │\n", + "│ shared equity ┆ 2 ┆ 7 │\n", + "└─────────────────────┴──────────┴───────┘" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Empty-string counts in String columns:\n" + ] + }, + { + "data": { + "text/html": [ + "<div><style>\n", + ".dataframe > thead > tr,\n", + ".dataframe > tbody > tr {\n", + " text-align: right;\n", + " white-space: pre-wrap;\n", + "}\n", + "</style>\n", + "<small>shape: (1, 15)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>Postcode</th><th>Postcode source</th><th>Extracted postcode</th><th>Inferred postcode</th><th>Listing raw address</th><th>Address per Property Register</th><th>UPRN</th><th>Property number or name</th><th>Leasehold/Freehold</th><th>Property type</th><th>Property sub-type</th><th>Price qualifier</th><th>Listing URL</th><th>Listing status</th><th>provider</th></tr><tr><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td><td>u32</td></tr></thead><tbody><tr><td>0</td><td>0</td><td>0</td><td>0</td><td>2825</td><td>2837</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>69358</td><td>0</td><td>0</td><td>0</td></tr></tbody></table></div>" + ], + "text/plain": [ + "shape: (1, 15)\n", + "┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬────────┬───────┬───────┬───────┐\n", + "│ Pos ┆ Pos ┆ Ext ┆ Inf ┆ Lis ┆ Add ┆ UPR ┆ Pro ┆ Lea ┆ Pro ┆ Pro ┆ Price ┆ Listi ┆ Listi ┆ provi │\n", + "│ tco ┆ tco ┆ rac ┆ err ┆ tin ┆ res ┆ N ┆ per ┆ seh ┆ per ┆ per ┆ qualif ┆ ng ┆ ng ┆ der │\n", + "│ de ┆ de ┆ ted ┆ ed ┆ g ┆ s ┆ --- ┆ ty ┆ old ┆ ty ┆ ty ┆ ier ┆ URL ┆ statu ┆ --- │\n", + "│ --- ┆ sou ┆ pos ┆ pos ┆ raw ┆ per ┆ u32 ┆ num ┆ /Fr ┆ typ ┆ sub ┆ --- ┆ --- ┆ s ┆ u32 │\n", + "│ u32 ┆ rce ┆ tco ┆ tco ┆ add ┆ Pro ┆ ┆ ber ┆ eeh ┆ e ┆ -ty ┆ u32 ┆ u32 ┆ --- ┆ │\n", + "│ ┆ --- ┆ de ┆ de ┆ res ┆ per ┆ ┆ or ┆ old ┆ --- ┆ pe ┆ ┆ ┆ u32 ┆ │\n", + "│ ┆ u32 ┆ --- ┆ --- ┆ s ┆ ty ┆ ┆ nam ┆ --- ┆ u32 ┆ --- ┆ ┆ ┆ ┆ │\n", + "│ ┆ ┆ u32 ┆ u32 ┆ --- ┆ Reg ┆ ┆ e ┆ u32 ┆ ┆ u32 ┆ ┆ ┆ ┆ │\n", + "│ ┆ ┆ ┆ ┆ u32 ┆ ist ┆ ┆ --- ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ ┆ ┆ ┆ ┆ ┆ er ┆ ┆ u32 ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ ┆ ┆ ┆ ┆ ┆ --- ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ ┆ ┆ ┆ ┆ ┆ u32 ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "╞═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪════════╪═══════╪═══════╪═══════╡\n", + "│ 0 ┆ 0 ┆ 0 ┆ 0 ┆ 282 ┆ 283 ┆ 0 ┆ 0 ┆ 0 ┆ 0 ┆ 0 ┆ 69358 ┆ 0 ┆ 0 ┆ 0 │\n", + "│ ┆ ┆ ┆ ┆ 5 ┆ 7 ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴────────┴───────┴───────┴───────┘" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Listing status distinct :\", raw[\"Listing status\"].unique().to_list())\n", + "print(\"Property sub-type distinct:\", raw[\"Property sub-type\"].n_unique())\n", + "\n", + "pq = (\n", + " raw.filter(pl.col(\"Price qualifier\") != \"\")\n", + " .with_columns(pl.col(\"Price qualifier\").str.strip_chars().str.to_lowercase().alias(\"norm\"))\n", + " .group_by(\"norm\")\n", + " .agg(pl.col(\"Price qualifier\").n_unique().alias(\"variants\"), pl.len().alias(\"rows\"))\n", + " .filter(pl.col(\"variants\") > 1)\n", + " .sort(\"rows\", descending=True)\n", + ")\n", + "print(\"\\nPrice-qualifier values that differ only by casing:\")\n", + "display(pq)\n", + "\n", + "print(\"Empty-string counts in String columns:\")\n", + "display(raw.select([\n", + " (pl.col(c).str.strip_chars() == \"\").sum().alias(c)\n", + " for c in raw.columns if raw.schema[c] == pl.String\n", + "]))" + ] + }, + { + "cell_type": "markdown", + "id": "cda8c639", + "metadata": {}, + "source": [ + "### 3.8 · 🔴/🟡 Listing date\n", + "\n", + "`Listing date` is **null for 100% of OnTheMarket & Zoopla** (Rightmove-only `firstVisibleDate`), so any\n", + "recency analysis is biased to 82% of the data — and it reaches back to **2011** in a live for-sale set." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "df376178", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.744727Z", + "iopub.status.busy": "2026-06-03T07:34:31.744645Z", + "iopub.status.idle": "2026-06-03T07:34:31.753658Z", + "shell.execute_reply": "2026-06-03T07:34:31.753266Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "<div><style>\n", + ".dataframe > thead > tr,\n", + ".dataframe > tbody > tr {\n", + " text-align: right;\n", + " white-space: pre-wrap;\n", + "}\n", + "</style>\n", + "<small>shape: (3, 5)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>provider</th><th>rows</th><th>date_null</th><th>oldest</th><th>newest</th></tr><tr><td>str</td><td>u32</td><td>u32</td><td>datetime[μs]</td><td>datetime[μs]</td></tr></thead><tbody><tr><td>"OnTheMarket"</td><td>12771</td><td>12771</td><td>null</td><td>null</td></tr><tr><td>"Rightmove"</td><td>92797</td><td>0</td><td>2011-03-14 13:57:53</td><td>2026-05-31 02:38:38</td></tr><tr><td>"Zoopla"</td><td>7037</td><td>7037</td><td>null</td><td>null</td></tr></tbody></table></div>" + ], + "text/plain": [ + "shape: (3, 5)\n", + "┌─────────────┬───────┬───────────┬─────────────────────┬─────────────────────┐\n", + "│ provider ┆ rows ┆ date_null ┆ oldest ┆ newest │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ --- │\n", + "│ str ┆ u32 ┆ u32 ┆ datetime[μs] ┆ datetime[μs] │\n", + "╞═════════════╪═══════╪═══════════╪═════════════════════╪═════════════════════╡\n", + "│ OnTheMarket ┆ 12771 ┆ 12771 ┆ null ┆ null │\n", + "│ Rightmove ┆ 92797 ┆ 0 ┆ 2011-03-14 13:57:53 ┆ 2026-05-31 02:38:38 │\n", + "│ Zoopla ┆ 7037 ┆ 7037 ┆ null ┆ null │\n", + "└─────────────┴───────┴───────────┴─────────────────────┴─────────────────────┘" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Listings dated before 2024-01-01: 911\n" + ] + } + ], + "source": [ + "display(\n", + " raw.group_by(\"provider\").agg(\n", + " pl.len().alias(\"rows\"),\n", + " pl.col(\"Listing date\").null_count().alias(\"date_null\"),\n", + " pl.col(\"Listing date\").min().alias(\"oldest\"),\n", + " pl.col(\"Listing date\").max().alias(\"newest\"),\n", + " ).sort(\"provider\")\n", + ")\n", + "print(f\"Listings dated before 2024-01-01: \"\n", + " f\"{raw.filter(pl.col('Listing date') < pl.datetime(2024, 1, 1)).height:,}\")" + ] + }, + { + "cell_type": "markdown", + "id": "dd559a4a", + "metadata": {}, + "source": [ + "## 4 · Cleanup\n", + "\n", + "We build a cleaned frame `clean` that **fixes or flags** the issues above. Guiding principle: prefer\n", + "adding provenance/flag columns and nulling clearly-invalid values over fabricating data we don't have\n", + "(e.g. shared-ownership *full* prices and un-converted sq ft are **flagged**, not invented).\n", + "\n", + "**Reference tables** (canonicalisation / classification):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "12a191be", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.754641Z", + "iopub.status.busy": "2026-06-03T07:34:31.754556Z", + "iopub.status.idle": "2026-06-03T07:34:31.756985Z", + "shell.execute_reply": "2026-06-03T07:34:31.756603Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reference tables defined.\n" + ] + } + ], + "source": [ + "RESIDENTIAL_TYPES = [\"Flats/Maisonettes\", \"Terraced\", \"Detached\", \"Semi-Detached\"]\n", + "\n", + "# Collapse portal-specific sub-type spellings to one canonical label.\n", + "SUBTYPE_CANON = {\n", + " \"Apartment\": \"Flat\",\n", + " \"Terraced House\": \"Terraced\", \"End Of Terrace House\": \"End Of Terrace\", \"End Terrace\": \"End Of Terrace\",\n", + " \"Semi-Detached House\": \"Semi-Detached\", \"Semi Detached\": \"Semi-Detached\",\n", + " \"Semi Detached Bungalow\": \"Semi-Detached Bungalow\",\n", + " \"Detached House\": \"Detached\", \"Link Detached House\": \"Link Detached\",\n", + " \"Townhouse\": \"Town House\", \"Houseboat\": \"House Boat\",\n", + " \"Ground Floor Flat\": \"Ground Flat\", \"Ground Floor Maisonette\": \"Ground Maisonette\",\n", + " \"Block Of Flats\": \"Block Of Apartments\",\n", + " \"Property\": \"Unknown\", \"Not Specified\": \"Unknown\",\n", + "}\n", + "\n", + "# Sub-types that are not residential dwellings (canonical names).\n", + "NONRES_SUBTYPES = [\n", + " \"Land\", \"Plot\", \"Parking\", \"Garage\", \"Garages\", \"Office\", \"Retail\", \"Industrial\",\n", + " \"Light Industrial\", \"Warehouse\", \"Woodland\", \"Farm Land\", \"Mixed Use\",\n", + " \"Mixed Use Auction Lot\", \"Residential Development\", \"Block Of Apartments\",\n", + " \"Commercial\", \"Restaurant\", \"Unknown\",\n", + "]\n", + "\n", + "# Positional-confidence tier from the pipeline's Postcode source.\n", + "PRECISION = {\n", + " \"detail_address\": \"address-unit\", \"address\": \"address-unit\",\n", + " \"coordinates\": \"coordinate-nearest\", \"detail_coordinates\": \"coordinate-nearest\",\n", + " \"search_outcode\": \"outcode-only\", \"address_outcode\": \"outcode-only\",\n", + "}\n", + "print(\"Reference tables defined.\")" + ] + }, + { + "cell_type": "markdown", + "id": "2491e545", + "metadata": {}, + "source": [ + "**Step A** — drop dead/redundant columns, normalise empty-string → null, canonicalise `Price qualifier`, derive `price_basis` + `is_shared_ownership`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "241f8359", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.757767Z", + "iopub.status.busy": "2026-06-03T07:34:31.757691Z", + "iopub.status.idle": "2026-06-03T07:34:31.771814Z", + "shell.execute_reply": "2026-06-03T07:34:31.771466Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step A done. price_basis:\n" + ] + }, + { + "data": { + "text/html": [ + "<div><style>\n", + ".dataframe > thead > tr,\n", + ".dataframe > tbody > tr {\n", + " text-align: right;\n", + " white-space: pre-wrap;\n", + "}\n", + "</style>\n", + "<small>shape: (7, 2)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>price_basis</th><th>count</th></tr><tr><td>str</td><td>u32</td></tr></thead><tbody><tr><td>"firm"</td><td>69358</td></tr><tr><td>"auction_guide"</td><td>23851</td></tr><tr><td>"floor"</td><td>17258</td></tr><tr><td>"share"</td><td>1404</td></tr><tr><td>"other"</td><td>494</td></tr><tr><td>"from"</td><td>221</td></tr><tr><td>"unpriced"</td><td>19</td></tr></tbody></table></div>" + ], + "text/plain": [ + "shape: (7, 2)\n", + "┌───────────────┬───────┐\n", + "│ price_basis ┆ count │\n", + "│ --- ┆ --- │\n", + "│ str ┆ u32 │\n", + "╞═══════════════╪═══════╡\n", + "│ firm ┆ 69358 │\n", + "│ auction_guide ┆ 23851 │\n", + "│ floor ┆ 17258 │\n", + "│ share ┆ 1404 │\n", + "│ other ┆ 494 │\n", + "│ from ┆ 221 │\n", + "│ unpriced ┆ 19 │\n", + "└───────────────┴───────┘" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ql = pl.col(\"Price qualifier\").fill_null(\"\").str.to_lowercase().str.strip_chars()\n", + "\n", + "clean = (\n", + " raw\n", + " # \"Number of bedrooms & living rooms\" == Bedrooms+Bathrooms (no extra info) -> drop;\n", + " # \"Listing status\" is constant -> drop.\n", + " .drop([\"Listing status\", \"Number of bedrooms & living rooms\"])\n", + " .with_columns(\n", + " ql.str.contains(\"shared|part buy|part-buy\").alias(\"is_shared_ownership\"),\n", + " pl.when(ql.str.contains(\"shared|part buy|part-buy\")).then(pl.lit(\"share\"))\n", + " .when(ql.str.contains(\"offers in excess|offers over|offers in region|invited\")).then(pl.lit(\"floor\"))\n", + " .when(ql.str.contains(\"guide\")).then(pl.lit(\"auction_guide\"))\n", + " .when(ql == \"from\").then(pl.lit(\"from\"))\n", + " .when(ql.str.contains(\"application|coming soon\")).then(pl.lit(\"unpriced\"))\n", + " .when(ql == \"\").then(pl.lit(\"firm\"))\n", + " .otherwise(pl.lit(\"other\")).alias(\"price_basis\"),\n", + " )\n", + ")\n", + "\n", + "# Empty-string -> null for all String columns (except the derived enum price_basis).\n", + "str_cols = [c for c in clean.columns if clean.schema[c] == pl.String and c != \"price_basis\"]\n", + "clean = clean.with_columns([\n", + " pl.when(pl.col(c).str.strip_chars() == \"\").then(None).otherwise(pl.col(c)).alias(c)\n", + " for c in str_cols\n", + "])\n", + "\n", + "# Canonical casing for Price qualifier (drop comma variants, Title Case).\n", + "clean = clean.with_columns(\n", + " pl.when(pl.col(\"Price qualifier\").is_null()).then(None)\n", + " .otherwise(pl.col(\"Price qualifier\").str.replace_all(\",\", \"\").str.to_titlecase())\n", + " .alias(\"Price qualifier\")\n", + ")\n", + "print(\"Step A done. price_basis:\")\n", + "clean[\"price_basis\"].value_counts(sort=True)" + ] + }, + { + "cell_type": "markdown", + "id": "58767c84", + "metadata": {}, + "source": [ + "**Step B** — floor-area sanity (null impossibly-small, flag suspiciously-large) + recompute `Asking price per sqm` (excluding shared-ownership); null sentinel-`0` beds/baths for dwellings; canonicalise sub-types; add `is_residential`, `location_precision`; strip fake unit postcodes from outcode-only rows." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8e20392f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.772616Z", + "iopub.status.busy": "2026-06-03T07:34:31.772540Z", + "iopub.status.idle": "2026-06-03T07:34:31.783427Z", + "shell.execute_reply": "2026-06-03T07:34:31.783029Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step B done. clean shape: (112605, 30)\n", + "location_precision: [{'location_precision': 'address-unit', 'count': 100376}, {'location_precision': 'coordinate-nearest', 'count': 9467}, {'location_precision': 'outcode-only', 'count': 2762}]\n" + ] + } + ], + "source": [ + "fa = pl.col(\"Total floor area (sqm)\")\n", + "beds0 = pl.col(\"Bedrooms\").fill_null(0).cast(pl.Float64)\n", + "# Beds-aware floor: a dwelling needs ~10 m² per bedroom (min 12 m²). Anything below this is a\n", + "# single-room dimension mis-parsed as the total (a 2-bed < 20 m² is physically impossible).\n", + "min_plausible_area = pl.max_horizontal(pl.lit(12.0), beds0 * 10.0)\n", + "\n", + "clean = clean.with_columns(\n", + " (fa.is_not_null() & (fa < min_plausible_area)).alias(\"floor_area_suspect_small\"),\n", + " (fa.is_not_null() & (fa > 400)).alias(\"floor_area_suspect_large\"),\n", + ")\n", + "# Null impossibly-small areas (single-room dims parsed as total).\n", + "clean = clean.with_columns(\n", + " pl.when(pl.col(\"floor_area_suspect_small\")).then(None).otherwise(fa).alias(\"Total floor area (sqm)\")\n", + ")\n", + "\n", + "# Canonical sub-types + residential / build-type flags.\n", + "clean = clean.with_columns(pl.col(\"Property sub-type\").replace(SUBTYPE_CANON).alias(\"Property sub-type\"))\n", + "clean = clean.with_columns(\n", + " (~pl.col(\"Property sub-type\").is_in(NONRES_SUBTYPES)).alias(\"is_residential\"),\n", + " (pl.col(\"Property sub-type\") == \"House\").alias(\"build_type_unspecified\"), # was wrongly forced to 'Detached'\n", + ")\n", + "\n", + "# Sentinel 0 -> null for beds/baths on real dwellings (keep 0 for genuine Studios).\n", + "is_dwelling = pl.col(\"Property type\").is_in(RESIDENTIAL_TYPES)\n", + "is_studio = pl.col(\"Property sub-type\") == \"Studio\"\n", + "clean = clean.with_columns(\n", + " pl.when((pl.col(\"Bedrooms\") == 0) & is_dwelling & ~is_studio).then(None)\n", + " .otherwise(pl.col(\"Bedrooms\")).alias(\"Bedrooms\"),\n", + " pl.when((pl.col(\"Bathrooms\") == 0) & is_dwelling).then(None)\n", + " .otherwise(pl.col(\"Bathrooms\")).alias(\"Bathrooms\"),\n", + ")\n", + "\n", + "# Recompute £/sqm from cleaned area; undefined for shared-ownership (share price) & missing inputs.\n", + "clean = clean.with_columns(\n", + " pl.when(\n", + " pl.col(\"Total floor area (sqm)\").is_not_null()\n", + " & pl.col(\"Asking price\").is_not_null()\n", + " & ~pl.col(\"is_shared_ownership\")\n", + " )\n", + " .then((pl.col(\"Asking price\") / pl.col(\"Total floor area (sqm)\")).round().cast(pl.Int64))\n", + " .otherwise(None)\n", + " .alias(\"Asking price per sqm\")\n", + ")\n", + "\n", + "# Positional-confidence tier; strip the fabricated unit from outcode-only postcodes.\n", + "clean = clean.with_columns(\n", + " pl.col(\"Postcode source\").replace_strict(PRECISION, default=\"unknown\").alias(\"location_precision\")\n", + ")\n", + "clean = clean.with_columns(\n", + " pl.when(pl.col(\"location_precision\") == \"outcode-only\")\n", + " .then(pl.col(\"Postcode\").str.split(\" \").list.first())\n", + " .otherwise(pl.col(\"Postcode\"))\n", + " .alias(\"Postcode\")\n", + ")\n", + "print(f\"Step B done. clean shape: {clean.shape}\")\n", + "print(\"location_precision:\", clean[\"location_precision\"].value_counts(sort=True).to_dicts())" + ] + }, + { + "cell_type": "markdown", + "id": "33e81cf5", + "metadata": {}, + "source": [ + "**Step C** — de-duplicate to one row per physical property. Heuristic key: `(lat, lon, Asking price, Bedrooms)`, keeping the most-recently-listed row. This collapses both cross-portal and intra-portal duplicates; `raw` is retained for provenance." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ac920525", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.784400Z", + "iopub.status.busy": "2026-06-03T07:34:31.784318Z", + "iopub.status.idle": "2026-06-03T07:34:31.829788Z", + "shell.execute_reply": "2026-06-03T07:34:31.829419Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "De-duplicated: 112,605 -> 106,511 rows (removed 6,094, 5.4%)\n" + ] + }, + { + "data": { + "text/html": [ + "<div><style>\n", + ".dataframe > thead > tr,\n", + ".dataframe > tbody > tr {\n", + " text-align: right;\n", + " white-space: pre-wrap;\n", + "}\n", + "</style>\n", + "<small>shape: (3, 3)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>provider</th><th>clean</th><th>dedup</th></tr><tr><td>str</td><td>u32</td><td>u32</td></tr></thead><tbody><tr><td>"OnTheMarket"</td><td>12771</td><td>9949</td></tr><tr><td>"Rightmove"</td><td>92797</td><td>91064</td></tr><tr><td>"Zoopla"</td><td>7037</td><td>5498</td></tr></tbody></table></div>" + ], + "text/plain": [ + "shape: (3, 3)\n", + "┌─────────────┬───────┬───────┐\n", + "│ provider ┆ clean ┆ dedup │\n", + "│ --- ┆ --- ┆ --- │\n", + "│ str ┆ u32 ┆ u32 │\n", + "╞═════════════╪═══════╪═══════╡\n", + "│ OnTheMarket ┆ 12771 ┆ 9949 │\n", + "│ Rightmove ┆ 92797 ┆ 91064 │\n", + "│ Zoopla ┆ 7037 ┆ 5498 │\n", + "└─────────────┴───────┴───────┘" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dedup = (\n", + " clean\n", + " .sort(\"Listing date\", descending=True, nulls_last=True)\n", + " .unique(subset=[\"lat\", \"lon\", \"Asking price\", \"Bedrooms\"], keep=\"first\", maintain_order=True)\n", + ")\n", + "removed = clean.height - dedup.height\n", + "print(f\"De-duplicated: {clean.height:,} -> {dedup.height:,} rows (removed {removed:,}, {removed / clean.height:.1%})\")\n", + "display(\n", + " pl.concat([\n", + " clean.group_by(\"provider\").len().rename({\"len\": \"clean\"}),\n", + " dedup.group_by(\"provider\").len().rename({\"len\": \"dedup\"}),\n", + " ], how=\"align\").sort(\"provider\")\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "7d17dd05", + "metadata": {}, + "source": [ + "## 5 · After cleanup — re-show the stats" + ] + }, + { + "cell_type": "markdown", + "id": "b10a9386", + "metadata": {}, + "source": [ + "**Before / after summary** of the headline issues:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "df564e2b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.830811Z", + "iopub.status.busy": "2026-06-03T07:34:31.830735Z", + "iopub.status.idle": "2026-06-03T07:34:31.932037Z", + "shell.execute_reply": "2026-06-03T07:34:31.931618Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "<div><style>\n", + ".dataframe > thead > tr,\n", + ".dataframe > tbody > tr {\n", + " text-align: right;\n", + " white-space: pre-wrap;\n", + "}\n", + "</style>\n", + "<small>shape: (3, 9)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>dataset</th><th>rows</th><th>impossible_tiny_area</th><th>pqualifier_casing_dupes</th><th>empty_string_cells</th><th>max_£/sqm</th><th>subtype_distinct</th><th>zero_bed_non_studio</th><th>dead_columns</th></tr><tr><td>str</td><td>i64</td><td>i64</td><td>i64</td><td>i64</td><td>i64</td><td>i64</td><td>i64</td><td>i64</td></tr></thead><tbody><tr><td>"raw"</td><td>112605</td><td>89</td><td>6</td><td>75020</td><td>410959</td><td>79</td><td>4088</td><td>2</td></tr><tr><td>"clean"</td><td>112605</td><td>0</td><td>0</td><td>0</td><td>212963</td><td>63</td><td>934</td><td>0</td></tr><tr><td>"dedup"</td><td>106511</td><td>0</td><td>0</td><td>0</td><td>212963</td><td>63</td><td>711</td><td>0</td></tr></tbody></table></div>" + ], + "text/plain": [ + "shape: (3, 9)\n", + "┌─────────┬────────┬───────────┬───────────┬───────────┬──────────┬──────────┬──────────┬──────────┐\n", + "│ dataset ┆ rows ┆ impossibl ┆ pqualifie ┆ empty_str ┆ max_£/sq ┆ subtype_ ┆ zero_bed ┆ dead_col │\n", + "│ --- ┆ --- ┆ e_tiny_ar ┆ r_casing_ ┆ ing_cells ┆ m ┆ distinct ┆ _non_stu ┆ umns │\n", + "│ str ┆ i64 ┆ ea ┆ dupes ┆ --- ┆ --- ┆ --- ┆ dio ┆ --- │\n", + "│ ┆ ┆ --- ┆ --- ┆ i64 ┆ i64 ┆ i64 ┆ --- ┆ i64 │\n", + "│ ┆ ┆ i64 ┆ i64 ┆ ┆ ┆ ┆ i64 ┆ │\n", + "╞═════════╪════════╪═══════════╪═══════════╪═══════════╪══════════╪══════════╪══════════╪══════════╡\n", + "│ raw ┆ 112605 ┆ 89 ┆ 6 ┆ 75020 ┆ 410959 ┆ 79 ┆ 4088 ┆ 2 │\n", + "│ clean ┆ 112605 ┆ 0 ┆ 0 ┆ 0 ┆ 212963 ┆ 63 ┆ 934 ┆ 0 │\n", + "│ dedup ┆ 106511 ┆ 0 ┆ 0 ┆ 0 ┆ 212963 ┆ 63 ┆ 711 ┆ 0 │\n", + "└─────────┴────────┴───────────┴───────────┴───────────┴──────────┴──────────┴──────────┴──────────┘" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def diagnostics(d: pl.DataFrame, label: str) -> dict:\n", + " fa = pl.col(\"Total floor area (sqm)\")\n", + " pq_casing = (\n", + " d.filter(pl.col(\"Price qualifier\").is_not_null())\n", + " .with_columns(pl.col(\"Price qualifier\").str.to_lowercase().alias(\"n\"))\n", + " .group_by(\"n\").agg(pl.col(\"Price qualifier\").n_unique().alias(\"v\"))\n", + " .filter(pl.col(\"v\") > 1).height\n", + " )\n", + " empties = sum(\n", + " d.select((pl.col(c).str.strip_chars() == \"\").sum()).item()\n", + " for c in d.columns if d.schema[c] == pl.String\n", + " )\n", + " return {\n", + " \"dataset\": label,\n", + " \"rows\": d.height,\n", + " \"impossible_tiny_area\": d.filter(fa.is_not_null() & (fa < 20) & (pl.col(\"Bedrooms\").fill_null(0) >= 2)).height,\n", + " \"pqualifier_casing_dupes\": pq_casing,\n", + " \"empty_string_cells\": int(empties),\n", + " \"max_£/sqm\": d[\"Asking price per sqm\"].max(),\n", + " \"subtype_distinct\": d[\"Property sub-type\"].n_unique(),\n", + " \"zero_bed_non_studio\": d.filter((pl.col(\"Bedrooms\") == 0) & (pl.col(\"Property sub-type\") != \"Studio\")).height,\n", + " \"dead_columns\": int(\"Listing status\" in d.columns) + int(\"Number of bedrooms & living rooms\" in d.columns),\n", + " }\n", + "\n", + "pl.DataFrame([diagnostics(raw, \"raw\"), diagnostics(clean, \"clean\"), diagnostics(dedup, \"dedup\")])" + ] + }, + { + "cell_type": "markdown", + "id": "8afe0492", + "metadata": {}, + "source": [ + "**Schema after cleanup** (dropped 2 mislabeled/dead columns; added flags & provenance):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0688cda7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.933084Z", + "iopub.status.busy": "2026-06-03T07:34:31.933005Z", + "iopub.status.idle": "2026-06-03T07:34:31.935851Z", + "shell.execute_reply": "2026-06-03T07:34:31.935570Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Added columns : ['is_shared_ownership', 'price_basis', 'floor_area_suspect_small', 'floor_area_suspect_large', 'is_residential', 'build_type_unspecified', 'location_precision']\n", + "Dropped columns: ['Number of bedrooms & living rooms', 'Listing status']\n" + ] + }, + { + "data": { + "text/html": [ + "<div><style>\n", + ".dataframe > thead > tr,\n", + ".dataframe > tbody > tr {\n", + " text-align: right;\n", + " white-space: pre-wrap;\n", + "}\n", + "</style>\n", + "<small>shape: (30, 2)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>column</th><th>dtype</th></tr><tr><td>str</td><td>str</td></tr></thead><tbody><tr><td>"Bedrooms"</td><td>"Int32"</td></tr><tr><td>"Bathrooms"</td><td>"Int32"</td></tr><tr><td>"lon"</td><td>"Float64"</td></tr><tr><td>"lat"</td><td>"Float64"</td></tr><tr><td>"Postcode"</td><td>"String"</td></tr><tr><td>"Postcode source"</td><td>"String"</td></tr><tr><td>"Extracted postcode"</td><td>"String"</td></tr><tr><td>"Inferred postcode"</td><td>"String"</td></tr><tr><td>"Listing raw address"</td><td>"String"</td></tr><tr><td>"Address per Property Register"</td><td>"String"</td></tr><tr><td>"UPRN"</td><td>"String"</td></tr><tr><td>"Property number or name"</td><td>"String"</td></tr><tr><td>"Leasehold/Freehold"</td><td>"String"</td></tr><tr><td>"Property type"</td><td>"String"</td></tr><tr><td>"Property sub-type"</td><td>"String"</td></tr><tr><td>"Price qualifier"</td><td>"String"</td></tr><tr><td>"Total floor area (sqm)"</td><td>"Float64"</td></tr><tr><td>"Listing URL"</td><td>"String"</td></tr><tr><td>"Listing features"</td><td>"List(String)"</td></tr><tr><td>"Listing date"</td><td>"Datetime(time_unit='us', time_zone=None)"</td></tr><tr><td>"Asking price"</td><td>"Int64"</td></tr><tr><td>"Asking price per sqm"</td><td>"Int64"</td></tr><tr><td>"provider"</td><td>"String"</td></tr><tr><td>"is_shared_ownership"</td><td>"Boolean"</td></tr><tr><td>"price_basis"</td><td>"String"</td></tr><tr><td>"floor_area_suspect_small"</td><td>"Boolean"</td></tr><tr><td>"floor_area_suspect_large"</td><td>"Boolean"</td></tr><tr><td>"is_residential"</td><td>"Boolean"</td></tr><tr><td>"build_type_unspecified"</td><td>"Boolean"</td></tr><tr><td>"location_precision"</td><td>"String"</td></tr></tbody></table></div>" + ], + "text/plain": [ + "shape: (30, 2)\n", + "┌───────────────────────────────┬──────────────────────────────────────────┐\n", + "│ column ┆ dtype │\n", + "│ --- ┆ --- │\n", + "│ str ┆ str │\n", + "╞═══════════════════════════════╪══════════════════════════════════════════╡\n", + "│ Bedrooms ┆ Int32 │\n", + "│ Bathrooms ┆ Int32 │\n", + "│ lon ┆ Float64 │\n", + "│ lat ┆ Float64 │\n", + "│ Postcode ┆ String │\n", + "│ Postcode source ┆ String │\n", + "│ Extracted postcode ┆ String │\n", + "│ Inferred postcode ┆ String │\n", + "│ Listing raw address ┆ String │\n", + "│ Address per Property Register ┆ String │\n", + "│ UPRN ┆ String │\n", + "│ Property number or name ┆ String │\n", + "│ Leasehold/Freehold ┆ String │\n", + "│ Property type ┆ String │\n", + "│ Property sub-type ┆ String │\n", + "│ Price qualifier ┆ String │\n", + "│ Total floor area (sqm) ┆ Float64 │\n", + "│ Listing URL ┆ String │\n", + "│ Listing features ┆ List(String) │\n", + "│ Listing date ┆ Datetime(time_unit='us', time_zone=None) │\n", + "│ Asking price ┆ Int64 │\n", + "│ Asking price per sqm ┆ Int64 │\n", + "│ provider ┆ String │\n", + "│ is_shared_ownership ┆ Boolean │\n", + "│ price_basis ┆ String │\n", + "│ floor_area_suspect_small ┆ Boolean │\n", + "│ floor_area_suspect_large ┆ Boolean │\n", + "│ is_residential ┆ Boolean │\n", + "│ build_type_unspecified ┆ Boolean │\n", + "│ location_precision ┆ String │\n", + "└───────────────────────────────┴──────────────────────────────────────────┘" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "added = [c for c in clean.columns if c not in raw.columns]\n", + "dropped = [c for c in raw.columns if c not in clean.columns]\n", + "print(\"Added columns :\", added)\n", + "print(\"Dropped columns:\", dropped)\n", + "pl.DataFrame({\"column\": clean.columns, \"dtype\": [str(t) for t in clean.dtypes]})" + ] + }, + { + "cell_type": "markdown", + "id": "0a16d168", + "metadata": {}, + "source": [ + "**Missingness after cleanup** — beds/baths now legitimately null where unknown; empty-strings gone; per-sqm follows cleaned area:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cfe2fc79", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.936668Z", + "iopub.status.busy": "2026-06-03T07:34:31.936597Z", + "iopub.status.idle": "2026-06-03T07:34:31.950929Z", + "shell.execute_reply": "2026-06-03T07:34:31.950552Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "<div><style>\n", + ".dataframe > thead > tr,\n", + ".dataframe > tbody > tr {\n", + " text-align: right;\n", + " white-space: pre-wrap;\n", + "}\n", + "</style>\n", + "<small>shape: (3, 30)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>provider</th><th>Bedrooms</th><th>Bathrooms</th><th>lon</th><th>lat</th><th>Postcode</th><th>Postcode source</th><th>Extracted postcode</th><th>Inferred postcode</th><th>Listing raw address</th><th>Address per Property Register</th><th>UPRN</th><th>Property number or name</th><th>Leasehold/Freehold</th><th>Property type</th><th>Property sub-type</th><th>Price qualifier</th><th>Total floor area (sqm)</th><th>Listing URL</th><th>Listing features</th><th>Listing date</th><th>Asking price</th><th>Asking price per sqm</th><th>is_shared_ownership</th><th>price_basis</th><th>floor_area_suspect_small</th><th>floor_area_suspect_large</th><th>is_residential</th><th>build_type_unspecified</th><th>location_precision</th></tr><tr><td>str</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td></tr></thead><tbody><tr><td>"OnTheMarket"</td><td>0.2</td><td>5.1</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>95.9</td><td>0.0</td><td>0.0</td><td>0.1</td><td>100.0</td><td>100.0</td><td>11.2</td><td>0.0</td><td>0.0</td><td>60.9</td><td>87.0</td><td>0.0</td><td>0.0</td><td>100.0</td><td>0.1</td><td>87.5</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>"Rightmove"</td><td>0.8</td><td>2.4</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>95.1</td><td>0.0</td><td>0.0</td><td>0.0</td><td>100.0</td><td>100.0</td><td>14.2</td><td>0.0</td><td>0.0</td><td>58.8</td><td>46.9</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>47.1</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>"Zoopla"</td><td>33.7</td><td>36.1</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>100.0</td><td>0.0</td><td>40.1</td><td>40.2</td><td>70.7</td><td>61.5</td><td>50.2</td><td>0.0</td><td>0.0</td><td>100.0</td><td>17.0</td><td>0.0</td><td>0.0</td><td>100.0</td><td>4.9</td><td>17.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr></tbody></table></div>" + ], + "text/plain": [ + "shape: (3, 30)\n", + "┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐\n", + "│ pro ┆ Bed ┆ Bat ┆ lon ┆ lat ┆ Pos ┆ Pos ┆ Ext ┆ Inf ┆ Lis ┆ Add ┆ UPR ┆ Pro ┆ Lea ┆ Pro ┆ Pro ┆ Pri ┆ Tot ┆ Lis ┆ Lis ┆ Lis ┆ Ask ┆ Ask ┆ is_ ┆ pri ┆ flo ┆ flo ┆ is_ ┆ bui ┆ loc │\n", + "│ vid ┆ roo ┆ hro ┆ --- ┆ --- ┆ tco ┆ tco ┆ rac ┆ err ┆ tin ┆ res ┆ N ┆ per ┆ seh ┆ per ┆ per ┆ ce ┆ al ┆ tin ┆ tin ┆ tin ┆ ing ┆ ing ┆ sha ┆ ce_ ┆ or_ ┆ or_ ┆ res ┆ ld_ ┆ ati │\n", + "│ er ┆ ms ┆ oms ┆ f64 ┆ f64 ┆ de ┆ de ┆ ted ┆ ed ┆ g ┆ s ┆ --- ┆ ty ┆ old ┆ ty ┆ ty ┆ qua ┆ flo ┆ g ┆ g ┆ g ┆ pri ┆ pri ┆ red ┆ bas ┆ are ┆ are ┆ ide ┆ typ ┆ on_ │\n", + "│ --- ┆ --- ┆ --- ┆ ┆ ┆ --- ┆ sou ┆ pos ┆ pos ┆ raw ┆ per ┆ f64 ┆ num ┆ /Fr ┆ typ ┆ sub ┆ lif ┆ or ┆ URL ┆ fea ┆ dat ┆ ce ┆ ce ┆ _ow ┆ is ┆ a_s ┆ a_s ┆ nti ┆ e_u ┆ pre │\n", + "│ str ┆ f64 ┆ f64 ┆ ┆ ┆ f64 ┆ rce ┆ tco ┆ tco ┆ add ┆ Pro ┆ ┆ ber ┆ eeh ┆ e ┆ -ty ┆ ier ┆ are ┆ --- ┆ tur ┆ e ┆ --- ┆ per ┆ ner ┆ --- ┆ usp ┆ usp ┆ al ┆ nsp ┆ cis │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ --- ┆ de ┆ de ┆ res ┆ per ┆ ┆ or ┆ old ┆ --- ┆ pe ┆ --- ┆ a ┆ f64 ┆ es ┆ --- ┆ f64 ┆ sqm ┆ shi ┆ f64 ┆ ect ┆ ect ┆ --- ┆ eci ┆ ion │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ --- ┆ --- ┆ s ┆ ty ┆ ┆ nam ┆ --- ┆ f64 ┆ --- ┆ f64 ┆ (sq ┆ ┆ --- ┆ f64 ┆ ┆ --- ┆ p ┆ ┆ _sm ┆ _la ┆ f64 ┆ fie ┆ --- │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ f64 ┆ --- ┆ Reg ┆ ┆ e ┆ f64 ┆ ┆ f64 ┆ ┆ m) ┆ ┆ f64 ┆ ┆ ┆ f64 ┆ --- ┆ ┆ all ┆ rge ┆ ┆ d ┆ f64 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ ist ┆ ┆ --- ┆ ┆ ┆ ┆ ┆ --- ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ ┆ --- ┆ --- ┆ ┆ --- ┆ │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ er ┆ ┆ f64 ┆ ┆ ┆ ┆ ┆ f64 ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ f64 ┆ ┆ f64 ┆ │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ --- ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "╞═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╪═════╡\n", + "│ OnT ┆ 0.2 ┆ 5.1 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 95. ┆ 0.0 ┆ 0.0 ┆ 0.1 ┆ 100 ┆ 100 ┆ 11. ┆ 0.0 ┆ 0.0 ┆ 60. ┆ 87. ┆ 0.0 ┆ 0.0 ┆ 100 ┆ 0.1 ┆ 87. ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 │\n", + "│ heM ┆ ┆ ┆ ┆ ┆ ┆ ┆ 9 ┆ ┆ ┆ ┆ .0 ┆ .0 ┆ 2 ┆ ┆ ┆ 9 ┆ 0 ┆ ┆ ┆ .0 ┆ ┆ 5 ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ ark ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ et ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ Rig ┆ 0.8 ┆ 2.4 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 95. ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 100 ┆ 100 ┆ 14. ┆ 0.0 ┆ 0.0 ┆ 58. ┆ 46. ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 47. ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 │\n", + "│ htm ┆ ┆ ┆ ┆ ┆ ┆ ┆ 1 ┆ ┆ ┆ ┆ .0 ┆ .0 ┆ 2 ┆ ┆ ┆ 8 ┆ 9 ┆ ┆ ┆ ┆ ┆ 1 ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ ove ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ Zoo ┆ 33. ┆ 36. ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 100 ┆ 0.0 ┆ 40. ┆ 40. ┆ 70. ┆ 61. ┆ 50. ┆ 0.0 ┆ 0.0 ┆ 100 ┆ 17. ┆ 0.0 ┆ 0.0 ┆ 100 ┆ 4.9 ┆ 17. ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 ┆ 0.0 │\n", + "│ pla ┆ 7 ┆ 1 ┆ ┆ ┆ ┆ ┆ .0 ┆ ┆ 1 ┆ 2 ┆ 7 ┆ 5 ┆ 2 ┆ ┆ ┆ .0 ┆ 0 ┆ ┆ ┆ .0 ┆ ┆ 0 ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "value_cols_c = [c for c in clean.columns if c != \"provider\"]\n", + "miss_c = (\n", + " clean.group_by(\"provider\")\n", + " .agg([missing_count(c, clean.schema[c]) for c in value_cols_c] + [pl.len().alias(\"__rows\")])\n", + " .sort(\"provider\")\n", + ")\n", + "miss_c.select([\"provider\"] + [(pl.col(c) / pl.col(\"__rows\") * 100).round(1).alias(c) for c in value_cols_c])" + ] + }, + { + "cell_type": "markdown", + "id": "9f0b901b", + "metadata": {}, + "source": [ + "**Price / floor-area sanity restored** (firm-price view excludes shared-ownership):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad59e2d6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.952084Z", + "iopub.status.busy": "2026-06-03T07:34:31.951936Z", + "iopub.status.idle": "2026-06-03T07:34:31.967287Z", + "shell.execute_reply": "2026-06-03T07:34:31.966952Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Residential, non-shared rows: 109,662\n", + "Impossible tiny areas remaining (area<20 & beds>=2): 0\n", + "Max £/sqm raw 410,959 -> clean 212,963\n" + ] + }, + { + "data": { + "text/html": [ + "<div><style>\n", + ".dataframe > thead > tr,\n", + ".dataframe > tbody > tr {\n", + " text-align: right;\n", + " white-space: pre-wrap;\n", + "}\n", + "</style>\n", + "<small>shape: (9, 4)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>statistic</th><th>Asking price</th><th>Total floor area (sqm)</th><th>Asking price per sqm</th></tr><tr><td>str</td><td>f64</td><td>f64</td><td>f64</td></tr></thead><tbody><tr><td>"count"</td><td>109645.0</td><td>56075.0</td><td>56075.0</td></tr><tr><td>"null_count"</td><td>17.0</td><td>53587.0</td><td>53587.0</td></tr><tr><td>"mean"</td><td>924734.079256</td><td>113.391677</td><td>9186.075381</td></tr><tr><td>"std"</td><td>1.5915e6</td><td>106.075279</td><td>6356.803435</td></tr><tr><td>"min"</td><td>500.0</td><td>12.4</td><td>35.0</td></tr><tr><td>"25%"</td><td>375000.0</td><td>60.0</td><td>5644.0</td></tr><tr><td>"50%"</td><td>550000.0</td><td>82.0</td><td>7317.0</td></tr><tr><td>"75%"</td><td>875000.0</td><td>126.1</td><td>10496.0</td></tr><tr><td>"max"</td><td>1e8</td><td>1893.1</td><td>212963.0</td></tr></tbody></table></div>" + ], + "text/plain": [ + "shape: (9, 4)\n", + "┌────────────┬───────────────┬────────────────────────┬──────────────────────┐\n", + "│ statistic ┆ Asking price ┆ Total floor area (sqm) ┆ Asking price per sqm │\n", + "│ --- ┆ --- ┆ --- ┆ --- │\n", + "│ str ┆ f64 ┆ f64 ┆ f64 │\n", + "╞════════════╪═══════════════╪════════════════════════╪══════════════════════╡\n", + "│ count ┆ 109645.0 ┆ 56075.0 ┆ 56075.0 │\n", + "│ null_count ┆ 17.0 ┆ 53587.0 ┆ 53587.0 │\n", + "│ mean ┆ 924734.079256 ┆ 113.391677 ┆ 9186.075381 │\n", + "│ std ┆ 1.5915e6 ┆ 106.075279 ┆ 6356.803435 │\n", + "│ min ┆ 500.0 ┆ 12.4 ┆ 35.0 │\n", + "│ 25% ┆ 375000.0 ┆ 60.0 ┆ 5644.0 │\n", + "│ 50% ┆ 550000.0 ┆ 82.0 ┆ 7317.0 │\n", + "│ 75% ┆ 875000.0 ┆ 126.1 ┆ 10496.0 │\n", + "│ max ┆ 1e8 ┆ 1893.1 ┆ 212963.0 │\n", + "└────────────┴───────────────┴────────────────────────┴──────────────────────┘" ] }, "metadata": {}, @@ -296,35 +1872,23 @@ " white-space: pre-wrap;\n", "}\n", "</style>\n", - "<small>shape: (19, 5)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>provider</th><th>column</th><th>na_count</th><th>provider_rows</th><th>na_pct</th></tr><tr><td>str</td><td>str</td><td>u32</td><td>u32</td><td>f64</td></tr></thead><tbody><tr><td>"OnTheMarket"</td><td>"Listing date"</td><td>85</td><td>85</td><td>100.0</td></tr><tr><td>"OnTheMarket"</td><td>"Property number or name"</td><td>85</td><td>85</td><td>100.0</td></tr><tr><td>"OnTheMarket"</td><td>"UPRN"</td><td>85</td><td>85</td><td>100.0</td></tr><tr><td>"OnTheMarket"</td><td>"Extracted postcode"</td><td>84</td><td>85</td><td>98.82</td></tr><tr><td>"OnTheMarket"</td><td>"Asking price per sqm"</td><td>82</td><td>85</td><td>96.47</td></tr><tr><td>"OnTheMarket"</td><td>"Total floor area (sqm)"</td><td>82</td><td>85</td><td>96.47</td></tr><tr><td>"Rightmove"</td><td>"Property number or name"</td><td>99</td><td>99</td><td>100.0</td></tr><tr><td>"Rightmove"</td><td>"UPRN"</td><td>99</td><td>99</td><td>100.0</td></tr><tr><td>"Rightmove"</td><td>"Extracted postcode"</td><td>98</td><td>99</td><td>98.99</td></tr><tr><td>"Rightmove"</td><td>"Asking price per sqm"</td><td>34</td><td>99</td><td>34.34</td></tr><tr><td>"Rightmove"</td><td>"Total floor area (sqm)"</td><td>34</td><td>99</td><td>34.34</td></tr><tr><td>"Rightmove"</td><td>"Leasehold/Freehold"</td><td>17</td><td>99</td><td>17.17</td></tr><tr><td>"Zoopla"</td><td>"Extracted postcode"</td><td>58</td><td>58</td><td>100.0</td></tr><tr><td>"Zoopla"</td><td>"Listing date"</td><td>58</td><td>58</td><td>100.0</td></tr><tr><td>"Zoopla"</td><td>"UPRN"</td><td>25</td><td>58</td><td>43.1</td></tr><tr><td>"Zoopla"</td><td>"Leasehold/Freehold"</td><td>14</td><td>58</td><td>24.14</td></tr><tr><td>"Zoopla"</td><td>"Property number or name"</td><td>11</td><td>58</td><td>18.97</td></tr><tr><td>"Zoopla"</td><td>"Asking price per sqm"</td><td>5</td><td>58</td><td>8.62</td></tr><tr><td>"Zoopla"</td><td>"Total floor area (sqm)"</td><td>5</td><td>58</td><td>8.62</td></tr></tbody></table></div>" + "<small>shape: (7, 3)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>price_basis</th><th>rows</th><th>median_price</th></tr><tr><td>str</td><td>u32</td><td>f64</td></tr></thead><tbody><tr><td>"firm"</td><td>69358</td><td>575000.0</td></tr><tr><td>"auction_guide"</td><td>23851</td><td>575000.0</td></tr><tr><td>"floor"</td><td>17258</td><td>500000.0</td></tr><tr><td>"share"</td><td>1404</td><td>146250.0</td></tr><tr><td>"other"</td><td>494</td><td>452500.0</td></tr><tr><td>"from"</td><td>221</td><td>632500.0</td></tr><tr><td>"unpriced"</td><td>19</td><td>null</td></tr></tbody></table></div>" ], "text/plain": [ - "shape: (19, 5)\n", - "┌─────────────┬─────────────────────────┬──────────┬───────────────┬────────┐\n", - "│ provider ┆ column ┆ na_count ┆ provider_rows ┆ na_pct │\n", - "│ --- ┆ --- ┆ --- ┆ --- ┆ --- │\n", - "│ str ┆ str ┆ u32 ┆ u32 ┆ f64 │\n", - "╞═════════════╪═════════════════════════╪══════════╪═══════════════╪════════╡\n", - "│ OnTheMarket ┆ Listing date ┆ 85 ┆ 85 ┆ 100.0 │\n", - "│ OnTheMarket ┆ Property number or name ┆ 85 ┆ 85 ┆ 100.0 │\n", - "│ OnTheMarket ┆ UPRN ┆ 85 ┆ 85 ┆ 100.0 │\n", - "│ OnTheMarket ┆ Extracted postcode ┆ 84 ┆ 85 ┆ 98.82 │\n", - "│ OnTheMarket ┆ Asking price per sqm ┆ 82 ┆ 85 ┆ 96.47 │\n", - "│ OnTheMarket ┆ Total floor area (sqm) ┆ 82 ┆ 85 ┆ 96.47 │\n", - "│ Rightmove ┆ Property number or name ┆ 99 ┆ 99 ┆ 100.0 │\n", - "│ Rightmove ┆ UPRN ┆ 99 ┆ 99 ┆ 100.0 │\n", - "│ Rightmove ┆ Extracted postcode ┆ 98 ┆ 99 ┆ 98.99 │\n", - "│ Rightmove ┆ Asking price per sqm ┆ 34 ┆ 99 ┆ 34.34 │\n", - "│ Rightmove ┆ Total floor area (sqm) ┆ 34 ┆ 99 ┆ 34.34 │\n", - "│ Rightmove ┆ Leasehold/Freehold ┆ 17 ┆ 99 ┆ 17.17 │\n", - "│ Zoopla ┆ Extracted postcode ┆ 58 ┆ 58 ┆ 100.0 │\n", - "│ Zoopla ┆ Listing date ┆ 58 ┆ 58 ┆ 100.0 │\n", - "│ Zoopla ┆ UPRN ┆ 25 ┆ 58 ┆ 43.1 │\n", - "│ Zoopla ┆ Leasehold/Freehold ┆ 14 ┆ 58 ┆ 24.14 │\n", - "│ Zoopla ┆ Property number or name ┆ 11 ┆ 58 ┆ 18.97 │\n", - "│ Zoopla ┆ Asking price per sqm ┆ 5 ┆ 58 ┆ 8.62 │\n", - "│ Zoopla ┆ Total floor area (sqm) ┆ 5 ┆ 58 ┆ 8.62 │\n", - "└─────────────┴─────────────────────────┴──────────┴───────────────┴────────┘" + "shape: (7, 3)\n", + "┌───────────────┬───────┬──────────────┐\n", + "│ price_basis ┆ rows ┆ median_price │\n", + "│ --- ┆ --- ┆ --- │\n", + "│ str ┆ u32 ┆ f64 │\n", + "╞═══════════════╪═══════╪══════════════╡\n", + "│ firm ┆ 69358 ┆ 575000.0 │\n", + "│ auction_guide ┆ 23851 ┆ 575000.0 │\n", + "│ floor ┆ 17258 ┆ 500000.0 │\n", + "│ share ┆ 1404 ┆ 146250.0 │\n", + "│ other ┆ 494 ┆ 452500.0 │\n", + "│ from ┆ 221 ┆ 632500.0 │\n", + "│ unpriced ┆ 19 ┆ null │\n", + "└───────────────┴───────┴──────────────┘" ] }, "metadata": {}, @@ -332,54 +1896,37 @@ } ], "source": [ - "def missing_expr(column: str, dtype: pl.DataType) -> pl.Expr:\n", - " missing = pl.col(column).is_null()\n", - " if dtype in (pl.Float32, pl.Float64):\n", - " missing = missing | pl.col(column).is_nan().fill_null(False)\n", - " return missing.sum().alias(column)\n", + "firm = clean.filter(~pl.col(\"is_shared_ownership\") & pl.col(\"is_residential\"))\n", + "print(f\"Residential, non-shared rows: {firm.height:,}\")\n", + "print(f\"Impossible tiny areas remaining (area<20 & beds>=2): \"\n", + " f\"{clean.filter((pl.col('Total floor area (sqm)') < 20) & (pl.col('Bedrooms').fill_null(0) >= 2)).height}\")\n", + "print(f\"Max £/sqm raw {raw['Asking price per sqm'].max():,} -> clean {clean['Asking price per sqm'].max():,}\")\n", + "display(firm.select(\"Asking price\", \"Total floor area (sqm)\", \"Asking price per sqm\").describe())\n", "\n", - "\n", - "value_columns = [column for column in df.columns if column != \"provider\"]\n", - "missing_by_provider = (\n", - " df.group_by(\"provider\")\n", - " .agg([missing_expr(column, df.schema[column]) for column in value_columns])\n", - " .sort(\"provider\")\n", - ")\n", - "\n", - "missing_long = (\n", - " missing_by_provider.unpivot(\n", - " index=\"provider\",\n", - " variable_name=\"column\",\n", - " value_name=\"na_count\",\n", - " )\n", - " .join(df.group_by(\"provider\").len().rename({\"len\": \"provider_rows\"}), on=\"provider\")\n", - " .filter(pl.col('na_count') > 0)\n", - " .with_columns((pl.col(\"na_count\") / pl.col(\"provider_rows\") * 100).round(2).alias(\"na_pct\"))\n", - " .sort([\"provider\", \"na_count\", \"column\"], descending=[False, True, False])\n", - ")\n", - "\n", - "display(missing_by_provider)\n", - "display(missing_long)" + "# price_basis composition\n", + "display(clean.group_by(\"price_basis\").agg(\n", + " pl.len().alias(\"rows\"), pl.col(\"Asking price\").median().alias(\"median_price\")\n", + ").sort(\"rows\", descending=True))" ] }, { "cell_type": "markdown", - "id": "24de8b4c", + "id": "e833c578", "metadata": {}, "source": [ - "## Map" + "**Categoricals normalised** — sub-type variants collapsed, qualifier casing merged:" ] }, { "cell_type": "code", - "execution_count": 4, - "id": "cadef70a", + "execution_count": null, + "id": "6a20db99", "metadata": { "execution": { - "iopub.execute_input": "2026-05-17T10:23:48.014374Z", - "iopub.status.busy": "2026-05-17T10:23:48.014290Z", - "iopub.status.idle": "2026-05-17T10:23:49.319476Z", - "shell.execute_reply": "2026-05-17T10:23:49.319211Z" + "iopub.execute_input": "2026-06-03T07:34:31.968094Z", + "iopub.status.busy": "2026-06-03T07:34:31.968011Z", + "iopub.status.idle": "2026-06-03T07:34:31.981256Z", + "shell.execute_reply": "2026-06-03T07:34:31.980922Z" } }, "outputs": [ @@ -387,3640 +1934,142 @@ "name": "stdout", "output_type": "stream", "text": [ - "Mapped rows: 242\n" + "Property sub-type distinct: raw 79 -> clean 63\n", + "Price-qualifier casing-duplicate buckets remaining: 0\n" ] }, { "data": { - "application/vnd.plotly.v1+json": { - "config": { - "plotlyServerURL": "https://plot.ly" - }, - "data": [ - { - "customdata": [ - [ - "Stockwell Road, London", - 310000, - 1, - 1, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/89076063#/?channel=RES_BUY", - 51.471079, - -0.121569 - ], - [ - "Stockwell Park Crescent II, London", - 2595000, - 4, - 5, - "Semi-Detached", - "https://www.rightmove.co.uk/properties/174610352#/?channel=RES_BUY", - 51.47115, - -0.11817 - ], - [ - "Groveway, Stockwell", - 2295000, - 3, - 6, - "Detached", - "https://www.rightmove.co.uk/properties/174282005#/?channel=RES_BUY", - 51.473247, - -0.114727 - ], - [ - "Stockwell Park Road, London", - 2250000, - 2, - 4, - "Semi-Detached", - "https://www.rightmove.co.uk/properties/170781485#/?channel=RES_BUY", - 51.472141, - -0.116603 - ], - [ - "St Johns Buildings, London", - 2100000, - 2, - 2, - "Terraced", - "https://www.rightmove.co.uk/properties/174206714#/?channel=RES_BUY", - 51.46428, - -0.11247 - ], - [ - "Stockwell Park Road, London", - 2100000, - 3, - 4, - "Terraced", - "https://www.rightmove.co.uk/properties/88435821#/?channel=RES_BUY", - 51.47089, - -0.116765 - ], - [ - "Crewdson Road, London", - 1900000, - 3, - 5, - "Terraced", - "https://www.rightmove.co.uk/properties/174798002#/?channel=RES_BUY", - 51.478768, - -0.113111 - ], - [ - "Stockwell Park Crescent, Stockwell, London", - 1695000, - 3, - 3, - "Detached", - "https://www.rightmove.co.uk/properties/88376967#/?channel=RES_BUY", - 51.47091, - -0.11805 - ], - [ - "Stockwell Park Road, London", - 1695000, - 3, - 5, - "Semi-Detached", - "https://www.rightmove.co.uk/properties/167893637#/?channel=RES_BUY", - 51.474381, - -0.119192 - ], - [ - "Stockwell Park Crescent, Stockwell", - 1695000, - 2, - 2, - "Semi-Detached", - "https://www.rightmove.co.uk/properties/173668991#/?channel=RES_BUY", - 51.470774, - -0.11778 - ], - [ - "Hargwyne Street, London", - 1650000, - 3, - 4, - "Terraced", - "https://www.rightmove.co.uk/properties/174050450#/?channel=RES_BUY", - 51.465546, - -0.121041 - ], - [ - "Burnley Road, London", - 1595000, - 2, - 5, - "Terraced", - "https://www.rightmove.co.uk/properties/88367181#/?channel=RES_BUY", - 51.470986, - -0.119194 - ], - [ - "Clapham Road, Stockwell", - 1550000, - 3, - 5, - "Terraced", - "https://www.rightmove.co.uk/properties/172178081#/?channel=RES_BUY", - 51.475262, - -0.118914 - ], - [ - "Brixton Road, Brixton High Street", - 1550000, - 1, - 8, - "Terraced", - "https://www.rightmove.co.uk/properties/88139847#/?channel=RES_BUY", - 51.465359, - -0.114329 - ], - [ - "Trinity Gardens, LONDON", - 1500000, - 2, - 4, - "Terraced", - "https://www.rightmove.co.uk/properties/174274454#/?channel=RES_BUY", - 51.461726, - -0.118903 - ], - [ - "St. Michael's Road, London", - 1495000, - 3, - 5, - "Terraced", - "https://www.rightmove.co.uk/properties/88502766#/?channel=RES_BUY", - 51.471604, - -0.119671 - ], - [ - "Lorn Road, Stockwell", - 1475000, - 2, - 3, - "Semi-Detached", - "https://www.rightmove.co.uk/properties/172265342#/?channel=RES_BUY", - 51.472272, - -0.113846 - ], - [ - "Stockwell Green, Stockwell, London", - 1450000, - 2, - 4, - "Detached", - "https://www.rightmove.co.uk/properties/173813414#/?channel=RES_BUY", - 51.4678, - -0.1199 - ], - [ - "Ferndale Road, London", - 1400000, - 2, - 3, - "Terraced", - "https://www.rightmove.co.uk/properties/87958638#/?channel=RES_BUY", - 51.46318, - -0.12043 - ], - [ - "Stirling Road, Stockwell", - 1365000, - 4, - 4, - "Detached", - "https://www.rightmove.co.uk/properties/160476977#/?channel=RES_BUY", - 51.468018, - -0.126212 - ], - [ - "Dalyell Road, London", - 1350000, - 2, - 4, - "Terraced", - "https://www.rightmove.co.uk/properties/174526448#/?channel=RES_BUY", - 51.467377, - -0.120725 - ], - [ - "Hargwyne Street, London", - 1350000, - 3, - 5, - "Terraced", - "https://www.rightmove.co.uk/properties/88118943#/?channel=RES_BUY", - 51.464718, - -0.120788 - ], - [ - "Sidney Road, Stockwell", - 1350000, - 2, - 4, - "Detached", - "https://www.rightmove.co.uk/properties/173691437#/?channel=RES_BUY", - 51.469995, - -0.116842 - ], - [ - "Tasman Road, Clapham North", - 1300000, - 2, - 4, - "Terraced", - "https://www.rightmove.co.uk/properties/88674900#/?channel=RES_BUY", - 51.464666, - -0.125111 - ], - [ - "Tasman Road, Clapham", - 1300000, - 2, - 5, - "Terraced", - "https://www.rightmove.co.uk/properties/166381670#/?channel=RES_BUY", - 51.464662, - -0.125115 - ], - [ - "Akerman Road, Brixton, London", - 950000, - 1, - 3, - "Terraced", - "https://www.rightmove.co.uk/properties/174585656#/?channel=RES_BUY", - 51.4723, - -0.10713 - ], - [ - "Kimberley Road, Clapham North", - 1295000, - 3, - 5, - "Detached", - "https://www.rightmove.co.uk/properties/170576258#/?channel=RES_BUY", - 51.467839, - -0.122975 - ], - [ - "Clapham Road, London", - 1250000, - 0, - 7, - "Detached", - "https://www.rightmove.co.uk/properties/172845386#/?channel=RES_BUY", - 51.47241, - -0.12187 - ], - [ - "Savoy Mews, Clapham, London", - 1250000, - 3, - 4, - "Terraced", - "https://www.rightmove.co.uk/properties/171967202#/?channel=RES_BUY", - 51.467846, - -0.129214 - ], - [ - "Kay Road, London", - 1225000, - 2, - 4, - "Terraced", - "https://www.rightmove.co.uk/properties/159519872#/?channel=RES_BUY", - 51.46829, - -0.12247 - ], - [ - "Stirling Road, London", - 1200000, - 2, - 4, - "Terraced", - "https://www.rightmove.co.uk/properties/174773513#/?channel=RES_BUY", - 51.467893, - -0.126016 - ], - [ - "Ferndale Road, London", - 1175000, - 2, - 4, - "Terraced", - "https://www.rightmove.co.uk/properties/88182951#/?channel=RES_BUY", - 51.463223, - -0.11965 - ], - [ - "Grantham Road, Stockwell", - 1175000, - 3, - 4, - "Terraced", - "https://www.rightmove.co.uk/properties/87587604#/?channel=RES_BUY", - 51.468085, - -0.125018 - ], - [ - "Lothian Road, Oval", - 1150000, - 2, - 3, - "Detached", - "https://www.rightmove.co.uk/properties/168423935#/?channel=RES_BUY", - 51.476299, - -0.102795 - ], - [ - "Clapham Place, 340A Clapham Road, London", - 1100000, - 2, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/162737807#/?channel=RES_BUY", - 51.469463, - -0.126614 - ], - [ - "Archer Mews, Clapham", - 1100000, - 2, - 3, - "Terraced", - "https://www.rightmove.co.uk/properties/162027752#/?channel=RES_BUY", - 51.466859, - -0.127675 - ], - [ - "Hargwyne Street, Stockwell", - 1050000, - 3, - 4, - "Detached", - "https://www.rightmove.co.uk/properties/88674894#/?channel=RES_BUY", - 51.46622, - -0.121542 - ], - [ - "Argyll Close", - 1050000, - 3, - 4, - "Detached", - "https://www.rightmove.co.uk/properties/88123392#/?channel=RES_BUY", - 51.467369, - -0.120287 - ], - [ - "Trinity Gardens, London", - 1000000, - 1, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/166982441#/?channel=RES_BUY", - 51.461843, - -0.118482 - ], - [ - "Printers Road, London", - 1000000, - 3, - 3, - "Terraced", - "https://www.rightmove.co.uk/properties/88736202#/?channel=RES_BUY", - 51.475519, - -0.117579 - ], - [ - "Printers Road, London", - 1000000, - 3, - 3, - "Detached", - "https://www.rightmove.co.uk/properties/171963581#/?channel=RES_BUY", - 51.475422, - -0.117396 - ], - [ - "Combermere Road", - 1000000, - 4, - 4, - "Detached", - "https://www.rightmove.co.uk/properties/174512360#/?channel=RES_BUY", - 51.466953, - -0.118676 - ], - [ - "Chantrey Road, Brixton, London", - 1000000, - 2, - 5, - "Terraced", - "https://www.rightmove.co.uk/properties/87722028#/?channel=RES_BUY", - 51.46524, - -0.11785 - ], - [ - "Caldwell Street, Stockwell", - 995000, - 2, - 4, - "Detached", - "https://www.rightmove.co.uk/properties/89089584#/?channel=RES_BUY", - 51.477238, - -0.116819 - ], - [ - "Offley Road, Oval, London", - 950000, - 2, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/87978744#/?channel=RES_BUY", - 51.4801, - -0.11306 - ], - [ - "Clapham Road, London", - 950000, - 2, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/174253709#/?channel=RES_BUY", - 51.46955, - -0.12494 - ], - [ - "Burgoyne Road, Brixton, London", - 950000, - 1, - 3, - "Detached", - "https://www.rightmove.co.uk/properties/88915212#/?channel=RES_BUY", - 51.46626, - -0.11924 - ], - [ - "Akerman Road, Brixton", - 950000, - 1, - 3, - "Terraced", - "https://www.rightmove.co.uk/properties/174043499#/?channel=RES_BUY", - 51.472355, - -0.107133 - ], - [ - "Trinity Gardens, Brixton, London", - 950000, - 1, - 3, - "Detached", - "https://www.rightmove.co.uk/properties/87721950#/?channel=RES_BUY", - 51.46184, - -0.11885 - ], - [ - "Dalyell Road, Stockwell", - 950000, - 2, - 5, - "Terraced", - "https://www.rightmove.co.uk/properties/173248592#/?channel=RES_BUY", - 51.46484, - -0.11861 - ], - [ - "Cowley Road, London", - 500000, - 1, - 2, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/174943268#/?channel=RES_BUY", - 51.472811, - -0.110448 - ], - [ - "Burgoyne Road, Brixton", - 950000, - 1, - 3, - "Terraced", - "https://www.rightmove.co.uk/properties/171244910#/?channel=RES_BUY", - 51.466514, - -0.119357 - ], - [ - "Kay Road", - 950000, - 1, - 3, - "Detached", - "https://www.rightmove.co.uk/properties/88786803#/?channel=RES_BUY", - 51.468173, - -0.123544 - ], - [ - "Edithna Street, Clapham", - 949000, - 2, - 2, - "Terraced", - "https://www.rightmove.co.uk/properties/173407493#/?channel=RES_BUY", - 51.467536, - -0.124279 - ], - [ - "Landor Road, Stockwell", - 925000, - 3, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/174241487#/?channel=RES_BUY", - 51.465761, - -0.127271 - ], - [ - "Cancell Road, Stockwell", - 925000, - 2, - 3, - "Terraced", - "https://www.rightmove.co.uk/properties/172063247#/?channel=RES_BUY", - 51.47675, - -0.10812 - ], - [ - "Combermere Road, Brixton", - 900000, - 1, - 3, - "Detached", - "https://www.rightmove.co.uk/properties/174829754#/?channel=RES_BUY", - 51.466761, - -0.118967 - ], - [ - "Stockwell Green, Stockwell, London", - 900000, - 2, - 2, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/87758454#/?channel=RES_BUY", - 51.46797, - -0.11961 - ], - [ - "Lingham Street, Stockwell", - 900000, - 2, - 2, - "Detached", - "https://www.rightmove.co.uk/properties/174459077#/?channel=RES_BUY", - 51.468202, - -0.121805 - ], - [ - "Dalyell Road, Clapham", - 900000, - 1, - 3, - "Terraced", - "https://www.rightmove.co.uk/properties/174751187#/?channel=RES_BUY", - 51.467378, - -0.120699 - ], - [ - "Hillyard Street, Stockwell, London", - 895000, - 2, - 4, - "Terraced", - "https://www.rightmove.co.uk/properties/169772384#/?channel=RES_BUY", - 51.474009, - -0.113644 - ], - [ - "Fairbairn Green, Oval, London", - 850000, - 2, - 4, - "Detached", - "https://www.rightmove.co.uk/properties/87977643#/?channel=RES_BUY", - 51.47451, - -0.10695 - ], - [ - "Tindal Street", - 850000, - 2, - 4, - "Terraced", - "https://www.rightmove.co.uk/properties/145850135#/?channel=RES_BUY", - 51.476302, - -0.104166 - ], - [ - "Hargwyne Street, Brixton", - 825000, - 1, - 3, - "Detached", - "https://www.rightmove.co.uk/properties/88033488#/?channel=RES_BUY", - 51.465427, - -0.121403 - ], - [ - "Gresham Road, London", - 825000, - 1, - 2, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/173616209#/?channel=RES_BUY", - 51.463844, - -0.108902 - ], - [ - "Cancell Road, London", - 800000, - 1, - 3, - "Terraced", - "https://www.rightmove.co.uk/properties/167464373#/?channel=RES_BUY", - 51.476811, - -0.107076 - ], - [ - "Clapham Place, 340A Clapham Road, London", - 800000, - 2, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/167067521#/?channel=RES_BUY", - 51.46931, - -0.126446 - ], - [ - "Kimberley Road, London", - 800000, - 1, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/166294310#/?channel=RES_BUY", - 51.46846, - -0.123807 - ], - [ - "Dalyell Road, London", - 800000, - 1, - 3, - "Terraced", - "https://www.rightmove.co.uk/properties/174671783#/?channel=RES_BUY", - 51.464537, - -0.1186 - ], - [ - "Vassall Road, London", - 780000, - 2, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/169024502#/?channel=RES_BUY", - 51.477882, - -0.104541 - ], - [ - "Groveway, Stockwell", - 765000, - 2, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/173589443#/?channel=RES_BUY", - 51.473073, - -0.113506 - ], - [ - "Stane Grove, London", - 750000, - 2, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/172439786#/?channel=RES_BUY", - 51.468326, - -0.128228 - ], - [ - "Robsart Street", - 750000, - 2, - 2, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/89043525#/?channel=RES_BUY", - 51.470458, - -0.114754 - ], - [ - "Broomgrove Road, Stockwell", - 750000, - 2, - 4, - "Detached", - "https://www.rightmove.co.uk/properties/87785412#/?channel=RES_BUY", - 51.468367, - -0.117416 - ], - [ - "Landor Road, Clapham", - 525000, - 1, - 2, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/88178850#/?channel=RES_BUY", - 51.465864, - -0.126485 - ], - [ - "Southey Road, London", - 750000, - 1, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/88953351#/?channel=RES_BUY", - 51.476104, - -0.114177 - ], - [ - "Stirling Road, Clapham North", - 750000, - 1, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/172541237#/?channel=RES_BUY", - 51.467923, - -0.125572 - ], - [ - "Brixton Road, London", - 750000, - 2, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/88436790#/?channel=RES_BUY", - 51.473018, - -0.112407 - ], - [ - "Lorn Road, London", - 735000, - 1, - 2, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/174008492#/?channel=RES_BUY", - 51.47212, - -0.11497 - ], - [ - "Tregothnan Road, Clapham", - 735000, - 2, - 2, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/174955157#/?channel=RES_BUY", - 51.467534, - -0.124866 - ], - [ - "Clapham Road", - 725000, - 2, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/173512085#/?channel=RES_BUY", - 51.465962, - -0.129116 - ], - [ - "Fairbairn Green, Oval, London", - 725000, - 1, - 4, - "Semi-Detached", - "https://www.rightmove.co.uk/properties/88014204#/?channel=RES_BUY", - 51.47451, - -0.10695 - ], - [ - "Minet Road, London", - 725000, - 1, - 2, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/88412274#/?channel=RES_BUY", - 51.47043, - -0.10541 - ], - [ - "Stockwell Road", - 720000, - 2, - 2, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/88606029#/?channel=RES_BUY", - 51.465621, - -0.116586 - ], - [ - "Dundas Road, London", - 720000, - 2, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/171205478#/?channel=RES_BUY", - 51.472982, - -0.109654 - ], - [ - "Tasman Road, Clapham North", - 700000, - 1, - 2, - "Terraced", - "https://www.rightmove.co.uk/properties/162538115#/?channel=RES_BUY", - 51.465724, - -0.125134 - ], - [ - "Hubert Grove, LONDON", - 700000, - 2, - 4, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/174476441#/?channel=RES_BUY", - 51.464897, - -0.123706 - ], - [ - "Hackford Road, Oval, London", - 700000, - 2, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/88664931#/?channel=RES_BUY", - 51.47546, - -0.11555 - ], - [ - "Stockwell Park Road, Stockwell", - 699950, - 2, - 2, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/171128921#/?channel=RES_BUY", - 51.47055, - -0.116184 - ], - [ - "Brixton Road, Stockwell", - 699950, - 1, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/88155525#/?channel=RES_BUY", - 51.473284, - -0.112372 - ], - [ - "Clapham Road, Clapham", - 699950, - 1, - 2, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/88186095#/?channel=RES_BUY", - 51.468123, - -0.128106 - ], - [ - "Landor Road, Clapham, London", - 695000, - 2, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/173546969#/?channel=RES_BUY", - 51.466263, - -0.121044 - ], - [ - "Coal Lane", - 685000, - 2, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/173694455#/?channel=RES_BUY", - 51.463058, - -0.109573 - ], - [ - "Stockwell Park Walk", - 675000, - 2, - 2, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/173953706#/?channel=RES_BUY", - 51.46635, - -0.11388 - ], - [ - "Clapham Road, London", - 675000, - 2, - 2, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/88306662#/?channel=RES_BUY", - 51.468123, - -0.128106 - ], - [ - "Mayflower Road, Clapham, London", - 675000, - 1, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/174082844#/?channel=RES_BUY", - 51.467313, - -0.125793 - ], - [ - "Offley Road, Oval, Londobn", - 675000, - 2, - 2, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/88010451#/?channel=RES_BUY", - 51.480175, - -0.112983 - ], - [ - "St Lawrence Way, Brixton, London", - 675000, - 2, - 6, - "Terraced", - "https://www.rightmove.co.uk/properties/87975399#/?channel=RES_BUY", - 51.4715, - -0.10996 - ], - [ - "Kimberley Road, Clapham", - 670000, - 2, - 3, - "Flats/Maisonettes", - "https://www.rightmove.co.uk/properties/173861306#/?channel=RES_BUY", - 51.468039, - -0.123683 - ] - ], - "hovertemplate": "<b>%{hovertext}</b><br><br>provider=Rightmove<br>Address per Property Register=%{customdata[0]}<br>Asking price=%{customdata[1]:,.0f}<br>Bathrooms=%{customdata[2]}<br>Bedrooms=%{customdata[3]}<br>Property type=%{customdata[4]}<br>Listing URL=%{customdata[5]}<extra></extra>", - "hovertext": [ - "SW9 9EU", - "SW9 0DG", - "SW9 0AR", - "SW9 0DD", - "SW9 7QH", - "SW9 0DB", - "SW9 0LJ", - "SW9 0DG", - "SW9 0RU", - "SW9 0DG", - "SW9 9RF", - "SW9 0SW", - "SW9 0QQ", - "SW9 7AW", - "SW9 8DR", - "SW9 0SN", - "SW9 6LN", - "SW9 9HZ", - "SW9 8AH", - "SW9 9EF", - "SW9 9SD", - "SW9 9RQ", - "SW9 0TP", - "SW9 9LZ", - "SW9 9LZ", - "SW9 6TF", - "SW9 9DG", - "SW9 0QH", - "SW9 9AT", - "SW9 9DE", - "SW9 9EF", - "SW9 8AG", - "SW9 9ED", - "SW9 6UB", - "SW9 9FA", - "SW9 9BU", - "SW9 9RE", - "SW9 9QL", - "SW9 8DR", - "SW9 0BH", - "SW9 0BH", - "SW9 9QG", - "SW9 9TE", - "SW9 0HU", - "SW9 0LS", - "SW9 9BN", - "SW9 9QJ", - "SW9 6TF", - "SW9 8DR", - "SW9 9UT", - "SW9 6BW", - "SW9 9QS", - "SW9 9DH", - "SW9 9JR", - "SW9 9LN", - "SW9 6HP", - "SW9 9QD", - "SW9 9HX", - "SW9 9JL", - "SW9 9SD", - "SW9 0PL", - "SW9 7RR", - "SW9 6UP", - "SW9 9RF", - "SW9 7JE", - "SW9 6GA", - "SW9 9FA", - "SW9 9DH", - "SW9 9UU", - "SW9 6JA", - "SW9 6AR", - "SW4 6JL", - "SW9 0BP", - "SW9 9TL", - "SW9 9RT", - "SW9 0PD", - "SW9 9EE", - "SW9 6LW", - "SW9 0AD", - "SW9 9JX", - "SW9 9RX", - "SW9 7RR", - "SE5 9HY", - "SW9 9TB", - "SW9 6BZ", - "SW9 9PE", - "SW9 9PD", - "SW9 0RH", - "SW9 0DH", - "SW9 6LP", - "SW9 9FY", - "SW9 9RE", - "SW9 8FZ", - "SW9 0FF", - "SW9 9FY", - "SW9 9JY", - "SW9 0LS", - "SW9 6NP", - "SW9 9DH" - ], - "lat": { - "bdata": "jGoRUUy8SUBVwaikTrxJQA73kVuTvElA5QzFHW+8SUDsF+yGbbtJQLgBnx9GvElAiC8TRUi9SUAArmTHRrxJQAFsQIS4vElAT+eKUkK8SUBOZOYCl7tJQNtv7URJvElACoSdYtW8SUAb8zrikLtJQEDbatYZu0lA1lQWhV28SUCDaK1oc7xJQM6I0t7gu0lApRR0e0m7SUA8+IkD6LtJQIjzcALTu0lAZ+4h4Xu7SUBKJNHLKLxJQBXI7Cx6u0lA09heC3q7SUBN845TdLxJQIxl+iXiu0lA1SZO7ne8SUA/yLJg4rtJQJ2FPe3wu0lAf4P26uO7SUCk4CnkSrtJQMRfkzXqu0lACg+aXfe8SUBN1xNdF7xJQPBrJAnCu0lA3V7SGK27SUAFFVW/0rtJQHpx4qsdu0lANdB8zt28SUBD5sqg2rxJQHHiqx3Fu0lAQWX8+4y7SUBINIEiFr1JQKFns+pzvUlAHOviNhq8SUBrt11orrtJQBGN7iB2vElACf63kh27SUCz74rgf7tJQDMYIxKFvElAJZASu7a7SUBj78UX7btJQPHZOjjYu0lASmBzDp67SUAbL90kBr1JQC0GD9O+u0lAK8HicOa7SUD99QoL7rtJQFhv1ArTu0lAPYGwU6y8SUD/z2G+vLxJQHuCxHb3vElAc9anHJO7SUAROX09X7tJQMCvkSQIvUlAx9eeWRK8SUD5vU1/9rtJQBdky/J1u0lAbazEPCu9SUBwz/OnjbxJQOnuOhvyu0lAHxK+9ze8SUBIwylz87tJQB8xem6hu0lAVb/S+fC8SUDqBZ/m5LtJQK01lNqLvElAzeSbbW68SUBQ4nMn2LtJQOGWj6Sku0lA/89hvry8SUBVh9wMN7xJQFiqC3iZu0lAYMyWrIq8SUAtexLYnLtJQBeBsb6Bu0lAMEeP39u8SUAAkX77OrxJQCvc8pGUvElAscBXdOu7SUDcKoiBrrtJQFkTC3xFu0lAqz5XW7G7SUCxwFd067tJQHH/kenQu0lArK3YX3a9SUAxCKwcWrxJQFMgs7Pou0lA", - "dtype": "f8" - }, - "legendgroup": "Rightmove", - "lon": { - "bdata": "vRk1XyUfv784Sl6dY0C+v27b96i/Xr2/n5Cdt7HZvb9798d71cq8v79DUaBP5L2/A1/Rrdf0vL/x9EpZhji+v4Pg8e1dg76/EHUfgNQmvr+DonkAi/y+v+4h4Xt/g76/81oJ3SVxvr+XAPxTqkS9vyFzZVBtcL6/6pRHN8Kivr9YycfuAiW9v6hXyjLEsb6/TRB1H4DUvr+obi7+tifAv/JBz2bV576/uM6/Xfbrvr94msx4W+m9v3FXryKjA8C/3ZiesMQDwL+UpGsm32y7v+zAOSNKe7+/pg9dUN8yv79auReYFYrAvwq6vaQxWr+/A+li00ohwL/+ZffkYaG+v2WmtP6WAMC/4jsx68VQur+AnZs24zTAv4EmwoanV8C/jSYXY2Adv7+uSiL7IMu+v/InKhvWVL6/OUayR6gZvr8sZK4Mqg2+v9Dx0eKMYb6/z2bV52orvr8gKo2Y2ee9v8RafAqA8by/XFX2XRH8v7+fAmA8g4a+v7aGUnsRbbu/dy0hH/Rsvr/ogvqWOV2+v4ma6PNRRry/xXWMKy6Ovr9J9Z1flKC/v55flKC/0L+/81Zdh2pKwL8gJAuYwK27v52gTQ6fdL6/kElGzsKevr90QX3LnC6/v3jvqDEh5r6/yvli78UXvb+ppE5AE2G7vzHqWnufqrq/xeOiWkQUv7/cD3hgAOG7vzS+Ly5Vabu/zuFa7WEvwL8wEATI0LG/v807TtGRXL6/sFQX8DLDur+4V+atug69vwA7N23GacC/ns4VpYRgvb9j8gaY+Q6+v6mfNxWpMMC/kpT0MLQ6vb8/i6VIvhLAv7Zq14S0xry/H2gFhqxuvb/G4GHaN/e/v4j2sYLfhsC/qaROQBNhu79A3qtWJvy6v4rkK4GU2L2/Ribg10gSvL+dD88SZATAv2moUUgyq7+/TYQNT6+Uvb/bhlEQPL69v9Zx/FBpxLy/pu81BMdlwL+lhGBVvfy+v7ZMhuP5DLy/gSGrWz0nvb+m7zUEx2XAv8ZpiCr8GcC/DAQBMnTsvL+8P96rVia8vxE4Emiwqb+/", - "dtype": "f8" - }, - "marker": { - "color": "#2563eb", - "opacity": 0.65, - "size": 5 - }, - "mode": "markers", - "name": "Rightmove", - "showlegend": true, - "subplot": "map", - "type": "scattermap" - }, - { - "customdata": [ - [ - "Bedford Road, London", - 525000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19209711/", - 51.463636, - -0.129102 - ], - [ - "Padfield Road, London", - 275000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19522441/", - 51.466129, - -0.100233 - ], - [ - "Lord Holland Lane, Myatts Fields South, London", - 600000, - 1, - 4, - "Terraced", - "https://www.onthemarket.com/details/18847208/", - 51.471775, - -0.108913 - ], - [ - "Mostyn Road, London", - 350000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19305103/", - 51.473026, - -0.107904 - ], - [ - "Hackford Road, London", - 475000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19601952/", - 51.475374, - -0.115372 - ], - [ - "Clapham Road, London", - 225000, - 1, - 0, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19601638/", - 51.476212, - -0.117911 - ], - [ - "Coldharbour Lane, Brixton, London", - 575000, - 2, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19601141/", - 51.463969, - -0.105579 - ], - [ - "Stockwell Road", - 435000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19599310/", - 51.466426, - -0.116437 - ], - [ - "Coldharbour Lane", - 450000, - 2, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19599313/", - 51.46566, - -0.102355 - ], - [ - "Stockwell Park Walk, London", - 500000, - 2, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/18060975/", - 51.466421103788, - -0.114496210643 - ], - [ - "20 Fergusson Mews, London", - 650000, - 2, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19266851/", - 51.469851, - -0.126918 - ], - [ - "Stockwell Road, Stockwell, London", - 450000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19167472/", - 51.466385, - -0.116535 - ], - [ - "Milles Square, Brixton, London", - 340000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19592532/", - 51.462364, - -0.1109 - ], - [ - "Railton Road, London", - 500000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19591254/", - 51.46006, - -0.110269 - ], - [ - "Hemberton Road, London", - 550000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19591126/", - 51.466742, - -0.126297 - ], - [ - "Vassall Road, London", - 339950, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19151834/", - 51.478151, - -0.104252 - ], - [ - "Lingham Street, Stockwell, London", - 525000, - 2, - 3, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19586498/", - 51.469424, - -0.122658 - ], - [ - "Carney Place, London", - 350000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19585964/", - 51.462768, - -0.111009 - ], - [ - "Brixton Road, Brixton, London", - 450000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19585218/", - 51.46536, - -0.114303 - ], - [ - "Willington Road, Clapham North, London", - 350000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19584647/", - 51.465275, - -0.126386 - ], - [ - "Cleveland House, Hackford Road, London", - 515000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19584203/", - 51.477508, - -0.115029 - ], - [ - "Durand Gardens, London", - 650000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19307508/", - 51.473924, - -0.117196 - ], - [ - "Electric Avenue, Brixton, London", - 500000, - 2, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19581719/", - 51.462391, - -0.114278 - ], - [ - "Dover Mansions, Brixton, London", - 575000, - 2, - 3, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19580922/", - 51.464257, - -0.113427 - ], - [ - "Aytoun Road, London", - 465000, - 2, - 4, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19145304/", - 51.468933, - -0.116185 - ], - [ - "Stockwell Green", - 475000, - 2, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/18470548/", - 51.467529, - -0.118678 - ], - [ - "Benedict Road, London", - 350000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/18676093/", - 51.466685, - -0.116216 - ], - [ - "Draymans Court, Stockwell, London", - 475000, - 2, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19341068/", - 51.467534, - -0.118677 - ], - [ - "Myatt Road, London", - 325000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19567307/", - 51.477081, - -0.103866 - ], - [ - "Loughborough Park", - 500000, - 2, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19097631/", - 51.458717, - -0.106738 - ], - [ - "Loughborough Estate, London", - 340000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/18622635/", - 51.46826160116, - -0.10570123622231 - ], - [ - "Stane Grove, Clapham North, London", - 500000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19563052/", - 51.468519, - -0.128499 - ], - [ - "Loughborough Road, London", - 500000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/18682120/", - 51.470658, - -0.108302 - ], - [ - "Stane Grove, London", - 550000, - 2, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19288520/", - 51.468518, - -0.128499 - ], - [ - "Turner Close, London", - 470000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19558448/", - 51.476714, - -0.101937 - ], - [ - "Brighton Terrace, Brixton, London", - 475000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19306574/", - 51.461645, - -0.117062 - ], - [ - "Fenwick Place", - 599950, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19554481/", - 51.464473, - -0.12876 - ], - [ - "Loughborough Road", - 375000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19553677/", - 51.470695, - -0.108771 - ], - [ - "Eythorne Road, London", - 575000, - 2, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19552463/", - 51.475345, - -0.108351 - ], - [ - "Handforth Road, Oval, London", - 500000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19069586/", - 51.479485, - -0.113059 - ], - [ - "20 Fergusson Mews, Stockwell", - 695000, - 2, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19547590/", - 51.470019, - -0.126753 - ], - [ - "Landor Road, Clapham, London", - 550000, - 2, - 2, - "Other", - "https://www.onthemarket.com/details/19275567/", - 51.467004, - -0.122097 - ], - [ - "Cormont Road, Camberwell, London", - 325000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19544734/", - 51.473042, - -0.106046 - ], - [ - "Stockwell Road, London", - 425000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19543368/", - 51.466384, - -0.116535 - ], - [ - "Calais Street, London", - 695000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19539822/", - 51.475455, - -0.103167 - ], - [ - "Clapham Road, Stockwell, London", - 300000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19312175/", - 51.477909, - -0.115701 - ], - [ - "Stane Grove, London", - 450000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19538231/", - 51.468519, - -0.128499 - ], - [ - "Stockwell Road", - 465000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19538198/", - 51.466529, - -0.117086 - ], - [ - "Bolton Crescent, London", - 450000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19523846/", - 51.480484, - -0.10806 - ], - [ - "Handforth Road, London", - 550000, - 2, - 3, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19506302/", - 51.4793089, - -0.1138433 - ], - [ - "Acre Lane, London", - 600000, - 2, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19234257/", - 51.460529, - -0.11754 - ], - [ - "Brixton Road, LONDON", - 350000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19043584/", - 51.479824, - -0.111801 - ], - [ - "Bramah Road, London", - 525000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19521511/", - 51.473773, - -0.10913 - ], - [ - "Carney Place, London", - 400000, - 2, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19125735/", - 51.462428, - -0.110765 - ], - [ - "Liberty Street, London", - 225000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/18847282/", - 51.475833, - -0.11632 - ], - [ - "Liberty Street, London", - 375000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/18850207/", - 51.475833, - -0.11632 - ], - [ - "Clapham Road, London", - 400000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19517131/", - 51.4807822, - -0.1131921 - ], - [ - "Edithna Street", - 500000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/18944836/", - 51.467754, - -0.124359 - ], - [ - "Brighton Terrace, London", - 375000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19515033/", - 51.461928, - -0.117304 - ], - [ - "Offenham Road, London", - 498000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19513494/", - 51.475892, - -0.109228 - ], - [ - "Camberwell New Road, London", - 750000, - 2, - 2, - "Terraced", - "https://www.onthemarket.com/details/19512902/", - 51.47739791870117, - -0.10183600336313248 - ], - [ - "Wynne Road, Brixton, London", - 300000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/17925213/", - 51.469385, - -0.113518 - ], - [ - "Hanover Gardens London", - 1290000, - 1, - 3, - "Terraced", - "https://www.onthemarket.com/details/18150560/", - 51.4815756, - -0.1134328 - ], - [ - "St John's Crescent, London", - 520000, - 1, - 3, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19509501/", - 51.466075, - -0.111577 - ], - [ - "Rumsey Road, London", - 590000, - 2, - 3, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19043064/", - 51.466866, - -0.116459 - ], - [ - "Offley Road, London", - 450000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19503694/", - 51.479936, - -0.112276 - ], - [ - "Huxley House, Stockwell Road, Stockwell, London", - 435000, - 1, - 3, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19502011/", - 51.470333, - -0.121643 - ], - [ - "Stane Grove, Clapham, London", - 500000, - 2, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/18534657/", - 51.468264, - -0.127765 - ], - [ - "Salisbury Place, London", - 325000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19494191/", - 51.477335, - -0.103078 - ], - [ - "Hackford Road, London", - 375000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19201991/", - 51.47546, - -0.11501 - ], - [ - "Hillyard Street, London", - 250000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19306826/", - 51.473951, - -0.115205 - ], - [ - "Hackford Road, London", - 525000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19489525/", - 51.475637, - -0.115318 - ], - [ - "Robsart Street", - 640000, - 2, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19488047/", - 51.470149, - -0.114532 - ], - [ - "Crewdson Road, LONDON", - 525000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19487822/", - 51.47869, - -0.112493 - ], - [ - "Salisbury Place, Oval, London", - 325000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19483122/", - 51.477336, - -0.103052 - ], - [ - "Burton Road, London", - 475000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19357782/", - 51.471575, - -0.105481 - ], - [ - "Cromwell Road, London", - 325000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/18085145/", - 51.4761439, - -0.1061119 - ], - [ - "Ferndale Road, London", - 625000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19235836/", - 51.463174, - -0.12694 - ], - [ - "Coldharbour Lane, Brixton, London", - 400000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19478961/", - 51.464527, - -0.103943 - ], - [ - "Camberwell New Road, London", - 1350000, - 4, - 5, - "Detached", - "https://www.onthemarket.com/details/19476834/", - 51.478599, - -0.104555 - ], - [ - "Cormont Road, London", - 1395000, - 2, - 4, - "Detached", - "https://www.onthemarket.com/details/19476578/", - 51.472499, - -0.105408 - ], - [ - "Fyfield Road, London", - 425000, - 1, - 1, - "Terraced", - "https://www.onthemarket.com/details/19311666/", - 51.466176, - -0.109734 - ], - [ - "Landor Road, Stockwell", - 350000, - 1, - 1, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/19330855/", - 51.4667874, - -0.1226492 - ], - [ - "Cormont Road, London", - 1700000, - 2, - 4, - "Detached", - "https://www.onthemarket.com/details/19474066/", - 51.47264, - -0.105378 - ], - [ - "Holcombe House, Landor Road, Clapham", - 475000, - 1, - 2, - "Flats/Maisonettes", - "https://www.onthemarket.com/details/18716390/", - 51.465374, - -0.127617 - ] - ], - "hovertemplate": "<b>%{hovertext}</b><br><br>provider=OnTheMarket<br>Address per Property Register=%{customdata[0]}<br>Asking price=%{customdata[1]:,.0f}<br>Bathrooms=%{customdata[2]}<br>Bedrooms=%{customdata[3]}<br>Property type=%{customdata[4]}<br>Listing URL=%{customdata[5]}<extra></extra>", - "hovertext": [ - "SW4 7EF", - "SE5 9AA", - "SW9 6NN", - "SW9 6BF", - "SW9 0RG", - "SW9 0HP", - "SW9 8SE", - "SW9 9FX", - "SW9 8RU", - "SW9 0FH", - "SW4 6BF", - "SW9 9FX", - "SW9 8GA", - "SE24 0LW", - "SW9 9LE", - "SW9 6JB", - "SW9 9HE", - "SW9 8GF", - "SW9 7AW", - "SW9 9NF", - "SW9 0EN", - "SW9 0PP", - "SW9 8JX", - "SW9 7QF", - "SW9 0UE", - "SW9 9QE", - "SW9 0FS", - "SW9 9QE", - "SW9 6XE", - "SW9 8FS", - "SW9 7SP", - "SW9 9AL", - "SW9 7TB", - "SW9 9AL", - "SW9 6UQ", - "SW9 8DL", - "SW9 9PG", - "SW9 7JX", - "SW9 7BN", - "SW9 0LP", - "SW4 6QU", - "SW9 9JB", - "SE5 9RE", - "SW9 9FX", - "SW9 6UB", - "SW9 0HS", - "SW9 9AL", - "SW9 9TG", - "SE5 0RZ", - "SW9 0LU", - "SW2 5RS", - "SW9 6BT", - "SW9 6FJ", - "SW9 8GA", - "SW9 0EF", - "SW9 0EF", - "SW9 0JP", - "SW9 9EB", - "SW9 8DH", - "SW9 7DX", - "SE5 0RR", - "SW9 0BB", - "SE11 5TL", - "SW9 7LZ", - "SW9 0FR", - "SW9 0LR", - "SW9 9EY", - "SW9 9FY", - "SW9 6UW", - "SW9 0RE", - "SW9 0NB", - "SW9 0RG", - "SW9 0FA", - "SW9 6BP", - "SW9 6UW", - "SW9 6TG", - "SW9 7BG", - "SW4 7SF", - "SW9 8SG", - "SE5 0SU", - "SE5 9RA", - "SW9 7HW", - "SW9 9NT", - "SE5 9RA", - "SW9 9NS" - ], - "lat": { - "bdata": "x5+obFi7SUDNW3UdqrtJQAMJih9jvElALxSwHYy8SUAyryMO2bxJQDv7yoP0vElAza0QVmO7SUCGAODYs7tJQBaHM7+au0lAg3fNr7O7SUAXf9sTJLxJQCgs8YCyu0lAg2xZvi67SUBQGf8+47pJQLfVrDO+u0lAXMZNDTS9SUCP+usVFrxJQFLRWPs7u0lA626e6pC7SUC9UpYhjrtJQAjKbfsevUlADmWoiqm8SUB8e9egL7tJQDT4+8Vsu0lA8YEd/wW8SUA+d4L917tJQFJEhlW8u0lAUOJzJ9i7SUCARX79EL1JQEOPGD23uklAN3oD/++7SUD+Rjtu+LtJQObMdoU+vElALsvXZfi7SUDOxd/2BL1JQFOu8C4Xu0lAAHDs2XO7SUADste7P7xJQJeo3hrYvElAFva0w1+9SUDTvySVKbxJQPSMfcnGu0lANdHno4y8SUBXsI14srtJQB7cnbXbvElAZrtCHyy9SUD+Rjtu+LtJQFvR5ji3u0lAKSDtf4C9SUBDF3n+Wb1JQAfuQJ3yuklA/+px32q9SUApXfqXpLxJQJpgONcwu0lAxa2CGOi8SUDFrYIY6LxJQN2/aEWKvUlAXknyXN+7SUCojep0ILtJQMo2cAfqvElAAAAAYBu9SUDSHcTOFLxJQJpG7kSkvUlA2T15WKi7SUCjztxDwrtJQCcW+IpuvUlAYp0q3zO8SUBz8iIT8LtJQDoeM1AZvUlAMEeP39u8SUAIdCZtqrxJQD/iV6zhvElAoZ+p1y28SUAMdsO2Rb1JQAuallgZvUlAPE7RkVy8SUBOWIdI8rxJQMMtH0lJu0lA843onnW7SUD8cma7Qr1JQEQy5Nh6vElADRe5p6u7SUCql4Swv7tJQAZkr3d/vElAUDQPYJG7SUA=", - "dtype": "f8" - }, - "legendgroup": "OnTheMarket", - "lon": { - "bdata": "jpHsEWqGwL8v3/qw3qi5v633G+244bu/oIobt5ifu7/Oxd/2BIm9vymy1lBqL76/WvYksDkHu7+nWguz0M69vzIDlfHvM7q/ykQ6qJ9Pvb+FCaNZ2T7Av0zg1t081b2/wFsgQfFjvL9UO8PUljq8v9ycSgaAKsC/T+eKUkKwur+lv5fCg2a/vzbJj/gVa7y/Ha7VHvZCvb98DFacai3Avw1yF2GKcr2/CtY4m44Avr9Z/KawUkG9v5S/e0eNCb2/kSdJ10y+vb88M8FwrmG+v5mdRe9UwL2/hpLJqZ1hvr//lCpR9pa6vwCOPXsuU7u/Qbq4eDwPu79Ly0i9p3LAv3dlFwyuubu/S8tIvadywL8kmkARixi6v9C2mnXG972/CTiEKjV7wL/E0sCPati7v0oofSHkvLu/D7qEQ2/xvL/kvtU6cTnAv/eQ8L2/Qb+/OiLfpdQlu79M4NbdPNW9vz/EBgsnabq/nE8dq5Sevb9Ly0i9p3LAv97H0RxZ+b2/fXkB9tGpu785ZF6i1SS9v4LK+PcZF76/Dfyohv2evL/kMQOV8e+7v9CbilQYW7y/gufewyXHvb+C597DJce9vz9iqk8o+ry/eJj2zf3Vv7/LorCLoge+v4m3zr9d9ru/AAAAoOwRur8/4IEBhA+9v4AwS5buCb2/3Vz8bU+QvL9JKlPMQdC9v50tILQevry/VI7J4v4jv797ZkmAmlrAvwDl795RY7q/jIS2nEtxvb8g71UrE369v27fo/56hb2/2nBYGvhRvb/TZwdcV8y8v4aSyamdYbq/tXBZhc0Au791ZzdEJiq7v1bxRuaRP8C/t+ulKQKcur+jHqLRHcS6v9ScvMgE/Lq/IF9CBYcXvL+XbOEe8GW/v4LHt3cN+rq/5fG0/MBVwL8=", - "dtype": "f8" - }, - "marker": { - "color": "#16a34a", - "opacity": 0.65, - "size": 5 - }, - "mode": "markers", - "name": "OnTheMarket", - "showlegend": true, - "subplot": "map", - "type": "scattermap" - }, - { - "customdata": [ - [ - "1, Caldwell Street, Stockwell", - 995000, - 2, - 4, - "Other", - "https://www.zoopla.co.uk/for-sale/details/73326946/", - 51.477238, - -0.116819 - ], - [ - "Flat 27, Addington House,, Stockwell Road, Stockwell, London", - 350000, - 1, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/72554891/", - 51.468221, - -0.118798 - ], - [ - "1, Stockwell Park Road, London", - 1695000, - 3, - 5, - "Semi-Detached", - "https://www.zoopla.co.uk/for-sale/details/69392186/", - 51.474381, - -0.119192 - ], - [ - "Flat 11 Beale House, 45, Lingham Street, Stockwell, London", - 525000, - 2, - 3, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73306789/", - 51.469424, - -0.122658 - ], - [ - "17, Houghton Square, London", - 500000, - 2, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73302918/", - 51.46795, - -0.129002 - ], - [ - "Flat 4,, Cleveland House, Hackford Road, London", - 515000, - 1, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73302851/", - 51.477508, - -0.115029 - ], - [ - "chpk0226649, Hemberton Road, Clapham North, London", - 475000, - 1, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/71215394/", - 51.466593, - -0.125681 - ], - [ - "Flat 59, 151, Stockwell Road", - 465000, - 1, - 1, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73250562/", - 51.466529, - -0.117086 - ], - [ - "First Floor Flat, 70, Fenwick Place", - 599950, - 1, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73268982/", - 51.464473, - -0.12876 - ], - [ - "Flat C, 58, Loughborough Road", - 375000, - 1, - 1, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73268027/", - 51.470695, - -0.108771 - ], - [ - "Flat 7, 5, Eythorne Road, Oval", - 575000, - 2, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73266802/", - 51.475345, - -0.108351 - ], - [ - "chpk3677610, Yates Court, Stockwell, London", - 475000, - 1, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73261921/", - 51.472181, - -0.12142 - ], - [ - "Beam, Lambeth SW9, New home", - 580000, - 2, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/new-homes/details/73247019/", - 51.476628, - -0.10787 - ], - [ - "Beam, Lambeth SW9, New home", - 595000, - 2, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/new-homes/details/73246935/", - 51.476628, - -0.10787 - ], - [ - "Stockwell Road, Brixton SW9, New home", - 575000, - 2, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/new-homes/details/73239981/", - 51.4674179004739, - -0.122737777251185 - ], - [ - "Flat 17, Draymans Court, 41, Stockwell Green, London", - 375000, - 1, - 1, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73239240/", - 51.467439, - -0.118432 - ], - [ - "72, Hargwyne Street, Stockwell", - 1050000, - 3, - 4, - "Other", - "https://www.zoopla.co.uk/for-sale/details/73231221/", - 51.46622, - -0.121542 - ], - [ - "Flat 5, 18, Brighton Terrace, London", - 375000, - 1, - 1, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73225986/", - 51.461928, - -0.117304 - ], - [ - "Flat 3, 1, Offenham Road, Oval", - 498000, - 1, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73224383/", - 51.475892, - -0.109228 - ], - [ - "Handforth Road, London", - 550000, - 2, - 3, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73216028/", - 51.479309, - -0.113843 - ], - [ - "First Floor Flat, 3, Crewdson Road, Oval", - 525000, - 1, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73195760/", - 51.47869, - -0.112493 - ], - [ - "chpk3632024, Hillyard Street, Oval, London", - 475000, - 1, - 1, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73184722/", - 51.474134, - -0.114802 - ], - [ - "74, Stockwell Park Road, London", - 2100000, - 3, - 4, - "Terraced", - "https://www.zoopla.co.uk/for-sale/details/73183355/", - 51.47089, - -0.116765 - ], - [ - "Flat 12, 5, Eythorne Road, Oval", - 435000, - 1, - 1, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73178440/", - 51.475345, - -0.108351 - ], - [ - "Flat 7, 162, Brixton Road, London", - 340000, - 1, - 1, - "Other", - "https://www.zoopla.co.uk/for-sale/details/73177281/", - 51.475028, - -0.113055 - ], - [ - "12, Burnley Road, London", - 1595000, - 2, - 5, - "Terraced", - "https://www.zoopla.co.uk/for-sale/details/73170265/", - 51.470986, - -0.119194 - ], - [ - "16 Leda Court, Hackford Rd, Oval", - 425000, - 1, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/71247456/", - 51.477172, - -0.11466 - ], - [ - "Flat 8, 90, Clapham Road, Oval", - 300000, - 1, - 1, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/72100650/", - 51.478889, - -0.115641 - ], - [ - "Flat 14, 27, Hillyard Street, Oval", - 385000, - 1, - 1, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/72779518/", - 51.474212, - -0.114897 - ], - [ - "Flat 1 27, Hillyard Street, Oval, London", - 525000, - 1, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/72779557/", - 51.474262, - -0.114798 - ], - [ - "Amberley Court, Angell Road, London", - 390000, - 1, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/72978875/", - 51.467494, - -0.107537 - ], - [ - "118c, Landor Road, Clapham North", - 400000, - 1, - 1, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73160783/", - 51.466708, - -0.122739 - ], - [ - "chpk4025655, Milles Square, Brixton, London", - 500000, - 2, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73162720/", - 51.462364, - -0.110925 - ], - [ - "Clapham Road, Oval, London", - 550000, - 1, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73163252/", - 51.480763, - -0.113092 - ], - [ - "31a, Tunstall Road, Brixton, London", - 599950, - 1, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/71394847/", - 51.462399, - -0.117013 - ], - [ - "Flat 7, 376, Clapham Road, London", - 675000, - 2, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/73157265/", - 51.468123, - -0.128106 - ], - [ - "4, Rathgar Road, London", - 425000, - 1, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/64039312/", - 51.466029, - -0.102351 - ], - [ - "Flat 14, Vincent Court, Stockwell, London", - 350000, - 1, - 1, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/66790369/", - 51.47413, - -0.115666 - ], - [ - "Top floor, 62, Hemberton Road, Clapham", - 600000, - 1, - 3, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/66921521/", - 51.466328, - -0.126008 - ], - [ - "Zachary House, Lett Road, London", - 440000, - 1, - 1, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/67561303/", - 51.476216, - -0.117323 - ], - [ - "Beam, Oval SW9, New home", - 580000, - 2, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/new-homes/details/68885348/", - 51.476417, - -0.108425 - ], - [ - "Cancell Road, London SW9, New home", - 630000, - 2, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/new-homes/details/68885354/", - 51.476417, - -0.108425 - ], - [ - "86B, Landor Road, Stockwell", - 450000, - 1, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/69092765/", - 51.465884, - -0.125154 - ], - [ - "Beam, Oval SW9, New home", - 638000, - 2, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/new-homes/details/69141398/", - 51.476417, - -0.108425 - ], - [ - "Beam, Oval SW9, New home", - 580000, - 2, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/new-homes/details/69141898/", - 51.476417, - -0.108425 - ], - [ - "Beam, Oval SW9, New home", - 595000, - 2, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/new-homes/details/69141934/", - 51.476417, - -0.108425 - ], - [ - "Flat 8, Newson House, Brixton", - 101250, - 1, - 1, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/69345262/", - 51.458477, - -0.105774 - ], - [ - "Flat 2,, Haverfield House, 31 Clapham Road, London", - 445000, - 1, - 1, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/69477612/", - 51.480039, - -0.114014 - ], - [ - "29, Rupert Gardens, Stockwell", - 325000, - 1, - 4, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/69802039/", - 51.467677, - -0.104615 - ], - [ - "London, London", - 190000, - 1, - 1, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/69841147/", - 51.470153, - -0.115445 - ], - [ - "chpk2498574, Hopton House, Brixton, London", - 400000, - 1, - 3, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/69909713/", - 51.468284, - -0.106102 - ], - [ - "70, Hargwyne Street, Brixton", - 530000, - 1, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/69917093/", - 51.465846, - -0.121333 - ], - [ - "Flat 1, 9, Dundas Road, London", - 650000, - 2, - 3, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/69969115/", - 51.472982, - -0.10968 - ], - [ - "25, Fitzpatrick Road, London", - 625000, - 1, - 3, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/70045361/", - 51.475681, - -0.10581 - ], - [ - "361, Clapham Road, London", - 650000, - 1, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/70056401/", - 51.467428, - -0.127914 - ], - [ - "Flat 9, Ferndale Road, London", - 295000, - 1, - 1, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/70256633/", - 51.462776, - -0.122019 - ], - [ - "Flat 7, 2, Offenham Road, Oval, London", - 570000, - 2, - 2, - "Flats/Maisonettes", - "https://www.zoopla.co.uk/for-sale/details/70308376/", - 51.476, - -0.109 - ], - [ - "2A, Tasman Road, Clapham North", - 700000, - 1, - 2, - "Terraced", - "https://www.zoopla.co.uk/for-sale/details/70335716/", - 51.465724, - -0.125134 - ] - ], - "hovertemplate": "<b>%{hovertext}</b><br><br>provider=Zoopla<br>Address per Property Register=%{customdata[0]}<br>Asking price=%{customdata[1]:,.0f}<br>Bathrooms=%{customdata[2]}<br>Bedrooms=%{customdata[3]}<br>Property type=%{customdata[4]}<br>Listing URL=%{customdata[5]}<extra></extra>", - "hovertext": [ - "SW9 0HD", - "SW9 0TZ", - "SW9 0AP", - "SW9 9HG", - "SW9 9AN", - "SW9 0ET", - "SW9 9LF", - "SW9 9FX", - "SW9 9NW", - "SW9 7SB", - "SW9 7RH", - "SW9 9AU", - "SW9 6HP", - "SW9 6HP", - "SW9 9FX", - "SW9 9QE", - "SW9 9RJ", - "SW9 8DG", - "SW9 7BN", - "SW9 0LL", - "SW9 0LH", - "SW9 0NG", - "SW9 0DA", - "SW9 7RH", - "SW9 6AU", - "SW9 0SH", - "SW9 0EU", - "SW9 0JJ", - "SW9 0NG", - "SW9 0NG", - "SW9 7HL", - "SW9 9NT", - "SW9 8GA", - "SW9 0JP", - "SW9 8BZ", - "SW9 9AR", - "SW9 7EL", - "SW9 0QU", - "SW9 9LJ", - "SW9 0AF", - "SW9 6HN", - "SW9 6HN", - "SW9 9PE", - "SW9 6HN", - "SW9 6HN", - "SW9 6HN", - "SW9 8FU", - "SW9 0JD", - "SW9 7TL", - "SW9 0BF", - "SW9 7SP", - "SW9 9RG", - "SW9 6BZ", - "SW9 7AZ", - "SW9 9BT", - "SW4 7RU", - "SW9 7BN", - "SW9 9LT" - ], - "lat": { - "bdata": "SDSBIha9SUB0Jm2q7rtJQAFsQIS4vElAj/rrFRa8SUDkFB3J5btJQAjKbfsevUlAcsXFUbm7SUBb0eY4t7tJQABw7Nlzu0lAA7LXuz+8SUCXqN4a2LxJQHNlUG1wvElAzy10JQK9SUDPLXQlAr1JQNkMilnUu0lA/u+ICtW7SUDdXtIYrbtJQKiN6nQgu0lAyjZwB+q8SUDY1k//Wb1JQAx2w7ZFvUlA+fVDbLC8SUC4AZ8fRrxJQJeo3hrYvElAl1eut828SUDbb+1ESbxJQJFI2/gTvUlAA7UYPEy9SUB1r5P6srxJQCfeAZ60vElAwono19a7SUAKZHYWvbtJQINsWb4uu0lAPRBZpIm9SUD/WfPjL7tJQLHAV3Tru0lAaf6Y1qa7SUC4BrZKsLxJQMOayqKwu0lAfepYpfS8SUAUIXU7+7xJQBQhdTv7vElAZt0/FqK7SUAUIXU7+7xJQBQhdTv7vElAFCF1O/u8SUDue9Rfr7pJQPvm/upxvUlAswsG19y7SUDjjjf5LbxJQLqe6Lrwu0lAeHx716C7SUBgzJasirxJQA8qcR3jvElACp5CrtS7SUDVr3Q+PLtJQLByaJHtvElALXsS2Jy7SUA=", - "dtype": "f8" - }, - "legendgroup": "Zoopla", - "lon": { - "bdata": "ICqNmNnnvb+DiNS0i2m+v4Pg8e1dg76/pb+XwoNmv78GLo81I4PAvw1yF2GKcr2/+kFdpFAWwL/ex9EcWfm9vwk4hCo1e8C/xNLAj2rYu79KKH0h5Ly7v9qPFJFhFb+/djI4Sl6du792MjhKXp27v/sORzO+a7+/acTMPo9Rvr+NJhdjYB2/v8uisIuiB76/ibfOv132u7825+CZ0CS9v9NnB1xXzLy/u/CD86ljvb+/Q1GgT+S9v0oofSHkvLu/NzemJyzxvL/uIeF7f4O+v9HLKJZbWr2/+KQTCaaavb8+lGjJ42m9v+NtpddmY72/0CUceouHu781mfG20mu/v4QNT6+UZby/gnFw6ZjzvL/+8zRgkPS9v6bvNQTHZcC/WoC21awzur+9VkJ3SZy9vyxmhLcHIcC/S5ARUOEIvr/gnBGlvcG7v+CcEaW9wbu/uFZ72AsFwL/gnBGlvcG7v+CcEaW9wbu/4JwRpb3Bu7/uYMQ+ARS7v7xASYEFML2/R8mrcwzIur+vmXyzzY29vwZKCiyAKbu/BvLs8q0Pv7/AeAYN/RO8v4P6ljldFru/batZZ3xfwL+JmX0eozy/v4GVQ4ts57u/nQ/PEmQEwL8=", - "dtype": "f8" - }, - "marker": { - "color": "#dc2626", - "opacity": 0.65, - "size": 5 - }, - "mode": "markers", - "name": "Zoopla", - "showlegend": true, - "subplot": "map", - "type": "scattermap" - } - ], - "layout": { - "height": 800, - "legend": { - "title": { - "text": "Provider" - }, - "tracegroupgap": 0 - }, - "map": { - "center": { - "lat": 51.47029892778563, - "lon": -0.11608637408049434 - }, - "domain": { - "x": [ - 0, - 1 - ], - "y": [ - 0, - 1 - ] - }, - "style": "open-street-map", - "zoom": 9 - }, - "mapbox": { - "center": { - "lat": 51.47029892778563, - "lon": -0.11608637408049434 - }, - "zoom": 9 - }, - "margin": { - "b": 0, - "l": 0, - "r": 0, - "t": 45 - }, - "template": { - "data": { - "bar": [ - { - "error_x": { - "color": "#2a3f5f" - }, - "error_y": { - "color": "#2a3f5f" - }, - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "bar" - } - ], - "barpolar": [ - { - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "barpolar" - } - ], - "carpet": [ - { - "aaxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "baxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "type": "carpet" - } - ], - "choropleth": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "choropleth" - } - ], - "contour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "contour" - } - ], - "contourcarpet": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "contourcarpet" - } - ], - "heatmap": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmap" - } - ], - "histogram": [ - { - "marker": { - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "histogram" - } - ], - "histogram2d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2d" - } - ], - "histogram2dcontour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2dcontour" - } - ], - "mesh3d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "mesh3d" - } - ], - "parcoords": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "parcoords" - } - ], - "pie": [ - { - "automargin": true, - "type": "pie" - } - ], - "scatter": [ - { - "fillpattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - }, - "type": "scatter" - } - ], - "scatter3d": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatter3d" - } - ], - "scattercarpet": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattercarpet" - } - ], - "scattergeo": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergeo" - } - ], - "scattergl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergl" - } - ], - "scattermap": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattermap" - } - ], - "scattermapbox": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattermapbox" - } - ], - "scatterpolar": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolar" - } - ], - "scatterpolargl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolargl" - } - ], - "scatterternary": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterternary" - } - ], - "surface": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "surface" - } - ], - "table": [ - { - "cells": { - "fill": { - "color": "#EBF0F8" - }, - "line": { - "color": "white" - } - }, - "header": { - "fill": { - "color": "#C8D4E3" - }, - "line": { - "color": "white" - } - }, - "type": "table" - } - ] - }, - "layout": { - "annotationdefaults": { - "arrowcolor": "#2a3f5f", - "arrowhead": 0, - "arrowwidth": 1 - }, - "autotypenumbers": "strict", - "coloraxis": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "colorscale": { - "diverging": [ - [ - 0, - "#8e0152" - ], - [ - 0.1, - "#c51b7d" - ], - [ - 0.2, - "#de77ae" - ], - [ - 0.3, - "#f1b6da" - ], - [ - 0.4, - "#fde0ef" - ], - [ - 0.5, - "#f7f7f7" - ], - [ - 0.6, - "#e6f5d0" - ], - [ - 0.7, - "#b8e186" - ], - [ - 0.8, - "#7fbc41" - ], - [ - 0.9, - "#4d9221" - ], - [ - 1, - "#276419" - ] - ], - "sequential": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "sequentialminus": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ] - }, - "colorway": [ - "#636efa", - "#EF553B", - "#00cc96", - "#ab63fa", - "#FFA15A", - "#19d3f3", - "#FF6692", - "#B6E880", - "#FF97FF", - "#FECB52" - ], - "font": { - "color": "#2a3f5f" - }, - "geo": { - "bgcolor": "white", - "lakecolor": "white", - "landcolor": "#E5ECF6", - "showlakes": true, - "showland": true, - "subunitcolor": "white" - }, - "hoverlabel": { - "align": "left" - }, - "hovermode": "closest", - "mapbox": { - "style": "light" - }, - "paper_bgcolor": "white", - "plot_bgcolor": "#E5ECF6", - "polar": { - "angularaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "radialaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "scene": { - "xaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "yaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "zaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - } - }, - "shapedefaults": { - "line": { - "color": "#2a3f5f" - } - }, - "ternary": { - "aaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "baxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "caxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "title": { - "x": 0.05 - }, - "xaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - }, - "yaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - } - } - }, - "title": { - "text": "Buy listings by source" - } - } - } + "text/html": [ + "<div><style>\n", + ".dataframe > thead > tr,\n", + ".dataframe > tbody > tr {\n", + " text-align: right;\n", + " white-space: pre-wrap;\n", + "}\n", + "</style>\n", + "<small>shape: (15, 2)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>Property sub-type</th><th>count</th></tr><tr><td>str</td><td>u32</td></tr></thead><tbody><tr><td>"Flat"</td><td>64390</td></tr><tr><td>"Terraced"</td><td>10532</td></tr><tr><td>"Semi-Detached"</td><td>10170</td></tr><tr><td>"Detached"</td><td>7610</td></tr><tr><td>"End Of Terrace"</td><td>3747</td></tr><tr><td>"House"</td><td>3590</td></tr><tr><td>"Maisonette"</td><td>3196</td></tr><tr><td>"Studio"</td><td>1503</td></tr><tr><td>"Retirement Property"</td><td>891</td></tr><tr><td>"Ground Flat"</td><td>889</td></tr><tr><td>"Unknown"</td><td>842</td></tr><tr><td>"Bungalow"</td><td>797</td></tr><tr><td>"Penthouse"</td><td>735</td></tr><tr><td>"Detached Bungalow"</td><td>577</td></tr><tr><td>"Town House"</td><td>523</td></tr></tbody></table></div>" + ], + "text/plain": [ + "shape: (15, 2)\n", + "┌─────────────────────┬───────┐\n", + "│ Property sub-type ┆ count │\n", + "│ --- ┆ --- │\n", + "│ str ┆ u32 │\n", + "╞═════════════════════╪═══════╡\n", + "│ Flat ┆ 64390 │\n", + "│ Terraced ┆ 10532 │\n", + "│ Semi-Detached ┆ 10170 │\n", + "│ Detached ┆ 7610 │\n", + "│ End Of Terrace ┆ 3747 │\n", + "│ House ┆ 3590 │\n", + "│ Maisonette ┆ 3196 │\n", + "│ Studio ┆ 1503 │\n", + "│ Retirement Property ┆ 891 │\n", + "│ Ground Flat ┆ 889 │\n", + "│ Unknown ┆ 842 │\n", + "│ Bungalow ┆ 797 │\n", + "│ Penthouse ┆ 735 │\n", + "│ Detached Bungalow ┆ 577 │\n", + "│ Town House ┆ 523 │\n", + "└─────────────────────┴───────┘" + ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ - "map_df = (\n", - " df.filter(\n", - " pl.col(\"lat\").is_not_null()\n", - " & pl.col(\"lon\").is_not_null()\n", - " & pl.col(\"lat\").is_between(49, 56)\n", - " & pl.col(\"lon\").is_between(-1, 1)\n", - " )\n", - " .select(\n", - " \"provider\",\n", - " \"lat\",\n", - " \"lon\",\n", - " \"Postcode\",\n", - " \"Address per Property Register\",\n", - " \"Asking price\",\n", - " \"Bathrooms\",\n", - " \"Bedrooms\",\n", - " \"Property type\",\n", - " \"Listing URL\",\n", - " )\n", - " .to_pandas()\n", + "print(\"Property sub-type distinct: raw\", raw[\"Property sub-type\"].n_unique(),\n", + " \" -> clean\", clean[\"Property sub-type\"].n_unique())\n", + "casing = (\n", + " clean.filter(pl.col(\"Price qualifier\").is_not_null())\n", + " .with_columns(pl.col(\"Price qualifier\").str.to_lowercase().alias(\"n\"))\n", + " .group_by(\"n\").agg(pl.col(\"Price qualifier\").n_unique().alias(\"variants\"))\n", + " .filter(pl.col(\"variants\") > 1).height\n", ")\n", + "print(\"Price-qualifier casing-duplicate buckets remaining:\", casing)\n", + "display(clean[\"Property sub-type\"].value_counts(sort=True).head(15))" + ] + }, + { + "cell_type": "markdown", + "id": "94ac0585", + "metadata": {}, + "source": [ + "**Before/after — key metrics chart:**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b7aed7d0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T07:34:31.981991Z", + "iopub.status.busy": "2026-06-03T07:34:31.981907Z", + "iopub.status.idle": "2026-06-03T07:34:32.146617Z", + "shell.execute_reply": "2026-06-03T07:34:32.146178Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1100x396 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "labels = [\"impossible\\ntiny area\", \"£/sqm max\\n(÷1000)\", \"sub-type\\ndistinct\", \"0-bed\\nnon-studio\", \"qualifier\\ncasing dupes\"]\n", + "before = [\n", + " raw.filter((pl.col(\"Total floor area (sqm)\") < 20) & (pl.col(\"Bedrooms\") >= 2)).height,\n", + " raw[\"Asking price per sqm\"].max() / 1000,\n", + " raw[\"Property sub-type\"].n_unique(),\n", + " raw.filter((pl.col(\"Bedrooms\") == 0) & (pl.col(\"Property sub-type\") != \"Studio\")).height,\n", + " 6,\n", + "]\n", + "after = [\n", + " clean.filter((pl.col(\"Total floor area (sqm)\") < 20) & (pl.col(\"Bedrooms\").fill_null(0) >= 2)).height,\n", + " clean[\"Asking price per sqm\"].max() / 1000,\n", + " clean[\"Property sub-type\"].n_unique(),\n", + " clean.filter((pl.col(\"Bedrooms\") == 0) & (pl.col(\"Property sub-type\") != \"Studio\")).height,\n", + " 0,\n", + "]\n", + "x = np.arange(len(labels)); w = 0.38\n", + "fig, ax = plt.subplots(figsize=(10, 3.6))\n", + "b1 = ax.bar(x - w / 2, before, w, label=\"raw\", color=\"#dc2626\")\n", + "b2 = ax.bar(x + w / 2, after, w, label=\"clean\", color=\"#16a34a\")\n", + "ax.set_xticks(x); ax.set_xticklabels(labels, fontsize=8)\n", + "ax.set_yscale(\"symlog\"); ax.set_ylabel(\"value (symlog)\")\n", + "ax.set_title(\"Before / after cleanup\"); ax.legend()\n", + "for bars in (b1, b2):\n", + " ax.bar_label(bars, fmt=\"%.0f\", fontsize=7, padding=2)\n", + "plt.tight_layout(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f680553a", + "metadata": {}, + "source": [ + "## Caveats\n", "\n", - "print(f\"Mapped rows: {len(map_df):,}\")\n", - "\n", - "fig = px.scatter_map(\n", - " map_df,\n", - " lat=\"lat\",\n", - " lon=\"lon\",\n", - " color=\"provider\",\n", - " color_discrete_map={\n", - " \"Rightmove\": \"#2563eb\",\n", - " \"OnTheMarket\": \"#16a34a\",\n", - " \"Zoopla\": \"#dc2626\",\n", - " \"Unknown\": \"#6b7280\",\n", - " },\n", - " hover_name=\"Postcode\",\n", - " hover_data={\n", - " \"Address per Property Register\": True,\n", - " \"Asking price\": \":,.0f\",\n", - " \"Bathrooms\": True,\n", - " \"Bedrooms\": True,\n", - " \"Property type\": True,\n", - " \"Listing URL\": True,\n", - " \"lat\": False,\n", - " \"lon\": False,\n", - " },\n", - " zoom=9,\n", - " height=800,\n", - " title=\"Buy listings by source\",\n", - ")\n", - "fig.update_traces(marker={\"size\": 5, \"opacity\": 0.65})\n", - "fig.update_layout(\n", - " map_style=\"open-street-map\",\n", - " legend_title_text=\"Provider\",\n", - " margin={\"l\": 0, \"r\": 0, \"t\": 45, \"b\": 0},\n", - ")\n", - "fig.show()" + "- **`clean` keeps every row** (issues are flagged, not dropped) so it stays comparable to `raw`; use the\n", + " `is_residential` / `is_shared_ownership` / `floor_area_suspect_*` / `location_precision` flags to filter.\n", + "- **Shared-ownership full prices cannot be recovered** here — those rows are flagged and excluded from\n", + " `£/sqm`, but their `Asking price` is still a share. Likewise **suspiciously-large areas are flagged,\n", + " not auto-converted** from sq ft (the conversion factor isn't certain per-row).\n", + "- **De-dup is heuristic** (`lat,lon,price,beds`); it can over-collapse distinct units sharing a\n", + " development-centroid coordinate and under-collapse cross-portal dupes with differing prices. Treat\n", + " `dedup` as an analytics view and `raw` as the source of record.\n", + "- The cleanest *upstream* fixes belong in the `finder` pipeline (`storage.py` / per-portal transforms):\n", + " correct the beds/living-rooms column, normalise qualifiers, add a beds-aware area gate, emit a\n", + " precision flag, and resolve property identity across sources." ] } ], diff --git a/pipeline/download/median_age.py b/pipeline/download/median_age.py index b02c43d..1831d34 100644 --- a/pipeline/download/median_age.py +++ b/pipeline/download/median_age.py @@ -72,6 +72,18 @@ assert len(EXPECTED_BAND_NAMES) == len(AGE_BANDS), ( "EXPECTED_BAND_NAMES and AGE_BANDS must stay aligned 1:1" ) +# NOMIS sometimes labels a band with a wording variant that denotes the SAME +# age range (e.g. "Aged 4 years and under" for ages 0-4, "Aged 90 years and +# over" wording for the top band). Map such known-equivalent labels back to the +# canonical name BEFORE validation so a real band change still fails loudly, +# but a cosmetic relabel of an identical range does not block the build. +BAND_NAME_ALIASES = { + "Aged 4 years and under": "Aged 0 to 4 years", +} +assert set(BAND_NAME_ALIASES.values()) <= set(EXPECTED_BAND_NAMES), ( + "BAND_NAME_ALIASES must map to canonical EXPECTED_BAND_NAMES" +) + def compute_median_age(counts: list[int]) -> float: """Compute median age from five-year band counts using linear interpolation.""" @@ -98,6 +110,15 @@ def _bands_to_median_table(pivoted: pl.DataFrame) -> pl.DataFrame: missing/extra/relabelled band would otherwise silently mis-align counts against the wrong AGE_BANDS lower bound, so we fail loudly instead. """ + # Normalise known-equivalent NOMIS label variants to their canonical name + # before validating (renaming onto an already-present canonical column would + # collide, so polars raises loudly in that genuinely ambiguous case). + rename_map = { + c: BAND_NAME_ALIASES[c] for c in pivoted.columns if c in BAND_NAME_ALIASES + } + if rename_map: + pivoted = pivoted.rename(rename_map) + # Validate the pivoted age-band columns against the canonical NOMIS set # BEFORE computing anything. band_cols = [c for c in pivoted.columns if c != "GEOGRAPHY_CODE"] diff --git a/pipeline/download/noise.py b/pipeline/download/noise.py index 545f559..5811511 100644 --- a/pipeline/download/noise.py +++ b/pipeline/download/noise.py @@ -266,8 +266,12 @@ def _download_tile( except ( NoGeoTiffError, httpx.HTTPStatusError, - httpx.TimeoutException, - httpx.ConnectError, + # TransportError is the superset of TimeoutException, ConnectError, + # ReadError and ProtocolError — including RemoteProtocolError, raised + # when the WCS server closes the connection mid-stream ("incomplete + # chunked read"). All are transient; retry/split rather than letting + # one flaky tile crash the whole raster download. + httpx.TransportError, ) as e: last_error = e if attempt < MAX_RETRIES: diff --git a/pipeline/download/test_median_age.py b/pipeline/download/test_median_age.py index ccff9f4..7d322b7 100644 --- a/pipeline/download/test_median_age.py +++ b/pipeline/download/test_median_age.py @@ -57,6 +57,21 @@ def test_null_band_count_is_treated_as_zero_not_crash(): assert table["median_age"][0] == pytest.approx(32.5) +def test_equivalent_band_label_alias_is_accepted(): + # NOMIS relabelled the first band "Aged 4 years and under" (same as ages + # 0-4). It must be normalised to the canonical name and used as band 0, not + # rejected. All 100 people in that band -> median in the 0-4 range: 2.5. + counts_by_band = {name: [0] for name in EXPECTED_BAND_NAMES} + counts_by_band["Aged 4 years and under"] = counts_by_band.pop("Aged 0 to 4 years") + counts_by_band["Aged 4 years and under"] = [100] + pivoted = _pivoted(counts_by_band) + + table = median_age._bands_to_median_table(pivoted) + + assert table.height == 1 + assert table["median_age"][0] == pytest.approx(2.5) + + def test_missing_band_raises_clear_error(): counts_by_band = {name: [10] for name in EXPECTED_BAND_NAMES} del counts_by_band["Aged 85 years and over"] diff --git a/pipeline/transform/postcode_boundaries/geometry.py b/pipeline/transform/postcode_boundaries/geometry.py new file mode 100644 index 0000000..3fd85a4 --- /dev/null +++ b/pipeline/transform/postcode_boundaries/geometry.py @@ -0,0 +1,123 @@ +"""Robust GEOS overlay helpers. + +Overlay operations (union, difference, intersection) can raise a +``GEOSException`` — most often ``TopologyException: side location conflict``, +``Ring edge missing``, or ``found non-noded intersection`` — on geometries that +contain near-coincident or near-degenerate edges, or that are individually +invalid. The robust remedy is a *fixed-precision* overlay: GEOS's OverlayNG +engine, handed a grid size, nodes every edge onto that grid and finishes where +the full-precision overlay cannot. + +Getting the fallback to actually survive takes three rules, each of which we +learned the hard way from a crash: + +1. **Never precision-reduce with the default mode.** ``set_precision``'s default + ``valid_output`` (and ``keep_collapsed``) mode runs its *own* noding pass that + re-raises the very ``side location conflict`` we are trying to escape. We push + the grid into the overlay via the ``grid_size`` argument instead — where + OverlayNG nodes robustly — and only ever call ``set_precision`` in + ``pointwise`` mode (pure coordinate rounding, which cannot raise). +2. **Validate first.** ``make_valid`` repairs the self-intersections (bow-ties, + pinches) that make GEOS choke, so the overlay starts from an OGC-valid shape. +3. **Keep only polygonal parts.** ``make_valid`` of a spiky polygon routinely + returns a *mixed-dimension* ``GeometryCollection`` (a polygon plus a dangling + line), and OverlayNG rejects mixed-dimension input with + ``IllegalArgumentException: Overlay input is mixed-dimension``. Every input + here represents an area, so the line/point debris is meaningless noise and is + dropped before the overlay. + +The default fallback grid is 0.1 mm in the metre-based working CRS +(EPSG:27700), far below survey resolution and the ``MIN_GEOM_AREA`` threshold +downstream, so it cannot crush a postcode-scale shape. Callers operating in a +different CRS (e.g. the WGS84 output stage, where the same 1e-4 grid would be +~11 m) pass a ``grid`` matched to that CRS. The whole fallback runs ONLY after +the exact operation has already failed, so normal output is bit-for-bit +unchanged. +""" + +import shapely +from shapely import GEOSException, make_valid, set_precision +from shapely.geometry import Polygon +from shapely.ops import unary_union + +# 0.1 mm in metres — well below MIN_GEOM_AREA (0.01 m^2) and survey resolution. +_SNAP_GRID = 1e-4 + +_EMPTY = Polygon() + + +def _poly_valid(geom, grid): + """Return an OGC-valid, polygonal-only version of ``geom``. + + Repairs invalidity with ``make_valid`` and discards any non-polygonal debris + (dangling lines/points) it leaves behind, since OverlayNG rejects + mixed-dimension ``GeometryCollection`` input. The result is always a + ``Polygon``/``MultiPolygon`` (possibly empty), safe to feed to a + fixed-precision overlay. + """ + g = geom if geom.is_valid else make_valid(geom) + if g.geom_type in ("Polygon", "MultiPolygon"): + return g + if g.geom_type == "GeometryCollection": + polys = [ + p + for p in g.geoms + if p.geom_type in ("Polygon", "MultiPolygon") and not p.is_empty + ] + if not polys: + return _EMPTY + if len(polys) == 1: + return polys[0] + # Dissolve on the grid (robust) rather than building a possibly-invalid + # MultiPolygon of overlapping parts. + return shapely.union_all(polys, grid_size=grid) + return _EMPTY # line / point only + + +def _snap_poly_valid(geom, grid): + """Coordinate-round onto ``grid`` (``pointwise`` never raises), then clean.""" + return _poly_valid(set_precision(geom, grid, mode="pointwise"), grid) + + +def safe_union(geoms, grid=_SNAP_GRID): + """``unary_union`` that survives GEOS robustness failures.""" + try: + return unary_union(geoms) + except GEOSException: + pass + cleaned = [_poly_valid(g, grid) for g in geoms] + try: + return shapely.union_all(cleaned, grid_size=grid) + except GEOSException: + snapped = [_snap_poly_valid(g, grid) for g in geoms] + return shapely.union_all(snapped, grid_size=grid) + + +def safe_difference(a, b, grid=_SNAP_GRID): + """``a.difference(b)`` that survives GEOS robustness failures.""" + try: + return a.difference(b) + except GEOSException: + pass + a2, b2 = _poly_valid(a, grid), _poly_valid(b, grid) + try: + return shapely.difference(a2, b2, grid_size=grid) + except GEOSException: + return shapely.difference( + _snap_poly_valid(a2, grid), _snap_poly_valid(b2, grid), grid_size=grid + ) + + +def safe_intersection(a, b, grid=_SNAP_GRID): + """``a.intersection(b)`` that survives GEOS robustness failures.""" + try: + return a.intersection(b) + except GEOSException: + pass + a2, b2 = _poly_valid(a, grid), _poly_valid(b, grid) + try: + return shapely.intersection(a2, b2, grid_size=grid) + except GEOSException: + return shapely.intersection( + _snap_poly_valid(a2, grid), _snap_poly_valid(b2, grid), grid_size=grid + ) diff --git a/pipeline/transform/postcode_boundaries/greenspace.py b/pipeline/transform/postcode_boundaries/greenspace.py index 898474b..2d81c8f 100644 --- a/pipeline/transform/postcode_boundaries/greenspace.py +++ b/pipeline/transform/postcode_boundaries/greenspace.py @@ -5,9 +5,10 @@ from pathlib import Path import polars as pl from shapely import wkb from shapely.geometry import MultiPolygon, Polygon -from shapely.ops import unary_union from shapely.strtree import STRtree +from .geometry import safe_difference, safe_union + def load_greenspace(path: Path) -> tuple[STRtree, list]: """Load greenspace parquet and build an STRtree spatial index. @@ -51,8 +52,8 @@ def subtract_greenspace( if not intersecting: return postcode_geom - green_union = unary_union(intersecting) - result = postcode_geom.difference(green_union) + green_union = safe_union(intersecting) + result = safe_difference(postcode_geom, green_union) if result.is_empty: return postcode_geom diff --git a/pipeline/transform/postcode_boundaries/output.py b/pipeline/transform/postcode_boundaries/output.py index d65a261..fa881fc 100644 --- a/pipeline/transform/postcode_boundaries/output.py +++ b/pipeline/transform/postcode_boundaries/output.py @@ -7,11 +7,12 @@ import numpy as np from pyproj import Transformer from shapely import STRtree, make_valid, set_precision from shapely.errors import GEOSException -from shapely.geometry import MultiPolygon, Polygon, mapping, shape +from shapely.geometry import MultiPolygon, Polygon, box, mapping, shape from shapely.ops import transform as transform_geometry -from shapely.ops import unary_union from tqdm import tqdm +from .geometry import safe_difference, safe_union + _to_wgs84 = None @@ -207,7 +208,7 @@ def merge_fragments( merged = {} for pc, parts in by_postcode.items(): - combined = unary_union(parts) + combined = safe_union(parts) if combined.is_empty: continue if not combined.is_valid: @@ -260,7 +261,10 @@ def _polygonal(geom): ] if not polys: return None - merged = unary_union(polys) + # Both callers run on WGS84-degree output geometry, so the robustness + # fallback snaps on the 1e-6° grid (~0.11 m), not geometry.py's metre + # default — a coarse metre grid would obliterate a degree-scale shape. + merged = safe_union(polys, grid=_OUTPUT_PRECISION_DEG) return merged if not merged.is_empty else None return None @@ -317,8 +321,13 @@ def _resolve_overlaps( # Process losers from highest priority down, so every subtracted neighbour is # already finalised. for i in sorted(higher, key=lambda idx: rank[idx]): - cut = unary_union([out[j] for j in higher[i]]) - trimmed = out[i].difference(cut) + # These geometries are WGS84 degrees already snapped to output precision, + # so the robustness fallback snaps on the same 1e-6° grid (~0.11 m) rather + # than geometry.py's metre-CRS default. A raw difference can still raise a + # "side location conflict" on near-coincident OA-seam edges; the + # fixed-precision overlay noded them away. + cut = safe_union([out[j] for j in higher[i]], grid=_OUTPUT_PRECISION_DEG) + trimmed = safe_difference(out[i], cut, grid=_OUTPUT_PRECISION_DEG) if not trimmed.is_valid: trimmed = make_valid(trimmed) # Keep all polygonal parts: these geometries are in WGS84 degrees, so an @@ -336,13 +345,83 @@ def _round_coords(coords, ndigits=6): return [_round_coords(c, ndigits) for c in coords] +def _snap_polygonal(geom, grid): + """Re-node ``geom`` onto ``grid`` (``valid_output``) → polygonal-only, or None. + + ``set_precision`` ``valid_output`` runs an OverlayNG noding pass that places + every vertex on a multiple of ``grid`` *and* fixes the topology, so a plain + coordinate round of the result is exact (no two distinct vertices can land in + the same cell). Falls back to ``make_valid`` if precision-reduction raises. + """ + try: + snapped = set_precision(geom, grid, mode="valid_output") + except GEOSException: + snapped = make_valid(geom) + return _polygonal(snapped if snapped.is_valid else make_valid(snapped)) + + +# A square this many output-grid cells on a side, used as the last-resort +# footprint when snapping erases a sub-grid sliver. ~10 cells (≈0.7–1.1 m at UK +# latitudes) is invisible at map scale yet survives the 1e-6° snap as a valid, +# 4-corner ring. +_FOOTPRINT_GRID_CELLS = 5 + + +def _grid_footprint(geom): + """A tiny grid-aligned square at ``geom``'s representative point, snapped valid. + + Last line of defence so an *active* postcode never vanishes: the de-overlap + pass can shave a small (e.g. co-located, non-geographic) postcode down to a + sub-grid sliver that disappears when snapped to output precision. Rather than + drop it, place a minimal valid footprint at its location. The tiny overlap + this re-creates with the neighbour that trimmed it is harmless — the output + partition is best-effort, a missing boundary is a hard validation failure. + """ + try: + point = geom.representative_point() + except GEOSException: + return None + half = _OUTPUT_PRECISION_DEG * _FOOTPRINT_GRID_CELLS + square = box(point.x - half, point.y - half, point.x + half, point.y + half) + return _snap_polygonal(square, _OUTPUT_PRECISION_DEG) + + def _geojson_geometry(geom) -> dict | None: - """Serialize a WGS84 polygon/multipolygon to a 6dp GeoJSON dict, or None.""" + """Serialize a WGS84 polygon/multipolygon to a *valid* 6dp GeoJSON dict, or None. + + The coordinates are snapped onto the 1e-6° output grid with a re-noding pass + BEFORE the 6dp rounding, not by the round alone. ``_resolve_overlaps`` leaves + thin overlap-sliver triangles with full-precision (off-grid) vertices at OA + seams; a bare round-to-6dp collapses those into degenerate rings (GEOS "Too + few points") and pinches rings into self-intersections that pass the + pre-rounding validity check but fail once the feature is read back from disk. + Snapping with ``valid_output`` nodes the geometry onto the grid so the round + that follows lands on exact 1e-6 multiples and cannot reintroduce invalidity. + + ``None`` only for a genuinely empty/degenerate-with-no-location input; a + non-empty geometry that snaps to a sub-grid sliver is rescued into a minimal + grid footprint rather than dropped (an active postcode must keep a boundary). + """ geom = _polygonal(geom if geom.is_valid else make_valid(geom)) if geom is None or geom.is_empty: return None - gj = mapping(geom) - return {"type": gj["type"], "coordinates": _round_coords(gj["coordinates"])} + snapped = _snap_polygonal(geom, _OUTPUT_PRECISION_DEG) + if snapped is None or snapped.is_empty: + snapped = _grid_footprint(geom) + if snapped is None or snapped.is_empty: + return None + gj = mapping(snapped) + out = {"type": gj["type"], "coordinates": _round_coords(gj["coordinates"])} + # Defence-in-depth: re-validate the dict that actually reaches disk. Snapping + # makes the round exact, so this should already hold; repair once more on the + # grid if a pathological vertex still pinches a ring. + if not shape(out).is_valid: + snapped = _snap_polygonal(shape(out), _OUTPUT_PRECISION_DEG) + if snapped is None or snapped.is_empty: + return None + gj = mapping(snapped) + out = {"type": gj["type"], "coordinates": _round_coords(gj["coordinates"])} + return out def write_district_geojson( diff --git a/pipeline/transform/postcode_boundaries/process_oa.py b/pipeline/transform/postcode_boundaries/process_oa.py index ecdab5f..4404560 100644 --- a/pipeline/transform/postcode_boundaries/process_oa.py +++ b/pipeline/transform/postcode_boundaries/process_oa.py @@ -3,13 +3,23 @@ from collections import Counter, defaultdict import numpy as np from scipy.spatial import cKDTree from shapely import STRtree, make_valid -from shapely.geometry import MultiPolygon, Polygon -from shapely.ops import unary_union +from shapely.geometry import MultiPoint, MultiPolygon, Point, Polygon +from .geometry import safe_difference, safe_intersection, safe_union from .voronoi import compute_voronoi_regions MIN_GEOM_AREA = 0.01 +# Minimal footprint (BNG metres) for a postcode whose UPRN seed wins no area in a +# crowded multi-postcode OA — its Voronoi cell ∩ remaining collapses below +# MIN_GEOM_AREA, or its seed sits inside an INSPIRE parcel wholly claimed by a +# co-located postcode. Every *active* postcode must keep a boundary +# (validate_outputs is zero-tolerance), so it gets a small disc at its true seed +# location. ~28 m² clears MIN_GEOM_AREA and output snapping; the overlap it +# creates with the area's winner is resolved at the output stage, where the +# smaller postcode wins the contested ground (see output._resolve_overlaps). +_MIN_SEED_FOOTPRINT_M = 3.0 + def process_oa( oa_geom: Polygon | MultiPolygon, @@ -36,10 +46,12 @@ def process_oa( # Compute remaining area if claimed: - all_claimed = unary_union(list(claimed.values())) + all_claimed = safe_union(list(claimed.values())) all_claimed = _clean_polygonal(all_claimed) remaining = ( - valid_oa.difference(all_claimed) if all_claimed is not None else valid_oa + safe_difference(valid_oa, all_claimed) + if all_claimed is not None + else valid_oa ) remaining = _clean_polygonal(remaining) else: @@ -60,13 +72,54 @@ def process_oa( fragments = [] for pc, parts in result.items(): - merged = _clean_polygonal(unary_union(parts)) + merged = _clean_polygonal(safe_union(parts)) if merged is not None: fragments.append((pc, merged)) + # Every postcode with a UPRN seed in this OA must keep at least a minimal + # footprint — in a dense OA (a block of flats with hundreds of distinct + # postcodes) a single-seed postcode's cell can collapse below MIN_GEOM_AREA or + # be fully absorbed by a co-located postcode's INSPIRE parcel, producing no + # fragment, and an active postcode must never be dropped. + orphans = unique_pcs - {pc for pc, _ in fragments} + if orphans: + fragments.extend(_seed_footprints(orphans, points, postcodes, valid_oa)) + return fragments +def _seed_footprints( + orphans: set[str], + points: np.ndarray, + postcodes: list[str], + valid_oa: Polygon | MultiPolygon, +) -> list[tuple[str, Polygon | MultiPolygon]]: + """Give each orphan postcode a minimal disc footprint at its UPRN seed(s). + + Orphans are postcodes with a UPRN in this OA that nonetheless won no area in + the INSPIRE/Voronoi partition. Each keeps a small disc at its true location, + clipped to the OA; the overlap with the area's winner is resolved at output. + """ + by_pc: dict[str, list] = defaultdict(list) + for i, pc in enumerate(postcodes): + if pc in orphans: + by_pc[pc].append(points[i]) + + out: list[tuple[str, Polygon | MultiPolygon]] = [] + for pc, pts in by_pc.items(): + arr = np.asarray(pts, dtype=np.float64) + seed = Point(arr[0]) if len(arr) == 1 else MultiPoint(arr) + disc = seed.buffer(_MIN_SEED_FOOTPRINT_M) + clipped = _clean_polygonal(safe_intersection(disc, valid_oa)) + if clipped is None: + # Seed on/near the OA edge: keep the unclipped disc so the postcode + # still gets a footprint at its location rather than no boundary. + clipped = _clean_polygonal(disc) + if clipped is not None: + out.append((pc, clipped)) + return out + + def _claim_inspire_parcels( valid_oa: Polygon | MultiPolygon, points: np.ndarray, @@ -141,7 +194,7 @@ def _claim_inspire_parcels( assignable = parcel if contained_union is not None: - assignable = assignable.difference(contained_union) + assignable = safe_difference(assignable, contained_union) for part in _polygon_parts(assignable): part = _clean_polygonal(part) if part is None: @@ -169,7 +222,7 @@ def _prepare_inspire_parcels( continue if not geom.intersects(valid_oa): continue - clipped = _clean_polygonal(geom.intersection(valid_oa)) + clipped = _clean_polygonal(safe_intersection(geom, valid_oa)) if clipped is not None: parcels.append(clipped) return parcels @@ -199,7 +252,7 @@ def _merge_parts_by_postcode( ) -> dict[str, Polygon | MultiPolygon]: merged: dict[str, Polygon | MultiPolygon] = {} for pc, parts in parts_by_postcode.items(): - geom = _clean_polygonal(unary_union(parts)) + geom = _clean_polygonal(safe_union(parts)) if geom is not None: merged[pc] = geom return merged @@ -210,7 +263,7 @@ def _union_claims( ) -> Polygon | MultiPolygon | None: if not claims: return None - return _clean_polygonal(unary_union([geom for _, geom in claims])) + return _clean_polygonal(safe_union([geom for _, geom in claims])) def _resolve_ordered_claims( @@ -224,11 +277,11 @@ def _resolve_ordered_claims( if geom is None: continue if used is not None: - geom = _clean_polygonal(geom.difference(used)) + geom = _clean_polygonal(safe_difference(geom, used)) if geom is None: continue resolved_parts[pc].append(geom) - used = _clean_polygonal(geom if used is None else unary_union([used, geom])) + used = _clean_polygonal(geom if used is None else safe_union([used, geom])) return _merge_parts_by_postcode(resolved_parts) @@ -261,7 +314,7 @@ def _extract_polygonal(geom) -> Polygon | MultiPolygon | None: # overlapping polygonal parts, and a MultiPolygon of overlapping parts is # invalid — it double-counts area and makes the next `.difference()` raise # a TopologyException that aborts the OA (and, in parallel mode, the - # worker). unary_union merges them into a valid geometry. - merged = unary_union(polys) + # worker). safe_union merges them into a valid geometry. + merged = safe_union(polys) return merged if not merged.is_empty else None return None diff --git a/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py b/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py index 0b6ce96..760ac72 100644 --- a/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py +++ b/pipeline/transform/postcode_boundaries/test_postcode_boundaries.py @@ -757,6 +757,50 @@ class TestProcessOAInspireParcelAssignment: assert frag_dict["A"].intersection(frag_dict["B"]).area < 0.01 +class TestProcessOASeedFootprintGuarantee: + """Every postcode with a UPRN seed in a multi-postcode OA must produce a + fragment, even when its partition cell collapses below MIN_GEOM_AREA — an + active postcode must never be dropped (validate_outputs is zero-tolerance).""" + + def test_collapsed_voronoi_cells_rescued_as_footprints(self): + # OA just above MIN_GEOM_AREA; a 2-way Voronoi split leaves each cell + # (~0.0098 m²) below MIN_GEOM_AREA, so both would be dropped without rescue. + oa_geom = box(0, 0, 0.14, 0.14) # 0.0196 m² + points = np.array([[0.035, 0.07], [0.105, 0.07]]) + postcodes = ["AA1 1AA", "AA1 1AB"] + + fragments = process_oa(oa_geom, points, postcodes, inspire_candidates=[]) + got = {pc for pc, _ in fragments} + assert got == {"AA1 1AA", "AA1 1AB"}, f"dropped: {set(postcodes) - got}" + for _, geom in fragments: + assert geom.is_valid + assert geom.area > MIN_GEOM_AREA + + def test_seed_footprint_sits_on_the_uprn(self): + from shapely.geometry import Point + + from .process_oa import _seed_footprints + + oa_geom = box(0, 0, 1000, 1000) + points = np.array([[500.0, 500.0]]) + out = _seed_footprints({"AA1 1AA"}, points, ["AA1 1AA"], oa_geom) + + assert len(out) == 1 + pc, geom = out[0] + assert pc == "AA1 1AA" + assert geom.is_valid and geom.area > MIN_GEOM_AREA + assert geom.contains(Point(500, 500)) + + def test_only_orphans_get_footprints(self): + # A wins real area; B's lone seed collapses. Only B should be rescued, and + # A's genuine (large) fragment must be untouched by the rescue. + oa_geom = box(0, 0, 0.14, 0.14) + points = np.array([[0.07, 0.07], [0.07, 0.07], [0.105, 0.07]]) + postcodes = ["AA1 1AA", "AA1 1AA", "AA1 1AB"] + fragments = process_oa(oa_geom, points, postcodes, inspire_candidates=[]) + assert {pc for pc, _ in fragments} == {"AA1 1AA", "AA1 1AB"} + + # --------------------------------------------------------------------------- # _extract_polygonal helper # --------------------------------------------------------------------------- @@ -1221,6 +1265,238 @@ class TestOutputPartition: assert geoms["AA1 1AB"].area > 0 +class TestGeojsonGeometrySliverValidity: + """_geojson_geometry must emit geometry that is still valid after the final 6dp + rounding. A sub-grid overlap sliver (left by _resolve_overlaps' full-precision + difference) must be snapped away on the output grid rather than collapsed by a + naive round into a degenerate ('Too few points') / self-intersecting ring that + only fails once read back from disk.""" + + def test_subgrid_sliver_does_not_produce_invalid_ring(self): + from shapely.geometry import shape + from shapely.validation import explain_validity + + from .output import _geojson_geometry + + main = box(-0.34, 51.74, -0.33, 51.75) # ~degree-scale, valid + # A thin triangle whose three vertices all round to the same 1e-6 cell. + sliver = Polygon( + [ + (-0.3400284, 51.7505061), + (-0.3400280, 51.7505060), + (-0.3400281, 51.7505063), + ] + ) + assert sliver.is_valid + + gj = _geojson_geometry(MultiPolygon([main, sliver])) + assert gj is not None + rt = shape(gj) + assert rt.is_valid, explain_validity(rt) + assert not rt.is_empty + # The real (main) area is preserved; only the degenerate sliver is dropped. + assert rt.area == pytest.approx(main.area, rel=1e-3) + + def test_pure_sliver_is_rescued_not_written_invalid(self): + from shapely.geometry import shape + + from .output import _OUTPUT_PRECISION_DEG, _geojson_geometry + + # A sub-grid sliver (extent < 1e-6° in one dimension) that snaps to empty: + # it must be rescued into a minimal valid footprint at its location, never + # written invalid and never dropped (an active postcode keeps a boundary). + g = _OUTPUT_PRECISION_DEG + sliver = Polygon( + [ + (-0.30, 51.75), + (-0.30 + 5 * g, 51.75), + (-0.30 + 5 * g, 51.75 + 0.2 * g), + (-0.30, 51.75 + 0.1 * g), + ] + ) + gj = _geojson_geometry(sliver) + assert gj is not None # rescued, not dropped + rt = shape(gj) + assert rt.is_valid and not rt.is_empty + assert rt.distance(sliver) == pytest.approx(0.0, abs=1e-4) + + +class TestColocatedPostcodesAllRetained: + """Co-located non-geographic postcodes (e.g. AL1 9xx) have heavily-overlapping + tiny footprints; the de-overlap pass trims most to sub-grid slivers. None may + be dropped — every active postcode must keep a (valid, non-empty) boundary.""" + + def test_overlapping_tiny_footprints_none_dropped(self, tmp_path): + from shapely.geometry import Point, shape + + # 12 ~3 m discs within ~1 m of each other → after de-overlap most collapse + # below output precision. + postcodes = {} + for i in range(12): + e = 514000.0 + (i % 4) * 0.3 + n = 206000.0 + (i // 4) * 0.3 + postcodes[f"AL1 9{chr(65 + i)}{chr(65 + i)}"] = Point(e, n).buffer(3.0) + + write_district_geojson(postcodes, tmp_path) + coll = json.loads((tmp_path / "units" / "AL1.geojson").read_text()) + written = {f["properties"]["postcodes"] for f in coll["features"]} + assert written == set(postcodes), f"dropped: {set(postcodes) - written}" + for feature in coll["features"]: + geom = shape(feature["geometry"]) + assert geom.is_valid and not geom.is_empty + + +class TestSafeOverlayHelpers: + """The robust overlay helpers retry on a fixed-precision grid after a + GEOSException (e.g. ``side location conflict`` from near-coincident OA-seam + edges). The grid is a caller-supplied parameter: metres for the BNG stages, + 1e-6 degrees for the WGS84 output stage — so the same helper serves both + without crushing degree-scale shapes on the metre default.""" + + def test_grid_param_honored_on_clean_inputs(self): + from . import geometry + + a = box(0, 0, 10, 10) + b = box(5, 0, 15, 10) + # No exception → exact result, identical regardless of the fallback grid. + assert geometry.safe_difference(a, b, grid=1e-6).equals(a.difference(b)) + assert geometry.safe_union([a, b], grid=1e-6).equals(unary_union([a, b])) + assert geometry.safe_intersection(a, b, grid=1e-6).equals(a.intersection(b)) + + def test_difference_falls_back_to_fixed_precision_overlay(self, monkeypatch): + from shapely import GEOSException + from shapely.geometry.base import BaseGeometry + + from . import geometry + + a = box(0, 0, 10, 10) + b = box(5, 0, 15, 10) + + def _boom(self, other, *args, **kwargs): + raise GEOSException("forced side location conflict") + + # Patch the .difference() *method*; the fallback uses the top-level + # shapely.difference() function, so it still completes. + monkeypatch.setattr(BaseGeometry, "difference", _boom) + result = geometry.safe_difference(a, b, grid=1e-6) + assert result.is_valid + assert result.area == pytest.approx(50.0) # left half of `a` + + def test_union_falls_back_to_fixed_precision_overlay(self, monkeypatch): + from shapely import GEOSException + + from . import geometry + + a = box(0, 0, 10, 10) + b = box(5, 0, 15, 10) + + def _boom(_geoms): + raise GEOSException("forced robustness failure") + + monkeypatch.setattr(geometry, "unary_union", _boom) + result = geometry.safe_union([a, b], grid=1e-6) + assert result.is_valid + assert result.area == pytest.approx(150.0) # 100 + 100 - 50 overlap + + # A self-intersecting bow-tie: invalid. set_precision()'s DEFAULT + # ('valid_output') mode runs its own noding pass that re-raises + # 'side location conflict' on this — which is exactly how the production + # crash happened (the fallback re-raised the error it was meant to absorb). + _BOWTIE = Polygon([(0, 0), (1e-5, 1e-5), (1e-5, 0), (0, 1e-5), (0, 0)]) + # make_valid() of this spiky ring returns a mixed-dimension + # GeometryCollection (polygon + dangling line); OverlayNG rejects that with + # 'Overlay input is mixed-dimension', so the fallback must strip the debris. + _SPIKY = Polygon( + [(0, 0), (10, 0), (10, 10), (5, 5), (5.0000001, 5), (0, 10), (0, 0), (15, -5), (0, 0)] + ) + + def test_difference_fallback_survives_invalid_input(self, monkeypatch): + """Regression for the production crash: the fallback must not reduce + precision with set_precision's default valid_output mode, which re-raises + 'side location conflict' on an invalid geometry.""" + from shapely import GEOSException + from shapely.geometry.base import BaseGeometry + + from . import geometry + + assert not self._BOWTIE.is_valid # precondition + + def _boom(self, other, *a, **k): + raise GEOSException("forced side location conflict") + + monkeypatch.setattr(BaseGeometry, "difference", _boom) + result = geometry.safe_difference(self._BOWTIE, box(0, 0, 5e-6, 5e-6), grid=1e-6) + assert result.is_valid + assert result.geom_type in ("Polygon", "MultiPolygon") + + def test_difference_fallback_survives_make_valid_geometrycollection( + self, monkeypatch + ): + """Regression: make_valid can yield a mixed-dimension GeometryCollection + that OverlayNG rejects; the fallback must keep only polygonal parts.""" + from shapely import GEOSException, make_valid + from shapely.geometry.base import BaseGeometry + + from . import geometry + + assert make_valid(self._SPIKY).geom_type == "GeometryCollection" # precondition + + def _boom(self, other, *a, **k): + raise GEOSException("forced side location conflict") + + monkeypatch.setattr(BaseGeometry, "difference", _boom) + result = geometry.safe_difference(self._SPIKY, box(2, 2, 8, 8), grid=1e-4) + assert result.is_valid + assert result.geom_type in ("Polygon", "MultiPolygon") + assert result.area > 0 + + def test_intersection_fallback_survives_make_valid_geometrycollection( + self, monkeypatch + ): + from shapely import GEOSException + from shapely.geometry.base import BaseGeometry + + from . import geometry + + def _boom(self, other, *a, **k): + raise GEOSException("forced side location conflict") + + monkeypatch.setattr(BaseGeometry, "intersection", _boom) + result = geometry.safe_intersection(self._SPIKY, box(2, 2, 8, 8), grid=1e-4) + assert result.is_valid + assert result.geom_type in ("Polygon", "MultiPolygon") + assert result.area > 0 + + def test_union_fallback_survives_invalid_and_collection_inputs(self, monkeypatch): + """The union fallback must absorb both an invalid bow-tie and a + make_valid-becomes-GeometryCollection input without raising.""" + from shapely import GEOSException + + from . import geometry + + def _boom(_geoms): + raise GEOSException("forced robustness failure") + + monkeypatch.setattr(geometry, "unary_union", _boom) + result = geometry.safe_union( + [self._BOWTIE, self._SPIKY, box(20, 20, 30, 30)], grid=1e-4 + ) + assert result.is_valid + assert result.geom_type in ("Polygon", "MultiPolygon") + + def test_helpers_never_raise_on_empty_inputs(self): + """Degenerate/empty inputs must not abort a multi-hour run.""" + from . import geometry + + empty = Polygon() + a = box(0, 0, 10, 10) + assert geometry.safe_difference(empty, a).is_empty + assert geometry.safe_difference(a, empty).equals(a) + assert geometry.safe_intersection(empty, a).is_empty + assert geometry.safe_union([]).is_empty + assert geometry.safe_union([empty]).is_empty + + # --------------------------------------------------------------------------- # InspireIndex must return the same candidates as a brute-force bbox scan # --------------------------------------------------------------------------- diff --git a/pipeline/transform/postcode_boundaries/voronoi.py b/pipeline/transform/postcode_boundaries/voronoi.py index 6d80d12..939d3c9 100644 --- a/pipeline/transform/postcode_boundaries/voronoi.py +++ b/pipeline/transform/postcode_boundaries/voronoi.py @@ -4,7 +4,8 @@ import numpy as np from scipy.spatial import QhullError, Voronoi from shapely import make_valid from shapely.geometry import MultiPolygon, Polygon -from shapely.ops import unary_union + +from .geometry import safe_intersection, safe_union def compute_voronoi_regions( @@ -111,13 +112,13 @@ def compute_voronoi_regions( poly = Polygon(vertices) if not poly.is_valid: poly = make_valid(poly) - clipped = poly.intersection(boundary) + clipped = safe_intersection(poly, boundary) if not clipped.is_empty: pc_polys[unique_pcs[i]].append(clipped) result = {} for pc, parts in pc_polys.items(): - merged = unary_union(parts) + merged = safe_union(parts) if not merged.is_empty: result[pc] = merged return result @@ -143,7 +144,7 @@ def _equal_split_fallback( (min_x, strip_max_y), ] ) - clipped = boundary.intersection(strip) + clipped = safe_intersection(boundary, strip) if not clipped.is_empty: result[pc] = clipped return result diff --git a/pipeline/transform/test_tree_density.py b/pipeline/transform/test_tree_density.py index 340d9ec..45d0ee5 100644 --- a/pipeline/transform/test_tree_density.py +++ b/pipeline/transform/test_tree_density.py @@ -66,6 +66,53 @@ def test_accumulate_clipped_area_drops_missing_and_empty_geometry() -> None: assert canopy_area[0] == pytest.approx(400.0) +def test_accumulate_clipped_area_survives_invalid_polygon() -> None: + """A self-intersecting external polygon (TOW/NFI data is occasionally invalid) + must not abort the batched overlay with 'TopologyException: side location + conflict'; its repaired in-buffer area is still accumulated.""" + radius_m = 50 + points = pl.DataFrame({"postcode": ["A"], "x": [0.0], "y": [0.0]}) + circles, tree = _postcode_buffers(points, radius_m) + + # Bow-tie centred on A: self-intersecting => invalid. The raw batched + # shapely.intersection raises 'side location conflict' on it; make_valid splits + # it into two triangles of total area 200, fully inside A's radius-50 buffer. + bowtie = shapely.Polygon([(-10, -10), (10, 10), (10, -10), (-10, 10), (-10, -10)]) + assert not shapely.is_valid(bowtie) # precondition + with pytest.raises(shapely.errors.GEOSException): # documents the raw hazard + shapely.intersection( + np.array([bowtie], dtype=object), np.array([circles[0]], dtype=object) + ) + + canopy_area = np.zeros(1) + _accumulate_clipped_area(np.array([bowtie], dtype=object), circles, tree, canopy_area) + assert canopy_area[0] == pytest.approx(200.0, rel=1e-3) + + +def test_robust_intersection_area_recovers_from_overlay_failure(monkeypatch) -> None: + """The batched-overlay fallback must absorb a GEOSException from the fast path + and recover (validate + retry), returning the correct per-pair areas. Version + independent: the fast-path failure is forced rather than data-dependent.""" + from pipeline.transform import tree_density + + real_intersection = shapely.intersection + calls = {"n": 0} + + def flaky(a, b, **kwargs): + calls["n"] += 1 + if calls["n"] == 1: # fail only the first (fast-path) call + raise shapely.errors.GEOSException("forced side location conflict") + return real_intersection(a, b, **kwargs) + + monkeypatch.setattr(tree_density.shapely, "intersection", flaky) + + a = np.array([shapely.box(0, 0, 10, 10), shapely.box(0, 0, 4, 4)], dtype=object) + b = np.array([shapely.box(0, 0, 6, 6), shapely.box(0, 0, 2, 2)], dtype=object) + out = tree_density._robust_intersection_area(a, b) + assert calls["n"] >= 2 # fast path failed -> fallback path executed + assert out.tolist() == pytest.approx([36.0, 4.0]) + + def test_accumulate_clipped_area_height_weighted_by_overlap() -> None: radius_m = 50 points = pl.DataFrame({"postcode": ["A"], "x": [0.0], "y": [0.0]}) diff --git a/pipeline/transform/tree_density.py b/pipeline/transform/tree_density.py index 9590104..75ba03e 100644 --- a/pipeline/transform/tree_density.py +++ b/pipeline/transform/tree_density.py @@ -263,6 +263,43 @@ def _postcode_buffers( return circles, shapely.STRtree(circles) +# 0.1 mm in the BNG working CRS (EPSG:27700) — far below survey resolution; the +# same grid the postcode_boundaries overlay uses. +_OVERLAY_GRID_M = 1e-4 + + +def _robust_intersection_area(a: np.ndarray, b: np.ndarray) -> np.ndarray: + """Vectorized ``area(a[i] ∩ b[i])`` that survives GEOS robustness failures. + + External Forest Research TOW/NFI polygons are occasionally invalid + (self-intersections), and a single bad polygon makes the batched + ``shapely.intersection`` raise ``TopologyException: side location conflict``, + aborting the whole run. The fast path is the raw batched overlay — unchanged, + full-speed, when the data is clean — and only a failure triggers repair. + + The repair deliberately uses a *plain* overlay rather than the fixed-precision + (``grid_size``) one: ``make_valid`` can emit a mixed-dimension + ``GeometryCollection`` (a polygon plus a dangling line), which OverlayNG + rejects with ``Overlay input is mixed-dimension`` — whereas a plain overlay + accepts it, and its non-polygonal debris has zero area and is dropped by the + ``clipped_area > 0`` filter downstream anyway. A final pointwise coordinate + snap (which never raises) collapses the near-coincident edges behind any + residual full-precision robustness failure. + """ + try: + return shapely.area(shapely.intersection(a, b)) + except shapely.errors.GEOSException: + pass + a = shapely.make_valid(a) + b = shapely.make_valid(b) + try: + return shapely.area(shapely.intersection(a, b)) + except shapely.errors.GEOSException: + a = shapely.make_valid(shapely.set_precision(a, _OVERLAY_GRID_M, mode="pointwise")) + b = shapely.make_valid(shapely.set_precision(b, _OVERLAY_GRID_M, mode="pointwise")) + return shapely.area(shapely.intersection(a, b)) + + def _accumulate_clipped_area( geoms: np.ndarray, circles: np.ndarray, @@ -294,8 +331,8 @@ def _accumulate_clipped_area( if geom_index.size == 0: return - clipped_area = shapely.area( - shapely.intersection(geoms[geom_index], circles[postcode_index]) + clipped_area = _robust_intersection_area( + geoms[geom_index], circles[postcode_index] ) positive = clipped_area > 0 geom_index = geom_index[positive] From 843d14b7ba0cdfa26e4247750f9aa08e02aae895 Mon Sep 17 00:00:00 2001 From: Andras Schmelczer <andras@schmelczer.dev> Date: Thu, 4 Jun 2026 21:42:21 +0100 Subject: [PATCH 9/9] Improve memory --- Dockerfile | 4 +++ docker-compose.yml | 3 ++ server-rs/Cargo.lock | 22 +++++++++++++ server-rs/Cargo.toml | 7 +++++ server-rs/src/main.rs | 19 +++++++++++ server-rs/src/routes/tiles.rs | 59 ++++++++++++++++++++++++++++++++--- 6 files changed, 110 insertions(+), 4 deletions(-) diff --git a/Dockerfile b/Dockerfile index 7fb2826..f460db4 100644 --- a/Dockerfile +++ b/Dockerfile @@ -39,6 +39,10 @@ VOLUME ["/app/data"] RUN chown -R appuser:appuser /app USER appuser +# Fallback for any allocations not served by jemalloc (the binary's global +# allocator, tuned via the baked-in malloc_conf): cap glibc to 2 arenas so freed +# memory coalesces and is returned instead of fragmenting across per-CPU arenas. +ENV MALLOC_ARENA_MAX=2 EXPOSE 8001 HEALTHCHECK --interval=30s --timeout=5s --start-period=120s --retries=3 \ CMD curl -f http://localhost:8001/health || exit 1 diff --git a/docker-compose.yml b/docker-compose.yml index f5cc036..e43bca7 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -32,6 +32,9 @@ services: - ./property-data:/app/data:ro - ./finder/data:/app/finder-data:ro environment: + # Fallback only — the binary uses jemalloc as its global allocator + # (tuned via a baked-in malloc_conf). Caps glibc to 2 arenas. + MALLOC_ARENA_MAX: "2" POCKETBASE_URL: http://pocketbase:8090 POCKETBASE_ADMIN_EMAIL: *pb-email POCKETBASE_ADMIN_PASSWORD: *pb-password diff --git a/server-rs/Cargo.lock b/server-rs/Cargo.lock index 51b98b0..4aa3069 100644 --- a/server-rs/Cargo.lock +++ b/server-rs/Cargo.lock @@ -3880,6 +3880,7 @@ version = "0.1.0" dependencies = [ "anyhow", "axum", + "bytes", "clap", "h3o", "hex", @@ -3900,6 +3901,7 @@ dependencies = [ "serde", "serde_json", "sha2 0.11.0", + "tikv-jemallocator", "tokio", "tower", "tower-http", @@ -5253,6 +5255,26 @@ dependencies = [ "cfg-if", ] +[[package]] +name = "tikv-jemalloc-sys" +version = "0.6.1+5.3.0-1-ge13ca993e8ccb9ba9847cc330696e02839f328f7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd8aa5b2ab86a2cefa406d889139c162cbb230092f7d1d7cbc1716405d852a3b" +dependencies = [ + "cc", + "libc", +] + +[[package]] +name = "tikv-jemallocator" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0359b4327f954e0567e69fb191cf1436617748813819c94b8cd4a431422d053a" +dependencies = [ + "libc", + "tikv-jemalloc-sys", +] + [[package]] name = "tilejson" version = "0.4.3" diff --git a/server-rs/Cargo.toml b/server-rs/Cargo.toml index 7a718cf..bb6b3b4 100644 --- a/server-rs/Cargo.toml +++ b/server-rs/Cargo.toml @@ -33,8 +33,15 @@ sha2 = "0.11" hex = "0.4" tower = { version = "0.5", features = ["limit"] } libc = "0.2" +bytes = "1" sentry = { version = "0.46.0", default-features = false, features = ["backtrace", "contexts", "debug-images", "panic", "reqwest", "rustls", "tracing", "tower-http", "tower-axum-matched-path"] } +# jemalloc returns freed memory to the OS far more aggressively than glibc malloc +# (which strands freed rayon/Polars load buffers across many per-CPU arenas, inflating +# steady-state RSS). Decay is configured via `malloc_conf` in main.rs. +[target.'cfg(not(target_env = "msvc"))'.dependencies] +tikv-jemallocator = { version = "0.6", features = ["unprefixed_malloc_on_supported_platforms"] } + [lints.clippy] min_ident_chars = "warn" diff --git a/server-rs/src/main.rs b/server-rs/src/main.rs index 4b5f318..ac2275c 100644 --- a/server-rs/src/main.rs +++ b/server-rs/src/main.rs @@ -19,6 +19,25 @@ mod routes; mod state; pub mod utils; +// Use jemalloc as the global allocator. glibc malloc keeps freed memory in many +// per-CPU arenas and rarely returns it to the OS, so the transient buffers from +// the rayon/Polars-parallel data load stay resident and inflate steady-state RSS. +// jemalloc's decay-based purging (configured below) hands those pages back. +#[cfg(not(target_env = "msvc"))] +#[global_allocator] +static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc; + +// Return dirty/muzzy pages to the OS ~1s after they go idle, and run a background +// thread to do so proactively (so RSS drops after the startup load peak without +// waiting for the next allocation). Read by jemalloc at startup via the +// `malloc_conf` symbol (unprefixed on Linux). Can be overridden by the +// `_RJEM_MALLOC_CONF` / `MALLOC_CONF` env var. +#[cfg(not(target_env = "msvc"))] +#[allow(non_upper_case_globals)] +#[used] +#[export_name = "malloc_conf"] +pub static malloc_conf: &[u8] = b"background_thread:true,dirty_decay_ms:1000,muzzy_decay_ms:1000\0"; + use std::path::{Path, PathBuf}; use std::sync::Arc; use std::time::Duration; diff --git a/server-rs/src/routes/tiles.rs b/server-rs/src/routes/tiles.rs index b9efefd..bd79b5b 100644 --- a/server-rs/src/routes/tiles.rs +++ b/server-rs/src/routes/tiles.rs @@ -1,13 +1,64 @@ +use std::os::unix::fs::FileExt; use std::sync::Arc; use axum::extract::{Path, Query, State}; use axum::http::{header, StatusCode}; use axum::response::{IntoResponse, Response}; -use pmtiles::{AsyncPmTilesReader, MmapBackend, TileCoord}; +use bytes::Bytes; +use pmtiles::{ + AsyncBackend, AsyncPmTilesReader, BackendResponse, HashMapCache, PmtError, PmtResult, TileCoord, +}; use serde::Deserialize; use tracing::warn; -pub type TileReader = AsyncPmTilesReader<MmapBackend>; +/// PMTiles archives are read straight from disk with positional `pread` calls +/// instead of being memory-mapped. With an mmap backend every touched tile page +/// is attributed to the process RSS (~21 GB across all tilesets); with `pread` +/// the file contents stay in the (reclaimable) kernel page cache and only the +/// small per-request buffer lives in the process. A [`HashMapCache`] keeps the +/// archive's directory entries in memory so tile lookups don't re-read and +/// re-decompress directory pages from disk on every request. +pub type TileReader = AsyncPmTilesReader<FileBackend, HashMapCache>; + +/// An [`AsyncBackend`] that serves byte ranges from a local file via `pread`. +pub struct FileBackend { + file: Arc<std::fs::File>, + len: u64, +} + +impl FileBackend { + pub fn open(path: &std::path::Path) -> std::io::Result<Self> { + let file = std::fs::File::open(path)?; + let len = file.metadata()?.len(); + Ok(Self { + file: Arc::new(file), + len, + }) + } +} + +impl AsyncBackend for FileBackend { + async fn read(&self, offset: usize, length: usize) -> PmtResult<BackendResponse> { + let available = (self.len as usize).saturating_sub(offset); + let read_len = length.min(available); + if read_len == 0 { + return Ok(BackendResponse::new(Bytes::new())); + } + + let file = Arc::clone(&self.file); + // pread is blocking; keep it off the async runtime's worker threads. + let buf = tokio::task::spawn_blocking(move || { + let mut buf = vec![0u8; read_len]; + file.read_exact_at(&mut buf, offset as u64)?; + std::io::Result::Ok(buf) + }) + .await + .map_err(|err| PmtError::Reading(std::io::Error::other(err)))? + .map_err(PmtError::Reading)?; + + Ok(BackendResponse::new(Bytes::from(buf))) + } +} pub async fn get_tile( State(reader): State<Arc<TileReader>>, @@ -260,7 +311,7 @@ fn build_style(is_dark: bool, layers: &[serde_json::Value], tile_url: &str) -> s } pub async fn init_tile_reader(path: &std::path::Path) -> anyhow::Result<TileReader> { - let backend = MmapBackend::try_from(path).await?; - let reader = AsyncPmTilesReader::try_from_source(backend).await?; + let backend = FileBackend::open(path)?; + let reader = AsyncPmTilesReader::try_from_cached_source(backend, HashMapCache::default()).await?; Ok(reader) }