d17ac794fd
* Centralize filesystem paths in a single module Add paths.py, which resolves the repo root once and derives the cache, accounts DB, logs, templates, frontend and bundled-city-data locations from it. Replace the 13 per-module `dirname(__file__)/..` anchors with references to it, so a module's location no longer determines where the app reads its data. Env overrides (accounts DB, VAPID, IndexNow) are unchanged; every resolved path is byte-identical to before. Groundwork for moving modules into packages without re-pointing paths. Claude-Session: https://claude.ai/code/session_01XXxmNFy9cZ6Gh8Y9thZn62 * Split the backend into domain packages Group the flat backend modules into packages that mirror their concerns: data/ climate, grading, scoring, grid, places, cities, city_events, store web/ app, views, homepage, content, schemas notifications/ notify, digest, push, mailer, discord, discord_interactions, discord_link accounts/ models, users, api_accounts, db core/ metrics, singleton, audit Intra-project imports are rewritten to the package-qualified form. The entry scripts (indexnow, warm_cities, migrate, gen_cities, gen_flavor) and paths.py stay at the backend/ root, and backend/app.py becomes a shim re-exporting web.app:app so the launch target stays `app:app` — run.sh, the systemd units, and CI need no change. Verified: full suite (318) passes, `uvicorn app:app` boots and serves the home/SEO/static/API surfaces, and every root script imports clean. Claude-Session: https://claude.ai/code/session_01XXxmNFy9cZ6Gh8Y9thZn62
104 lines
3.5 KiB
Python
104 lines
3.5 KiB
Python
"""Access to the curated city set (backend/cities.json) that gets crawlable
|
|
climate pages. Loaded once, lazily; regenerate the JSON with gen_cities.py."""
|
|
import json
|
|
import os
|
|
|
|
import paths
|
|
|
|
_PATH = paths.CITIES_JSON
|
|
_FLAVOR_PATH = paths.CITIES_FLAVOR_JSON
|
|
_CITIES: list[dict] | None = None
|
|
_BY_SLUG: dict[str, dict] | None = None
|
|
_FLAVOR: dict[str, dict] | None = None
|
|
_DUPES: dict[str, dict[str, int]] | None = None
|
|
|
|
|
|
def _load() -> list[dict]:
|
|
global _CITIES, _BY_SLUG
|
|
if _CITIES is None:
|
|
with open(_PATH, encoding="utf-8") as f:
|
|
_CITIES = json.load(f)
|
|
_BY_SLUG = {c["slug"]: c for c in _CITIES}
|
|
return _CITIES
|
|
|
|
|
|
def all_cities() -> list[dict]:
|
|
return _load()
|
|
|
|
|
|
def all_slugs() -> list[str]:
|
|
return [c["slug"] for c in _load()]
|
|
|
|
|
|
def get(slug: str) -> dict | None:
|
|
"""The city for a slug, or None (→ 404)."""
|
|
_load()
|
|
return _BY_SLUG.get(slug)
|
|
|
|
|
|
def flavor(slug: str) -> dict | None:
|
|
"""A city's descriptive blurb {extract, url, title} from cities_flavor.json, or
|
|
None when we have no confident match (the page renders fine without it)."""
|
|
global _FLAVOR
|
|
if _FLAVOR is None:
|
|
try:
|
|
with open(_FLAVOR_PATH, encoding="utf-8") as f:
|
|
_FLAVOR = json.load(f)
|
|
except (OSError, ValueError):
|
|
_FLAVOR = {}
|
|
return _FLAVOR.get(slug)
|
|
|
|
|
|
def title_name(city: dict) -> str:
|
|
"""The shortest label that still names this city unambiguously — for page
|
|
titles, where display_name()'s region + country spend the width Google gives
|
|
us before it ever reaches the payload ("… in July").
|
|
|
|
'Seattle' for the 968 cities whose name is unique; 'London, GB' when the name
|
|
recurs in another country; 'Columbus, Ohio' when it recurs *within* one
|
|
country, where the country code would collide too and hand two different
|
|
pages the same title.
|
|
"""
|
|
name = city["name"]
|
|
dupes = _dupe_names().get(name)
|
|
if not dupes:
|
|
return name
|
|
if dupes.get(city.get("country_code")) == 1:
|
|
return f"{name}, {city['country_code']}"
|
|
return f"{name}, {city['admin1']}" if city.get("admin1") else name
|
|
|
|
|
|
def _dupe_names() -> dict[str, dict[str, int]]:
|
|
"""{name: {country_code: how many cities share both}} for duplicated names
|
|
only. Built once alongside the city list."""
|
|
global _DUPES
|
|
if _DUPES is None:
|
|
counts: dict[str, dict[str, int]] = {}
|
|
for c in _load():
|
|
counts.setdefault(c["name"], {})
|
|
cc = c.get("country_code")
|
|
counts[c["name"]][cc] = counts[c["name"]].get(cc, 0) + 1
|
|
_DUPES = {n: by_cc for n, by_cc in counts.items() if sum(by_cc.values()) > 1}
|
|
return _DUPES
|
|
|
|
|
|
def display_name(city: dict) -> str:
|
|
"""Human label: 'Seattle, Washington, United States' (drops repeated admin1)."""
|
|
parts = [city["name"]]
|
|
if city.get("admin1") and city["admin1"] != city["name"]:
|
|
parts.append(city["admin1"])
|
|
if city.get("country"):
|
|
parts.append(city["country"])
|
|
return ", ".join(parts)
|
|
|
|
|
|
def by_country() -> dict[str, list[dict]]:
|
|
"""Cities grouped by country, both the countries and the cities within each
|
|
ordered alphabetically — for the /climate hub's crawlable link graph + search."""
|
|
groups: dict[str, list[dict]] = {}
|
|
for c in _load():
|
|
key = c.get("country") or c.get("country_code") or "Other"
|
|
groups.setdefault(key, []).append(c)
|
|
for v in groups.values():
|
|
v.sort(key=lambda x: x["name"].lower())
|
|
return dict(sorted(groups.items(), key=lambda kv: kv[0].lower()))
|