feat: add data acquisition scripts mirrored from SafeVisionAI main repo

Added reproducible data pipeline scripts organized by origin:
- scripts/backend/data/ → from backend/scripts/data/ (5 files)
- scripts/scripts/data/ → from scripts/data/ (15 files)
- scripts/chatbot_service/data/ → from chatbot_service/scripts/data/ (6 Pro fetchers)

Only pure-data scripts included (no DB/Redis/PostGIS dependencies).
App-only scripts excluded to keep Hub fully self-contained.

scripts/backend/data/prepare_road_sources.py

@@ -0,0 +1,195 @@
+"""
+prepare_road_sources.py
+=======================
+Pre-processes local road data files that have only lat/lon point geometry
+into LineString-based GeoJSON files that import_road_infrastructure.py can
+actually import into the road_infrastructure PostGIS table.
+
+Sources handled:
+  1. chatbot_service/data/roads/toll_plazas.csv
+       → backend/datasets/roads/toll_plazas_linestring.geojson
+  2. backend/datasets/accidents/blackspot_seed.csv  (if present)
+       → backend/datasets/roads/blackspot_linestring.geojson
+
+Each point is expanded into a tiny 0.001-degree stub LineString so it
+satisfies the LINESTRING geometry constraint while preserving the location.
+
+Usage:
+    cd backend/
+    python scripts/prepare_road_sources.py
+"""
+from __future__ import annotations
+
+import csv
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]          # SafeVisionAI/backend/
+CHATBOT_DATA = ROOT.parent / "chatbot_service" / "data"
+OUT_DIR = ROOT / "datasets" / "roads"
+OUT_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def point_to_stub_linestring(lat: float, lon: float, delta: float = 0.001) -> dict:
+    """Return a GeoJSON geometry that is a tiny LineString centred on the point."""
+    return {
+        "type": "LineString",
+        "coordinates": [
+            [lon - delta / 2, lat],
+            [lon + delta / 2, lat],
+        ],
+    }
+
+
+# ---------------------------------------------------------------------------
+# 1.  Toll Plazas
+# ---------------------------------------------------------------------------
+def convert_toll_plazas() -> Path:
+    src = CHATBOT_DATA / "roads" / "toll_plazas.csv"
+    out = OUT_DIR / "toll_plazas_linestring.geojson"
+
+    if not src.exists():
+        print(f"[SKIP] toll_plazas.csv not found at {src}")
+        return out
+
+    features = []
+    skipped = 0
+    with src.open(encoding="utf-8-sig", newline="") as fh:
+        for row in csv.DictReader(fh):
+            try:
+                lat = float(row["lat"])
+                lon = float(row["lon"])
+            except (KeyError, ValueError):
+                skipped += 1
+                continue
+
+            props = {
+                "road_id":       f"toll-{row.get('id', len(features)+1)}",
+                "road_name":     row.get("name", ""),
+                "road_type":     "toll_plaza",
+                "road_number":   row.get("id", ""),
+                "state_code":    "IN",
+                "contractor_name": row.get("contractor_name", ""),
+                "project_source": "NHAI Toll Plazas — geohacker/toll-plazas-india",
+                "data_source_url":
+                    "https://github.com/geohacker/toll-plazas-india",
+            }
+            features.append({
+                "type": "Feature",
+                "geometry": point_to_stub_linestring(lat, lon),
+                "properties": props,
+            })
+
+    fc = {"type": "FeatureCollection", "features": features}
+    out.write_text(json.dumps(fc, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(f"[OK] Toll plazas: {len(features)} features -> {out.relative_to(ROOT)}"
+          + (f"  ({skipped} skipped)" if skipped else ""))
+    return out
+
+
+# ---------------------------------------------------------------------------
+# 2.  Blackspot seed CSV  (backend/datasets/accidents/blackspot_seed.csv)
+# ---------------------------------------------------------------------------
+def convert_blackspots() -> Path | None:
+    src = ROOT / "datasets" / "accidents" / "blackspot_seed.csv"
+    out = OUT_DIR / "blackspot_linestring.geojson"
+
+    if not src.exists():
+        print(f"[SKIP] blackspot_seed.csv not found at {src}")
+        return None
+
+    features = []
+    skipped = 0
+    with src.open(encoding="utf-8-sig", newline="") as fh:
+        reader = csv.DictReader(fh)
+        cols = reader.fieldnames or []
+        lat_col = next((c for c in cols if c.lower() in ("lat", "latitude")), None)
+        lon_col = next((c for c in cols if c.lower() in ("lon", "longitude")), None)
+        if not lat_col or not lon_col:
+            print(f"[SKIP] blackspot_seed.csv has no lat/lon columns (found: {cols})")
+            return None
+
+        for idx, row in enumerate(reader, start=1):
+            try:
+                lat = float(row[lat_col])
+                lon = float(row[lon_col])
+            except ValueError:
+                skipped += 1
+                continue
+
+            props = {
+                "road_id":        f"blackspot-{row.get('id', idx)}",
+                "road_name":      row.get("location", row.get("road_name", "")),
+                "road_type":      "blackspot",
+                "state_code":     row.get("state_code", "IN"),
+                "project_source": "MoRTH Blackspot Seed Data",
+                "data_source_url":
+                    "https://morth.nic.in/road-accident-black-spot",
+            }
+            features.append({
+                "type": "Feature",
+                "geometry": point_to_stub_linestring(lat, lon),
+                "properties": props,
+            })
+
+    fc = {"type": "FeatureCollection", "features": features}
+    out.write_text(json.dumps(fc, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(f"[OK] Blackspots:  {len(features)} features -> {out.relative_to(ROOT)}"
+          + (f"  ({skipped} skipped)" if skipped else ""))
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+if __name__ == "__main__":
+    print("=== prepare_road_sources.py ===")
+    toll_out  = convert_toll_plazas()
+    bs_out    = convert_blackspots()
+
+    # Write a ready-to-use manifest for import_official_road_sources.py
+    sources = []
+
+    # Source 1: PMGSY rural roads (GeoJSON LineStrings — direct import, no conversion needed)
+    pmgsy_path = CHATBOT_DATA / "roads" / "pmgsy_roads.geojson"
+    if pmgsy_path.exists():
+        sources.append({
+            "name": "pmgsy_rural_roads",
+            "path": str(pmgsy_path.resolve()),
+            "format": "json",
+            "default_state_code": "IN",
+            "default_project_source": "PMGSY GeoSadak — datameet/pmgsy-geosadak",
+            "default_data_source_url": "https://github.com/datameet/pmgsy-geosadak",
+        })
+        print(f"[OK] PMGSY source added ({pmgsy_path.name})")
+    else:
+        print(f"[SKIP] PMGSY not found at {pmgsy_path}")
+
+    # Source 2: Toll plazas (converted to LineString)
+    sources.append({
+        "name": "nhai_toll_plazas",
+        "path": str(toll_out.resolve()),
+        "format": "json",
+        "default_state_code": "IN",
+        "default_project_source": "NHAI Toll Plazas — geohacker/toll-plazas-india",
+        "default_data_source_url": "https://github.com/geohacker/toll-plazas-india",
+    })
+
+    # Source 3: Blackspots (if converted)
+    if bs_out and bs_out.exists():
+        sources.append({
+            "name": "morth_blackspots",
+            "path": str(bs_out.resolve()),
+            "format": "json",
+            "default_state_code": "IN",
+            "default_project_source": "MoRTH Accident Blackspots",
+            "default_data_source_url": "https://morth.nic.in/road-accident-black-spot",
+        })
+
+    manifest_path = ROOT / "scripts" / "road_sources.json"
+    manifest_path.write_text(json.dumps(sources, indent=2, ensure_ascii=False), encoding="utf-8")
+    print(f"\n[OK] Manifest written: {manifest_path.relative_to(ROOT)}")
+    print(f"     Contains {len(sources)} source(s)")
+    print("\nNow run:")
+    print(f"  python scripts/import_official_road_sources.py --manifest scripts/road_sources.json")

scripts/backend/data/road_sources.example.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d31ef0be60a8f9099713c42a9294653739a444033ad609748b6167cd1df7afd
+size 639

scripts/backend/data/road_sources.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b0a729760cda438188c0c7f10f82e16ea5ce04aa83d71f48fc80ae64c6468c62
+size 731

scripts/backend/data/sample_pmgsy.py

@@ -0,0 +1,66 @@
+"""
+sample_pmgsy.py
+===============
+Samples a representative subset of PMGSY roads from the full
+pmgsy_roads.geojson (867K features) and writes a smaller GeoJSON
+that import_official_road_sources.py can import without timing out.
+
+Strategy: Take up to `max_per_state` roads per state so all 29 states
+are represented, then cap the total at `total_limit`.
+
+Usage:
+    cd backend/
+    python scripts/sample_pmgsy.py [--limit 5000] [--per-state 200]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+from collections import defaultdict
+from pathlib import Path
+
+ROOT       = Path(__file__).resolve().parents[1]
+CHATBOT    = ROOT.parent / "chatbot_service" / "data"
+SRC        = CHATBOT / "roads" / "pmgsy_roads.geojson"
+OUT_DIR    = ROOT / "datasets" / "roads"
+OUT_DIR.mkdir(parents=True, exist_ok=True)
+OUT        = OUT_DIR / "pmgsy_sampled.geojson"
+
+
+def sample(total_limit: int = 5000, per_state: int = 200) -> None:
+    print(f"Loading {SRC.name} ... (this takes ~30s for 867K features)")
+    with SRC.open(encoding="utf-8") as fh:
+        data = json.load(fh)
+
+    all_features = data.get("features", [])
+    print(f"Total features: {len(all_features):,}")
+
+    buckets: dict[str, list] = defaultdict(list)
+    for feat in all_features:
+        state = feat.get("properties", {}).get("pmgsy_state", "Unknown")
+        buckets[state].append(feat)
+
+    selected = []
+    for state, feats in sorted(buckets.items()):
+        chosen = feats[:per_state]
+        selected.extend(chosen)
+        if len(selected) >= total_limit:
+            break
+
+    selected = selected[:total_limit]
+    print(f"Selected {len(selected):,} features from {len(buckets)} states")
+
+    fc = {"type": "FeatureCollection", "features": selected}
+    OUT.write_text(json.dumps(fc, ensure_ascii=False), encoding="utf-8")
+    size_mb = OUT.stat().st_size / 1_048_576
+    print(f"Written: {OUT.relative_to(ROOT)}  ({size_mb:.1f} MB)")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--limit",     type=int, default=5000, help="Max total roads")
+    parser.add_argument("--per-state", type=int, default=200,  help="Max roads per state")
+    args = parser.parse_args()
+    sample(args.limit, args.per_state)
+    print("\nDone. Now update scripts/road_sources.json to use:")
+    print(f"  datasets/roads/pmgsy_sampled.geojson")

scripts/backend/data/seed_violations.py

@@ -0,0 +1,481 @@
+from __future__ import annotations
+
+import argparse
+import csv
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+BACKEND_DIR = Path(__file__).resolve().parents[1]
+PROJECT_ROOT = BACKEND_DIR.parent
+CHATBOT_DATA_DIR = PROJECT_ROOT / 'chatbot_service' / 'data'
+
+
+VEHICLE_CLASS_ALIASES = {
+    '2W': 'two_wheeler',
+    'BIKE': 'two_wheeler',
+    'MOTORCYCLE': 'two_wheeler',
+    'SCOOTER': 'two_wheeler',
+    '4W': 'light_motor_vehicle',
+    'CAR': 'light_motor_vehicle',
+    'LMV': 'light_motor_vehicle',
+    'AUTO': 'light_motor_vehicle',
+    'HTV': 'heavy_vehicle',
+    'HGV': 'heavy_vehicle',
+    'TRUCK': 'heavy_vehicle',
+    'BUS': 'bus',
+    'COMM': 'bus',
+    'COMMERCIAL': 'bus',
+}
+
+
+@dataclass(frozen=True, slots=True)
+class ChallanRule:
+    violation_code: str
+    section: str
+    description: str
+    base_fines: dict[str, int]
+    repeat_fines: dict[str, int] = field(default_factory=dict)
+    aliases: tuple[str, ...] = ()
+
+
+DEFAULT_RULES: tuple[ChallanRule, ...] = (
+    ChallanRule(
+        violation_code='183',
+        section='Section 183',
+        description='Speeding beyond the notified limit.',
+        base_fines={
+            'two_wheeler': 1000,
+            'light_motor_vehicle': 2000,
+            'heavy_vehicle': 4000,
+            'bus': 4000,
+            'default': 2000,
+        },
+        repeat_fines={
+            'two_wheeler': 2000,
+            'light_motor_vehicle': 4000,
+            'heavy_vehicle': 8000,
+            'bus': 8000,
+            'default': 4000,
+        },
+        aliases=('112/183',),
+    ),
+    ChallanRule(
+        violation_code='185',
+        section='Section 185',
+        description='Driving under the influence of alcohol or drugs.',
+        base_fines={'default': 10000},
+        repeat_fines={'default': 15000},
+        aliases=('DUI', 'DRUNK'),
+    ),
+    ChallanRule(
+        violation_code='181',
+        section='Sections 3/181',
+        description='Driving without a valid driving licence.',
+        base_fines={'default': 5000},
+        repeat_fines={'default': 10000},
+        aliases=('3/181',),
+    ),
+    ChallanRule(
+        violation_code='194D',
+        section='Sections 129/194D',
+        description='Failure to wear a helmet or seat belt as required.',
+        base_fines={'default': 1000},
+        repeat_fines={'default': 2000},
+        aliases=('194D-HELMET', '194D-SEATBELT'),
+    ),
+    ChallanRule(
+        violation_code='194B',
+        section='Section 194B',
+        description='Safety gear non-compliance on a two-wheeler or while carrying a child.',
+        base_fines={
+            'two_wheeler': 1000,
+            'light_motor_vehicle': 1000,
+            'default': 1000,
+        },
+        repeat_fines={'default': 2000},
+    ),
+    ChallanRule(
+        violation_code='179',
+        section='Section 179',
+        description='Disobedience, obstruction, or refusal to comply with lawful directions.',
+        base_fines={'default': 2000},
+        repeat_fines={'default': 4000},
+    ),
+)
+
+
+RULE_COLUMNS = [
+    'violation_code',
+    'section',
+    'description',
+    'base_fine',
+    'base_fine_2w',
+    'base_fine_4w',
+    'base_fine_htv',
+    'base_fine_bus',
+    'repeat_fine',
+    'repeat_fine_2w',
+    'repeat_fine_4w',
+    'repeat_fine_htv',
+    'repeat_fine_bus',
+    'aliases',
+]
+OVERRIDE_COLUMNS = [
+    'state_code',
+    'violation_code',
+    'vehicle_class',
+    'base_fine',
+    'repeat_fine',
+    'section',
+    'description',
+    'note',
+]
+DEFAULT_OUTPUT_DIR = BACKEND_DIR / 'datasets' / 'challan'
+RULE_SOURCE_CANDIDATES = ('violations_seed.csv', 'violations.csv')
+OVERRIDE_SOURCE_CANDIDATES = ('state_overrides_seed.csv', 'state_overrides.csv')
+
+
+def _resolve_source(output_dir: Path, candidates: tuple[str, ...], explicit: Path | None) -> Path | None:
+    if explicit is not None:
+        return explicit
+    for name in candidates:
+        candidate = output_dir / name
+        if candidate.exists():
+            return candidate
+    for name in candidates:
+        candidate = CHATBOT_DATA_DIR / name
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def _stringify(amount: int | None) -> str:
+    return '' if amount is None else str(amount)
+
+
+def _rule_to_row(rule: ChallanRule) -> dict[str, str]:
+    return {
+        'violation_code': rule.violation_code,
+        'section': rule.section,
+        'description': rule.description,
+        'base_fine': _stringify(rule.base_fines.get('default')),
+        'base_fine_2w': _stringify(rule.base_fines.get('two_wheeler')),
+        'base_fine_4w': _stringify(rule.base_fines.get('light_motor_vehicle')),
+        'base_fine_htv': _stringify(rule.base_fines.get('heavy_vehicle')),
+        'base_fine_bus': _stringify(rule.base_fines.get('bus')),
+        'repeat_fine': _stringify(rule.repeat_fines.get('default')),
+        'repeat_fine_2w': _stringify(rule.repeat_fines.get('two_wheeler')),
+        'repeat_fine_4w': _stringify(rule.repeat_fines.get('light_motor_vehicle')),
+        'repeat_fine_htv': _stringify(rule.repeat_fines.get('heavy_vehicle')),
+        'repeat_fine_bus': _stringify(rule.repeat_fines.get('bus')),
+        'aliases': '|'.join(rule.aliases),
+    }
+
+
+def _normalize_rule_row(row: dict[str, str]) -> dict[str, str] | None:
+    raw_violation_code = (
+        row.get('violation_code')
+        or row.get('code')
+        or row.get('violation')
+        or ''
+    ).strip()
+    violation_code, qualifier = _split_violation_code(raw_violation_code)
+    violation_code = _normalize_violation_code(
+        violation_code
+    )
+    if not violation_code:
+        return None
+
+    section = (row.get('section') or row.get('mva_section') or '').strip() or f'Section {violation_code}'
+    description = (row.get('description') or row.get('description_en') or row.get('label') or '').strip() or 'Traffic rule violation.'
+    base_fines = _extract_fines(row, prefix='base_fine')
+    if not base_fines:
+        default_base = _parse_money(row.get('fine') or row.get('base') or row.get('amount') or '')
+        if default_base is not None:
+            base_fines['default'] = default_base
+    seed_base = _parse_money(row.get('base_fine_inr') or '')
+    seed_repeat = _parse_money(row.get('repeat_fine_inr') or '')
+    seed_vehicle_class = _normalize_seed_vehicle_class(row.get('vehicle_type') or qualifier or '')
+    if qualifier == 'REPEAT':
+        if seed_base is not None:
+            repeat_fines = {seed_vehicle_class: seed_base}
+        else:
+            repeat_fines = {}
+    else:
+        repeat_fines = _extract_fines(row, prefix='repeat_fine')
+        if seed_base is not None:
+            base_fines[seed_vehicle_class] = seed_base
+        if seed_repeat is not None:
+            repeat_fines[seed_vehicle_class] = seed_repeat
+    if not base_fines:
+        return None
+
+    if not repeat_fines:
+        default_repeat = _parse_money(row.get('repeat') or row.get('repeat_amount') or '')
+        if default_repeat is not None:
+            repeat_fines['default'] = default_repeat
+
+    aliases = [
+        item.strip().upper()
+        for item in (row.get('aliases') or row.get('alternate_codes') or '').split('|')
+        if item.strip()
+    ]
+    return _rule_to_row(
+        ChallanRule(
+            violation_code=violation_code,
+            section=section,
+            description=description,
+            base_fines=base_fines,
+            repeat_fines=repeat_fines,
+            aliases=tuple(aliases),
+        )
+    )
+
+
+def _load_rule_rows(path: Path) -> list[dict[str, str]]:
+    with path.open('r', encoding='utf-8-sig', newline='') as handle:
+        reader = csv.DictReader(handle)
+        if reader.fieldnames is None:
+            return []
+        rows_by_code: dict[str, dict[str, str]] = {}
+        for raw in reader:
+            normalized = _normalize_rule_row(raw)
+            if normalized is not None:
+                code = normalized['violation_code']
+                existing = rows_by_code.get(code)
+                rows_by_code[code] = _merge_rule_rows(existing, normalized) if existing else normalized
+        return [rows_by_code[key] for key in sorted(rows_by_code)]
+
+
+def _normalize_override_row(row: dict[str, str]) -> dict[str, str] | None:
+    raw_state = row.get('state_code') or row.get('state') or ''
+    if not raw_state.strip():
+        return None
+    state_code = _normalize_state_code(raw_state)
+    violation_code = _normalize_violation_code(
+        row.get('violation_code')
+        or row.get('code')
+        or row.get('violation')
+        or ''
+    )
+    base_fine = _parse_money(
+        row.get('base_fine')
+        or row.get('fine')
+        or row.get('amount')
+        or row.get('override_fine')
+        or ''
+    )
+    if not violation_code or base_fine is None:
+        return None
+
+    vehicle_class = (row.get('vehicle_class') or row.get('vehicle') or '').strip()
+    normalized_vehicle_class = ''
+    if vehicle_class:
+        normalized_vehicle_class = _normalize_vehicle_class(vehicle_class)
+
+    authority = (row.get('authority') or row.get('source_title') or '').strip()
+    effective_date = (row.get('effective_date') or '').strip()
+    source_url = (row.get('source_url') or '').strip()
+    verified_on = (row.get('verified_on') or '').strip()
+    note_parts = [
+        (row.get('note') or row.get('state_override') or row.get('remarks') or '').strip(),
+        authority,
+        f'effective {effective_date}' if effective_date else '',
+        f'verified {verified_on}' if verified_on else '',
+        f'source {source_url}' if source_url else '',
+    ]
+
+    return {
+        'state_code': state_code,
+        'violation_code': violation_code,
+        'vehicle_class': normalized_vehicle_class,
+        'base_fine': str(base_fine),
+        'repeat_fine': _stringify(
+            _parse_money(row.get('repeat_fine') or row.get('repeat') or row.get('repeat_amount') or '')
+        ),
+        'section': (row.get('section') or '').strip(),
+        'description': (row.get('description') or row.get('description_en') or '').strip(),
+        'note': '; '.join(part for part in note_parts if part),
+    }
+
+
+def _extract_fines(row: dict[str, str], *, prefix: str) -> dict[str, int]:
+    mapping = {
+        'two_wheeler': [f'{prefix}_2w', f'{prefix}_two_wheeler'],
+        'light_motor_vehicle': [f'{prefix}_4w', f'{prefix}_lmv', f'{prefix}_car'],
+        'heavy_vehicle': [f'{prefix}_htv', f'{prefix}_truck', f'{prefix}_heavy_vehicle'],
+        'bus': [f'{prefix}_bus', f'{prefix}_comm'],
+        'default': [prefix, f'{prefix}_default'],
+    }
+    fines: dict[str, int] = {}
+    for vehicle_class, columns in mapping.items():
+        for column in columns:
+            amount = _parse_money(row.get(column) or '')
+            if amount is not None:
+                fines[vehicle_class] = amount
+                break
+    return fines
+
+
+def _parse_money(value: str) -> int | None:
+    if not value:
+        return None
+    normalized = re.sub(r'[^0-9]', '', value)
+    if not normalized:
+        return None
+    return int(normalized)
+
+
+def _normalize_violation_code(value: str) -> str:
+    return re.sub(r'[^A-Z0-9/]', '', value.strip().upper())
+
+
+def _split_violation_code(value: str) -> tuple[str, str]:
+    text = value.strip().upper()
+    if not text:
+        return '', ''
+    parts = [part for part in re.split(r'[_\-\s]+', text) if part]
+    if len(parts) == 1:
+        return parts[0], ''
+    return parts[0], parts[1]
+
+
+def _normalize_vehicle_class(value: str) -> str:
+    normalized = re.sub(r'[^A-Z0-9_ ]', '', value.strip().upper()).replace(' ', '_')
+    if not normalized:
+        raise ValueError('vehicle_class is required')
+    return VEHICLE_CLASS_ALIASES.get(normalized, normalized.lower())
+
+
+def _normalize_seed_vehicle_class(value: str) -> str:
+    normalized = re.sub(r'[^A-Z0-9_ ]', '', value.strip().upper()).replace(' ', '_')
+    if not normalized or normalized == 'ALL' or normalized == 'FIRST' or normalized == 'REPEAT':
+        return 'default'
+    if normalized in {'LMV', '4W', 'CAR', 'LIGHT_MOTOR_VEHICLE'}:
+        return 'light_motor_vehicle'
+    if normalized in {'HMV', 'HTV', 'HEAVY_VEHICLE', 'GOODS_VEHICLE'}:
+        return 'heavy_vehicle'
+    if normalized in {'BUS', 'SCHOOL_VEHICLE', 'TRANSPORT_VEHICLE'}:
+        return 'bus'
+    if normalized in {'2W', 'BIKE', 'MOTORCYCLE', 'TWO_WHEELER'}:
+        return 'two_wheeler'
+    return _normalize_vehicle_class(normalized)
+
+
+def _merge_rule_rows(existing: dict[str, str], incoming: dict[str, str]) -> dict[str, str]:
+    merged = dict(existing)
+    for column in RULE_COLUMNS:
+        if column == 'aliases':
+            aliases = {
+                item.strip()
+                for item in (merged.get('aliases') or '').split('|') + (incoming.get('aliases') or '').split('|')
+                if item.strip()
+            }
+            merged['aliases'] = '|'.join(sorted(aliases))
+            continue
+        if not merged.get(column) and incoming.get(column):
+            merged[column] = incoming[column]
+    return merged
+
+
+def _normalize_state_code(value: str) -> str:
+    cleaned = value.strip().upper()
+    if not cleaned:
+        raise ValueError('state_code is required')
+    if '(' in cleaned and ')' in cleaned:
+        inside = cleaned.split('(')[-1].split(')')[0].strip()
+        if inside:
+            cleaned = inside
+    if len(cleaned) > 2:
+        compact = re.sub(r'[^A-Z]', '', cleaned)
+        if len(compact) >= 2:
+            cleaned = compact[:2]
+    return cleaned
+
+
+def _load_override_rows(path: Path) -> list[dict[str, str]]:
+    with path.open('r', encoding='utf-8-sig', newline='') as handle:
+        reader = csv.DictReader(handle)
+        if reader.fieldnames is None:
+            return []
+        rows: list[dict[str, str]] = []
+        for raw in reader:
+            normalized = _normalize_override_row(raw)
+            if normalized is not None:
+                rows.append(normalized)
+        return rows
+
+
+def _write_csv(path: Path, fieldnames: list[str], rows: list[dict[str, str]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open('w', encoding='utf-8', newline='') as handle:
+        writer = csv.DictWriter(handle, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description='Normalize challan seed data into the backend CSVs used by the challan service.',
+    )
+    parser.add_argument(
+        '--output-dir',
+        type=Path,
+        default=DEFAULT_OUTPUT_DIR,
+        help=f'Directory that receives violations.csv and state_overrides.csv. Defaults to {DEFAULT_OUTPUT_DIR}',
+    )
+    parser.add_argument(
+        '--rules-source',
+        type=Path,
+        help='Optional source CSV to normalize into violations.csv.',
+    )
+    parser.add_argument(
+        '--overrides-source',
+        type=Path,
+        help='Optional source CSV to normalize into state_overrides.csv.',
+    )
+    parser.add_argument(
+        '--defaults-only',
+        action='store_true',
+        help='Ignore source files and emit only the backend built-in challan rules.',
+    )
+    args = parser.parse_args()
+
+    output_dir = args.output_dir
+    rules_path = output_dir / 'violations.csv'
+    overrides_path = output_dir / 'state_overrides.csv'
+
+    rule_map: dict[str, dict[str, str]] = {
+        rule.violation_code: _rule_to_row(rule)
+        for rule in DEFAULT_RULES
+    }
+
+    source_rules = None if args.defaults_only else _resolve_source(output_dir, RULE_SOURCE_CANDIDATES, args.rules_source)
+    if source_rules and source_rules.exists():
+        for row in _load_rule_rows(source_rules):
+            rule_map[row['violation_code']] = row
+
+    override_rows: list[dict[str, str]] = []
+    source_overrides = None if args.defaults_only else _resolve_source(output_dir, OVERRIDE_SOURCE_CANDIDATES, args.overrides_source)
+    if source_overrides and source_overrides.exists():
+        override_rows = _load_override_rows(source_overrides)
+
+    sorted_rules = [rule_map[key] for key in sorted(rule_map)]
+    sorted_overrides = sorted(
+        override_rows,
+        key=lambda row: (row['state_code'], row['violation_code'], row['vehicle_class']),
+    )
+
+    _write_csv(rules_path, RULE_COLUMNS, sorted_rules)
+    _write_csv(overrides_path, OVERRIDE_COLUMNS, sorted_overrides)
+
+    print(
+        f'Wrote {len(sorted_rules)} challan rules to {rules_path} '
+        f'and {len(sorted_overrides)} state overrides to {overrides_path}'
+    )
+
+
+if __name__ == '__main__':
+    main()

scripts/chatbot_service/data/_overpass_utils.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import time
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import Iterable
+
+
+ROOT_DIR = Path(__file__).resolve().parents[2]
+CHATBOT_SERVICE_DIR = ROOT_DIR / 'chatbot_service'
+
+DEFAULT_ENDPOINTS = (
+    'https://overpass-api.de/api/interpreter',
+    'https://overpass.kumi.systems/api/interpreter',
+    'https://lz4.overpass-api.de/api/interpreter',
+)
+DEFAULT_HEADERS = {
+    'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8',
+    'User-Agent': 'SafeVisionAI chatbot data fetcher/1.0',
+}
+CSV_COLUMNS = [
+    'name',
+    'lat',
+    'lon',
+    'phone',
+    'address',
+    'city',
+    'state',
+    'operator',
+    'osm_id',
+    'osm_type',
+    'category',
+    'opening_hours',
+    'website',
+    'email',
+    'postcode',
+    'source',
+]
+
+
+def build_arg_parser(description: str, default_output: Path) -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument(
+        '--output',
+        type=Path,
+        default=default_output,
+        help=f'CSV path to write. Defaults to {default_output}',
+    )
+    parser.add_argument(
+        '--endpoint',
+        help='Optional Overpass endpoint override. Defaults to the built-in endpoint fallback list.',
+    )
+    parser.add_argument(
+        '--timeout',
+        type=int,
+        default=180,
+        help='HTTP timeout in seconds. Defaults to 180.',
+    )
+    parser.add_argument(
+        '--retries',
+        type=int,
+        default=2,
+        help='Retries per endpoint before failing over. Defaults to 2.',
+    )
+    return parser
+
+
+def build_india_query(selectors: Iterable[str], *, timeout: int) -> str:
+    joined = '\n  '.join(selector.strip() for selector in selectors if selector.strip())
+    return (
+        f'[out:json][timeout:{timeout}];\n'
+        'area["ISO3166-1"="IN"][admin_level=2]->.india;\n'
+        '(\n'
+        f'  {joined}\n'
+        ');\n'
+        'out center tags;'
+    )
+
+
+def fetch_elements(
+    query: str,
+    *,
+    endpoint: str | None,
+    timeout: int,
+    retries: int,
+) -> list[dict]:
+    payload = urllib.parse.urlencode({'data': query}).encode('utf-8')
+    endpoints = [endpoint] if endpoint else list(DEFAULT_ENDPOINTS)
+    last_error: Exception | None = None
+
+    for url in endpoints:
+        for attempt in range(1, retries + 1):
+            request = urllib.request.Request(url, data=payload, headers=DEFAULT_HEADERS, method='POST')
+            try:
+                with urllib.request.urlopen(request, timeout=timeout) as response:
+                    decoded = response.read().decode('utf-8')
+                data = json.loads(decoded)
+                return list(data.get('elements', []))
+            except Exception as exc:  # pragma: no cover - network path
+                last_error = exc
+                if attempt < retries:
+                    time.sleep(min(attempt, 3))
+
+    raise SystemExit(f'Unable to fetch data from Overpass. Last error: {last_error}')
+
+
+def extract_point(element: dict) -> tuple[float | None, float | None]:
+    if 'lat' in element and 'lon' in element:
+        return float(element['lat']), float(element['lon'])
+
+    center = element.get('center') or {}
+    if 'lat' in center and 'lon' in center:
+        return float(center['lat']), float(center['lon'])
+
+    return None, None
+
+
+def first_non_empty(*values: str | None) -> str:
+    for value in values:
+        if value is None:
+            continue
+        text = str(value).strip()
+        if text:
+            return text
+    return ''
+
+
+def compose_address(tags: dict[str, str]) -> str:
+    return first_non_empty(
+        tags.get('addr:full'),
+        ', '.join(
+            part
+            for part in [
+                tags.get('addr:housenumber'),
+                tags.get('addr:street'),
+                tags.get('addr:suburb'),
+                first_non_empty(tags.get('addr:city'), tags.get('addr:town'), tags.get('addr:village')),
+                first_non_empty(tags.get('addr:district'), tags.get('addr:county')),
+                tags.get('addr:state'),
+                tags.get('addr:postcode'),
+            ]
+            if part
+        ),
+    )
+
+
+def normalize_row(element: dict, *, default_category: str, fallback_name: str) -> dict | None:
+    lat, lon = extract_point(element)
+    if lat is None or lon is None:
+        return None
+
+    tags = element.get('tags', {})
+    return {
+        'name': first_non_empty(tags.get('name'), fallback_name),
+        'lat': f'{lat:.6f}',
+        'lon': f'{lon:.6f}',
+        'phone': first_non_empty(tags.get('phone'), tags.get('contact:phone'), tags.get('emergency:phone')),
+        'address': compose_address(tags),
+        'city': first_non_empty(tags.get('addr:city'), tags.get('addr:town'), tags.get('addr:village')),
+        'state': first_non_empty(tags.get('addr:state')),
+        'operator': first_non_empty(tags.get('operator')),
+        'osm_id': str(element.get('id', '')),
+        'osm_type': str(element.get('type', '')),
+        'category': first_non_empty(
+            tags.get('amenity'),
+            tags.get('healthcare'),
+            tags.get('office'),
+            tags.get('emergency'),
+            default_category,
+        ),
+        'opening_hours': first_non_empty(tags.get('opening_hours')),
+        'website': first_non_empty(tags.get('website'), tags.get('contact:website')),
+        'email': first_non_empty(tags.get('email'), tags.get('contact:email')),
+        'postcode': first_non_empty(tags.get('addr:postcode')),
+        'source': 'overpass',
+    }
+
+
+def dedupe_rows(rows: Iterable[dict]) -> list[dict]:
+    seen: set[tuple[str, str, str, str]] = set()
+    deduped: list[dict] = []
+    for row in rows:
+        key = (
+            row.get('name', '').strip().lower(),
+            row.get('category', '').strip().lower(),
+            row.get('lat', ''),
+            row.get('lon', ''),
+        )
+        if key in seen:
+            continue
+        seen.add(key)
+        deduped.append(row)
+    deduped.sort(key=lambda item: (item.get('state', ''), item.get('city', ''), item.get('name', '')))
+    return deduped
+
+
+def write_rows(path: Path, rows: Iterable[dict]) -> int:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    materialized = dedupe_rows(rows)
+    with path.open('w', newline='', encoding='utf-8') as handle:
+        writer = csv.DictWriter(handle, fieldnames=CSV_COLUMNS)
+        writer.writeheader()
+        writer.writerows(materialized)
+    return len(materialized)
+
+
+def print_summary(*, label: str, count: int, output: Path) -> None:
+    print(f'Saved {count} {label} records to {output}')

scripts/chatbot_service/data/fetch_ambulance.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from _overpass_utils import (
+    CHATBOT_SERVICE_DIR,
+    build_arg_parser,
+    build_india_query,
+    fetch_elements,
+    normalize_row,
+    print_summary,
+    write_rows,
+)
+
+
+DEFAULT_OUTPUT = CHATBOT_SERVICE_DIR / 'data' / 'emergency' / 'ambulance_stations.csv'
+SELECTORS = [
+    'node["emergency"="ambulance_station"](area.india);',
+    'way["emergency"="ambulance_station"](area.india);',
+    'relation["emergency"="ambulance_station"](area.india);',
+    'node["amenity"="ambulance_station"](area.india);',
+    'way["amenity"="ambulance_station"](area.india);',
+    'relation["amenity"="ambulance_station"](area.india);',
+    'node["healthcare"="ambulance_station"](area.india);',
+    'way["healthcare"="ambulance_station"](area.india);',
+    'relation["healthcare"="ambulance_station"](area.india);',
+]
+
+
+def main() -> None:
+    parser = build_arg_parser('Fetch India ambulance station data from Overpass.', DEFAULT_OUTPUT)
+    args = parser.parse_args()
+
+    query = build_india_query(SELECTORS, timeout=args.timeout)
+    elements = fetch_elements(query, endpoint=args.endpoint, timeout=args.timeout, retries=args.retries)
+    rows = [
+        row
+        for element in elements
+        if (row := normalize_row(element, default_category='ambulance', fallback_name='Unnamed ambulance station')) is not None
+    ]
+    count = write_rows(args.output, rows)
+    print_summary(label='ambulance station', count=count, output=args.output)
+
+
+if __name__ == '__main__':
+    main()

scripts/chatbot_service/data/fetch_blood_banks.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from _overpass_utils import (
+    CHATBOT_SERVICE_DIR,
+    build_arg_parser,
+    build_india_query,
+    fetch_elements,
+    normalize_row,
+    print_summary,
+    write_rows,
+)
+
+
+DEFAULT_OUTPUT = CHATBOT_SERVICE_DIR / 'data' / 'hospitals' / 'blood_bank_directory.csv'
+SELECTORS = [
+    'node["amenity"="blood_bank"](area.india);',
+    'way["amenity"="blood_bank"](area.india);',
+    'relation["amenity"="blood_bank"](area.india);',
+    'node["healthcare"="blood_bank"](area.india);',
+    'way["healthcare"="blood_bank"](area.india);',
+    'relation["healthcare"="blood_bank"](area.india);',
+    'node["blood_bank"="yes"](area.india);',
+    'way["blood_bank"="yes"](area.india);',
+    'relation["blood_bank"="yes"](area.india);',
+]
+
+
+def main() -> None:
+    parser = build_arg_parser('Fetch India blood bank data from Overpass.', DEFAULT_OUTPUT)
+    args = parser.parse_args()
+
+    query = build_india_query(SELECTORS, timeout=args.timeout)
+    elements = fetch_elements(query, endpoint=args.endpoint, timeout=args.timeout, retries=args.retries)
+    rows = [
+        row
+        for element in elements
+        if (row := normalize_row(element, default_category='blood_bank', fallback_name='Unnamed blood bank')) is not None
+    ]
+    count = write_rows(args.output, rows)
+    print_summary(label='blood bank', count=count, output=args.output)
+
+
+if __name__ == '__main__':
+    main()

scripts/chatbot_service/data/fetch_fire.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from _overpass_utils import (
+    CHATBOT_SERVICE_DIR,
+    build_arg_parser,
+    build_india_query,
+    fetch_elements,
+    normalize_row,
+    print_summary,
+    write_rows,
+)
+
+
+DEFAULT_OUTPUT = CHATBOT_SERVICE_DIR / 'data' / 'emergency' / 'fire_stations.csv'
+SELECTORS = [
+    'node["amenity"="fire_station"](area.india);',
+    'way["amenity"="fire_station"](area.india);',
+    'relation["amenity"="fire_station"](area.india);',
+]
+
+
+def main() -> None:
+    parser = build_arg_parser('Fetch India fire station data from Overpass.', DEFAULT_OUTPUT)
+    args = parser.parse_args()
+
+    query = build_india_query(SELECTORS, timeout=args.timeout)
+    elements = fetch_elements(query, endpoint=args.endpoint, timeout=args.timeout, retries=args.retries)
+    rows = [
+        row
+        for element in elements
+        if (row := normalize_row(element, default_category='fire_station', fallback_name='Unnamed fire station')) is not None
+    ]
+    count = write_rows(args.output, rows)
+    print_summary(label='fire service', count=count, output=args.output)
+
+
+if __name__ == '__main__':
+    main()

scripts/chatbot_service/data/fetch_hospitals.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from _overpass_utils import (
+    CHATBOT_SERVICE_DIR,
+    build_arg_parser,
+    build_india_query,
+    fetch_elements,
+    normalize_row,
+    print_summary,
+    write_rows,
+)
+
+
+DEFAULT_OUTPUT = CHATBOT_SERVICE_DIR / 'data' / 'hospitals' / 'hospital_directory.csv'
+SELECTORS = [
+    'node["amenity"~"hospital|clinic"](area.india);',
+    'way["amenity"~"hospital|clinic"](area.india);',
+    'relation["amenity"~"hospital|clinic"](area.india);',
+    'node["healthcare"~"hospital|clinic"](area.india);',
+    'way["healthcare"~"hospital|clinic"](area.india);',
+    'relation["healthcare"~"hospital|clinic"](area.india);',
+]
+
+
+def main() -> None:
+    parser = build_arg_parser('Fetch India hospital and clinic data from Overpass.', DEFAULT_OUTPUT)
+    args = parser.parse_args()
+
+    query = build_india_query(SELECTORS, timeout=args.timeout)
+    elements = fetch_elements(query, endpoint=args.endpoint, timeout=args.timeout, retries=args.retries)
+    rows = [
+        row
+        for element in elements
+        if (row := normalize_row(element, default_category='hospital', fallback_name='Unnamed hospital')) is not None
+    ]
+    count = write_rows(args.output, rows)
+    print_summary(label='hospital', count=count, output=args.output)
+
+
+if __name__ == '__main__':
+    main()

scripts/chatbot_service/data/fetch_police.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from _overpass_utils import (
+    CHATBOT_SERVICE_DIR,
+    build_arg_parser,
+    build_india_query,
+    fetch_elements,
+    normalize_row,
+    print_summary,
+    write_rows,
+)
+
+
+DEFAULT_OUTPUT = CHATBOT_SERVICE_DIR / 'data' / 'emergency' / 'police_stations.csv'
+SELECTORS = [
+    'node["amenity"="police"](area.india);',
+    'way["amenity"="police"](area.india);',
+    'relation["amenity"="police"](area.india);',
+    'node["office"="police"](area.india);',
+    'way["office"="police"](area.india);',
+    'relation["office"="police"](area.india);',
+]
+
+
+def main() -> None:
+    parser = build_arg_parser('Fetch India police station data from Overpass.', DEFAULT_OUTPUT)
+    args = parser.parse_args()
+
+    query = build_india_query(SELECTORS, timeout=args.timeout)
+    elements = fetch_elements(query, endpoint=args.endpoint, timeout=args.timeout, retries=args.retries)
+    rows = [
+        row
+        for element in elements
+        if (row := normalize_row(element, default_category='police', fallback_name='Unnamed police station')) is not None
+    ]
+    count = write_rows(args.output, rows)
+    print_summary(label='police station', count=count, output=args.output)
+
+
+if __name__ == '__main__':
+    main()

scripts/scripts/data/_overpass_utils.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import Iterable
+
+
+ROOT_DIR = Path(__file__).resolve().parents[1]
+DEFAULT_ENDPOINTS = (
+    'https://overpass-api.de/api/interpreter',
+    'https://overpass.kumi.systems/api/interpreter',
+    'https://lz4.overpass-api.de/api/interpreter',
+)
+DEFAULT_HEADERS = {
+    'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8',
+    'User-Agent': 'SafeVisionAI bootstrap scripts/1.0',
+}
+CSV_COLUMNS = [
+    'osm_id',
+    'osm_type',
+    'name',
+    'lat',
+    'lon',
+    'phone',
+    'type',
+    'city',
+    'state',
+    'address',
+    'opening_hours',
+    'website',
+    'source',
+]
+
+
+def build_arg_parser(description: str, default_output: Path) -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument(
+        '--output',
+        type=Path,
+        default=default_output,
+        help=f'CSV path to write. Defaults to {default_output}',
+    )
+    parser.add_argument(
+        '--endpoint',
+        help='Optional Overpass endpoint override. Defaults to a built-in fallback list.',
+    )
+    parser.add_argument(
+        '--timeout',
+        type=int,
+        default=300,
+        help='HTTP timeout in seconds. Defaults to 300.',
+    )
+    return parser
+
+
+def build_india_query(selectors: Iterable[str], *, timeout: int) -> str:
+    joined_selectors = '\n  '.join(selector.strip() for selector in selectors if selector.strip())
+    return (
+        f'[out:json][timeout:{timeout}];\n'
+        'area["ISO3166-1"="IN"][admin_level=2]->.searchArea;\n'
+        '(\n'
+        f'  {joined_selectors}\n'
+        ');\n'
+        'out center tags;'
+    )
+
+
+def fetch_elements(query: str, *, endpoint: str | None, timeout: int) -> list[dict]:
+    payload = urllib.parse.urlencode({'data': query}).encode('utf-8')
+    endpoints = [endpoint] if endpoint else list(DEFAULT_ENDPOINTS)
+    last_error: Exception | None = None
+
+    for url in endpoints:
+        request = urllib.request.Request(url, data=payload, headers=DEFAULT_HEADERS, method='POST')
+        try:
+            with urllib.request.urlopen(request, timeout=timeout) as response:
+                decoded = response.read().decode('utf-8')
+            data = json.loads(decoded)
+            return list(data.get('elements', []))
+        except Exception as exc:  # pragma: no cover - network failure path
+            last_error = exc
+
+    raise SystemExit(f'Unable to fetch data from Overpass. Last error: {last_error}')
+
+
+def extract_point(element: dict) -> tuple[float | None, float | None]:
+    if 'lat' in element and 'lon' in element:
+        return float(element['lat']), float(element['lon'])
+
+    center = element.get('center') or {}
+    if 'lat' in center and 'lon' in center:
+        return float(center['lat']), float(center['lon'])
+
+    return None, None
+
+
+def compose_address(tags: dict[str, str]) -> str:
+    parts = [
+        tags.get('addr:housenumber'),
+        tags.get('addr:street'),
+        tags.get('addr:suburb'),
+        tags.get('addr:city') or tags.get('addr:town') or tags.get('addr:village'),
+        tags.get('addr:state'),
+    ]
+    return ', '.join(part for part in parts if part)
+
+
+def normalize_row(element: dict, *, default_type: str, fallback_name: str) -> dict | None:
+    lat, lon = extract_point(element)
+    if lat is None or lon is None:
+        return None
+
+    tags = element.get('tags', {})
+    amenity_type = tags.get('amenity') or tags.get('healthcare') or tags.get('emergency') or default_type
+    return {
+        'osm_id': str(element.get('id', '')),
+        'osm_type': str(element.get('type', '')),
+        'name': tags.get('name') or fallback_name,
+        'lat': f'{lat:.6f}',
+        'lon': f'{lon:.6f}',
+        'phone': tags.get('phone') or tags.get('contact:phone') or tags.get('emergency:phone') or '',
+        'type': amenity_type,
+        'city': tags.get('addr:city') or tags.get('addr:town') or tags.get('addr:village') or '',
+        'state': tags.get('addr:state') or '',
+        'address': compose_address(tags),
+        'opening_hours': tags.get('opening_hours') or '',
+        'website': tags.get('website') or tags.get('contact:website') or '',
+        'source': 'overpass',
+    }
+
+
+def dedupe_rows(rows: Iterable[dict]) -> list[dict]:
+    seen: set[tuple[str, str, str, str]] = set()
+    deduped: list[dict] = []
+    for row in rows:
+        key = (
+            row.get('name', '').strip().lower(),
+            row.get('type', '').strip().lower(),
+            row.get('lat', ''),
+            row.get('lon', ''),
+        )
+        if key in seen:
+            continue
+        seen.add(key)
+        deduped.append(row)
+    deduped.sort(key=lambda item: (item['state'], item['city'], item['name']))
+    return deduped
+
+
+def write_rows(path: Path, rows: Iterable[dict]) -> int:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    materialized = dedupe_rows(rows)
+    with path.open('w', newline='', encoding='utf-8') as handle:
+        writer = csv.DictWriter(handle, fieldnames=CSV_COLUMNS)
+        writer.writeheader()
+        writer.writerows(materialized)
+    return len(materialized)

scripts/scripts/data/audit_env.py

@@ -0,0 +1,128 @@
+"""Full audit of all .env files vs what the configs actually expect."""
+import re
+from pathlib import Path
+
+ROOT = Path(".")
+
+# ── 1. Read all actual .env files ────────────────────────────────────────────
+print("=" * 70)
+print("  ALL ENV FILES — CURRENT STATE")
+print("=" * 70)
+env_files = {}
+for f in sorted(ROOT.rglob(".env*")):
+    if any(x in f.parts for x in [".git", "node_modules", ".venv", "__pycache__"]):
+        continue
+    if f.suffix in (".example", ".local", ".bak"):
+        continue
+    lines = f.read_text(encoding="utf-8", errors="ignore").splitlines()
+    keys = {}
+    for line in lines:
+        line = line.strip()
+        if line and not line.startswith("#") and "=" in line:
+            k, _, v = line.partition("=")
+            keys[k.strip()] = v.strip()
+    env_files[str(f)] = keys
+    print(f"\n[{f}]")
+    for k, v in keys.items():
+        masked = v[:6] + "..." if len(v) > 10 and any(c in k.upper() for c in ["KEY", "TOKEN", "SECRET", "PASSWORD"]) else v
+        status = "OK" if v and not v.startswith("YOUR_") else "MISSING/PLACEHOLDER"
+        print(f"  [{status:^19}]  {k} = {masked}")
+
+# ── 2. What does chatbot_service/config.py expect? ────────────────────────────
+print("\n" + "=" * 70)
+print("  CHATBOT CONFIG — EXPECTED KEYS")
+print("=" * 70)
+cs_config = Path("chatbot_service/config.py").read_text(encoding="utf-8")
+
+# Extract field names and env aliases from pydantic Settings
+field_pattern = re.compile(r'(\w+)\s*:\s*[\w\|\[\]]+[^\n]*=\s*Field\(')
+alias_pattern = re.compile(r'validation_alias\s*=\s*["\']([A-Z_]+)["\']')
+
+chatbot_keys = set(re.findall(r'["\']([A-Z_][A-Z0-9_]+)["\']', cs_config))
+chatbot_keys.update(re.findall(r'os\.(?:environ|getenv)\(["\']([A-Z_]+)', cs_config))
+
+chatbot_env = env_files.get("chatbot_service\\.env", env_files.get("chatbot_service/.env", {}))
+if not chatbot_env:
+    for k in env_files:
+        if "chatbot_service" in k and ".example" not in k:
+            chatbot_env = env_files[k]
+            break
+
+missing_chatbot = []
+for key in sorted(chatbot_keys):
+    if len(key) < 4:
+        continue
+    in_env = key in chatbot_env
+    val = chatbot_env.get(key, "")
+    is_placeholder = val.startswith("YOUR_") or not val
+    if not in_env or is_placeholder:
+        missing_chatbot.append((key, "MISSING" if not in_env else "PLACEHOLDER"))
+
+if missing_chatbot:
+    for k, status in missing_chatbot:
+        print(f"  [!] {k}: {status}")
+else:
+    print("  All expected keys present.")
+
+# ── 3. What does backend/core/config.py expect? ────────────────────────────────
+print("\n" + "=" * 70)
+print("  BACKEND CONFIG — EXPECTED KEYS")
+print("=" * 70)
+be_config = Path("backend/core/config.py").read_text(encoding="utf-8")
+backend_keys = set(re.findall(r'["\']([A-Z_][A-Z0-9_]+)["\']', be_config))
+backend_keys.update(re.findall(r'os\.(?:environ|getenv)\(["\']([A-Z_]+)', be_config))
+
+backend_env = {}
+for k in env_files:
+    if "backend" in k and "chatbot" not in k and ".example" not in k:
+        backend_env = env_files[k]
+        break
+
+missing_backend = []
+for key in sorted(backend_keys):
+    if len(key) < 4:
+        continue
+    in_env = key in backend_env
+    val = backend_env.get(key, "")
+    is_placeholder = val.startswith("YOUR_") or not val
+    if not in_env or is_placeholder:
+        missing_backend.append((key, "MISSING" if not in_env else "PLACEHOLDER"))
+
+if missing_backend:
+    for k, status in missing_backend:
+        print(f"  [!] {k}: {status}")
+else:
+    print("  All expected keys present.")
+
+# ── 4. Frontend env check ────────────────────────────────────────────────────
+print("\n" + "=" * 70)
+print("  FRONTEND .env — EXPECTED KEYS")
+print("=" * 70)
+# Scan all .ts/.tsx files for process.env or NEXT_PUBLIC_ usage
+fe_keys = set()
+for f in Path("frontend").rglob("*.ts"):
+    if "node_modules" in f.parts:
+        continue
+    txt = f.read_text(encoding="utf-8", errors="ignore")
+    fe_keys.update(re.findall(r'process\.env\.([A-Z_][A-Z0-9_]+)', txt))
+    fe_keys.update(re.findall(r'process\.env\[["\']([A-Z_][A-Z0-9_]+)', txt))
+
+fe_env = {}
+for k in env_files:
+    if "frontend" in k and ".example" not in k:
+        fe_env = env_files[k]
+        break
+
+if fe_keys:
+    for key in sorted(fe_keys):
+        val = fe_env.get(key, "")
+        status = "OK" if val and not val.startswith("YOUR_") else "MISSING"
+        print(f"  [{status}]  {key} = {val or '(not set)'}")
+else:
+    print("  No process.env usage found in frontend TypeScript files.")
+
+print("\n" + "=" * 70)
+print("  SUMMARY")
+print("=" * 70)
+print(f"  Chatbot missing/placeholder: {len(missing_chatbot)} keys")
+print(f"  Backend missing/placeholder: {len(missing_backend)} keys")

scripts/scripts/data/bootstrap_local_data.py

@@ -0,0 +1,557 @@
+from __future__ import annotations
+
+import argparse
+import csv
+from io import BytesIO
+import json
+import math
+import shutil
+import struct
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+BACKEND_ROOT = PROJECT_ROOT / 'backend'
+
+import importlib.util as _ilu
+
+
+def _load_backend_module(rel_path: str, module_name: str):
+    """Load a module from backend/ by explicit file path and register it in
+    sys.modules under *module_name*.  This makes the import fully transparent
+    to Pylance/Pyright (no opaque sys.path mutation) while still satisfying
+    Python internals that need __module__ to be resolvable (e.g. dataclasses
+    with slots=True)."""
+    abs_path = BACKEND_ROOT / rel_path
+    spec = _ilu.spec_from_file_location(module_name, abs_path)
+    mod = _ilu.module_from_spec(spec)  # type: ignore[arg-type]
+    sys.modules[module_name] = mod  # register BEFORE exec so __module__ resolves
+    spec.loader.exec_module(mod)  # type: ignore[union-attr]
+    return mod
+
+
+_seed_viol = _load_backend_module("scripts/seed_violations.py", "scripts.seed_violations")
+DEFAULT_RULES = _seed_viol.DEFAULT_RULES
+OVERRIDE_COLUMNS = _seed_viol.OVERRIDE_COLUMNS
+RULE_COLUMNS = _seed_viol.RULE_COLUMNS
+_load_override_rows = _seed_viol._load_override_rows
+_load_rule_rows = _seed_viol._load_rule_rows
+_rule_to_row = _seed_viol._rule_to_row
+_write_csv = _seed_viol._write_csv
+
+_emerg_catalog = _load_backend_module("services/local_emergency_catalog.py", "services.local_emergency_catalog")
+load_local_emergency_catalog = _emerg_catalog.load_local_emergency_catalog
+
+
+
+CHATBOT_DATA_DIR = PROJECT_ROOT / 'chatbot_service' / 'data'
+FRONTEND_OFFLINE_DIR = PROJECT_ROOT / 'frontend' / 'public' / 'offline-data'
+BACKEND_CHALLAN_DIR = PROJECT_ROOT / 'backend' / 'datasets' / 'challan'
+ROADS_DIR = CHATBOT_DATA_DIR / 'roads'
+PMGSY_MAX_POINTS_PER_SEGMENT = 24
+
+OFFLINE_CITY_CENTERS: dict[str, tuple[float, float]] = {
+    'chennai': (13.0827, 80.2707),
+    'coimbatore': (11.0168, 76.9558),
+    'madurai': (9.9252, 78.1198),
+    'thiruvananthapuram': (8.5241, 76.9366),
+    'kochi': (9.9312, 76.2673),
+    'bengaluru': (12.9716, 77.5946),
+    'mumbai': (19.0760, 72.8777),
+    'pune': (18.5204, 73.8567),
+    'nagpur': (21.1458, 79.0882),
+    'hyderabad': (17.3850, 78.4867),
+    'delhi': (28.6139, 77.2090),
+    'jaipur': (26.9124, 75.7873),
+    'ahmedabad': (23.0225, 72.5714),
+    'surat': (21.1702, 72.8311),
+    'vadodara': (22.3072, 73.1812),
+    'kolkata': (22.5726, 88.3639),
+    'patna': (25.5941, 85.1376),
+    'bhopal': (23.2599, 77.4126),
+    'indore': (22.7196, 75.8577),
+    'lucknow': (26.8467, 80.9462),
+    'agra': (27.1767, 78.0081),
+    'varanasi': (25.3176, 82.9739),
+    'chandigarh': (30.7333, 76.7794),
+    'visakhapatnam': (17.6868, 83.2185),
+    'bhubaneswar': (20.2961, 85.8245),
+}
+CITY_RADIUS_METERS = 80_000
+
+
+def sync_challan_assets() -> None:
+    rules_source = CHATBOT_DATA_DIR / 'violations_seed.csv'
+    overrides_source = CHATBOT_DATA_DIR / 'state_overrides.csv'
+    rule_map = {rule.violation_code: _rule_to_row(rule) for rule in DEFAULT_RULES}
+    if rules_source.exists():
+        for row in _load_rule_rows(rules_source):
+            rule_map[row['violation_code']] = row
+    override_rows = _load_override_rows(overrides_source) if overrides_source.exists() else []
+
+    sorted_rules = [rule_map[key] for key in sorted(rule_map)]
+    sorted_overrides = sorted(
+        override_rows,
+        key=lambda row: (row['state_code'], row['violation_code'], row['vehicle_class']),
+    )
+
+    BACKEND_CHALLAN_DIR.mkdir(parents=True, exist_ok=True)
+    FRONTEND_OFFLINE_DIR.mkdir(parents=True, exist_ok=True)
+    _write_csv(BACKEND_CHALLAN_DIR / 'violations.csv', RULE_COLUMNS, sorted_rules)
+    _write_csv(BACKEND_CHALLAN_DIR / 'state_overrides.csv', OVERRIDE_COLUMNS, sorted_overrides)
+    _write_csv(FRONTEND_OFFLINE_DIR / 'violations.csv', RULE_COLUMNS, sorted_rules)
+    _write_csv(FRONTEND_OFFLINE_DIR / 'state_overrides.csv', OVERRIDE_COLUMNS, sorted_overrides)
+    print(f'Challan assets synced: rules={len(sorted_rules)} overrides={len(sorted_overrides)}')
+
+
+def sync_first_aid_bundle() -> None:
+    """Always sync first-aid.json from frontend (canonical 20-article source) to chatbot data.
+
+    The chatbot_service/data/first_aid.json was historically only 4 entries.
+    The frontend/public/offline-data/first-aid.json contains the full 20 WHO-based articles
+    and is the ground truth. This function overwrites unconditionally so the chatbot is never
+    left with the stale 4-entry version.
+    """
+    source = FRONTEND_OFFLINE_DIR / 'first-aid.json'
+    target = CHATBOT_DATA_DIR / 'first_aid.json'
+    if not source.exists():
+        print(f'WARNING: first-aid.json source not found at {source} — skipping sync')
+        return
+    shutil.copyfile(source, target)
+    print(f'Synced first aid bundle ({source.stat().st_size:,} bytes) -> {target}')
+
+
+def build_emergency_geojson() -> None:
+    catalog = load_local_emergency_catalog(PROJECT_ROOT)
+    features = []
+    for entry in catalog:
+        city, distance = _nearest_city(entry.lat, entry.lon)
+        if city is None or distance > CITY_RADIUS_METERS:
+            continue
+        features.append(
+            {
+                'type': 'Feature',
+                'id': entry.id,
+                'geometry': {'type': 'Point', 'coordinates': [entry.lon, entry.lat]},
+                'properties': {
+                    'city': city.title(),
+                    'name': entry.name,
+                    'category': entry.category,
+                    'sub_category': entry.sub_category,
+                    'phone': entry.phone,
+                    'phone_emergency': entry.phone_emergency,
+                    'address': entry.address,
+                    'has_trauma': entry.has_trauma,
+                    'has_icu': entry.has_icu,
+                    'is_24hr': entry.is_24hr,
+                    'source': entry.source,
+                },
+            }
+        )
+
+    payload = {
+        'type': 'FeatureCollection',
+        'properties': {
+            'generated_from': 'chatbot_service/data local CSV catalog',
+            'feature_count': len(features),
+            'cities': [city.title() for city in OFFLINE_CITY_CENTERS],
+        },
+        'features': features,
+    }
+    output_path = FRONTEND_OFFLINE_DIR / 'india-emergency.geojson'
+    output_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding='utf-8')
+    print(f'Emergency GeoJSON written: features={len(features)} path={output_path}')
+
+
+def export_pmgsy_geojson() -> None:
+    source = ROADS_DIR / 'pmgsy-geosadak-master.zip'
+    target = ROADS_DIR / 'pmgsy_roads.geojson'
+    if not source.exists():
+        print('PMGSY archive not found; skipping pmgsy_roads.geojson export')
+        return
+
+    planned_states: list[str] = []
+    skipped_archives: list[str] = []
+    feature_count = 0
+
+    with zipfile.ZipFile(source) as outer, target.open('w', encoding='utf-8') as handle:
+        planned_states = _list_pmgsy_state_members(outer)
+        skipped_archives = _list_pmgsy_split_archives(outer)
+        properties = {
+            'generated_from': source.name,
+            'geometry_generalization': f'max {PMGSY_MAX_POINTS_PER_SEGMENT} points per segment',
+            'planned_states': planned_states,
+            'skipped_archives': skipped_archives,
+        }
+        handle.write('{"type":"FeatureCollection","properties":')
+        json.dump(properties, handle, ensure_ascii=False, separators=(',', ':'))
+        handle.write(',"features":[')
+
+        is_first_feature = True
+        exported_states: list[str] = []
+        for state_name, archive_bytes in _iter_pmgsy_state_archives(outer):
+            try:
+                shp_bytes, dbf_bytes = _read_shapefile_bundle(archive_bytes)
+            except ValueError:
+                continue
+
+            exported_states.append(state_name)
+            for row, geometry in zip(_iter_dbf_rows(dbf_bytes), _iter_polyline_geometries(shp_bytes)):
+                if geometry is None:
+                    continue
+                feature = {
+                    'type': 'Feature',
+                    'id': f'pmgsy-{state_name}-{row.get("ER_ID") or feature_count + 1}',
+                    'geometry': geometry,
+                    'properties': _build_pmgsy_properties(row, state_name),
+                }
+                if not is_first_feature:
+                    handle.write(',')
+                json.dump(feature, handle, ensure_ascii=False, separators=(',', ':'))
+                is_first_feature = False
+                feature_count += 1
+
+        handle.write(']}')
+
+    print(
+        'PMGSY GeoJSON exported: '
+        f'rows={feature_count} states={len(exported_states)} skipped={len(skipped_archives)} path={target}'
+    )
+
+
+def export_national_highways_csv() -> None:
+    target = ROADS_DIR / 'national_highways.csv'
+    if target.exists() and target.stat().st_size > 0:
+        print(f'National highways CSV already present: {target}')
+        return
+
+    candidates = sorted(
+        path for path in ROADS_DIR.glob('*.csv')
+        if path.name != target.name and any(token in path.stem.lower() for token in ('nh', 'highway', 'nhai'))
+    )
+    if not candidates:
+        summary_rows = _build_road_summary_rows()
+        if not summary_rows:
+            print('No usable local road CSVs found; skipping national_highways.csv export')
+            return
+
+        target.parent.mkdir(parents=True, exist_ok=True)
+        with target.open('w', encoding='utf-8', newline='') as handle:
+            writer = csv.DictWriter(
+                handle,
+                fieldnames=[
+                    'source_file',
+                    'geography_level',
+                    'geography_name',
+                    'period',
+                    'metric_name',
+                    'value',
+                    'unit',
+                    'notes',
+                ],
+            )
+            writer.writeheader()
+            writer.writerows(summary_rows)
+        print(
+            'National highways CSV synthesized from local road tables: '
+            f'rows={len(summary_rows)} path={target}'
+        )
+        return
+
+    shutil.copyfile(candidates[0], target)
+    print(f'National highways CSV copied from {candidates[0].name} to {target}')
+
+
+def _nearest_city(lat: float, lon: float) -> tuple[str | None, float]:
+    best_city = None
+    best_distance = float('inf')
+    for city, (city_lat, city_lon) in OFFLINE_CITY_CENTERS.items():
+        distance = _distance_meters(lat, lon, city_lat, city_lon)
+        if distance < best_distance:
+            best_city = city
+            best_distance = distance
+    return best_city, best_distance
+
+
+def _distance_meters(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    radius = 6_371_000
+    phi1 = math.radians(lat1)
+    phi2 = math.radians(lat2)
+    delta_phi = math.radians(lat2 - lat1)
+    delta_lambda = math.radians(lon2 - lon1)
+    a = (
+        math.sin(delta_phi / 2) ** 2
+        + math.cos(phi1) * math.cos(phi2) * math.sin(delta_lambda / 2) ** 2
+    )
+    return 2 * radius * math.atan2(math.sqrt(a), math.sqrt(1 - a))
+
+
+def _list_pmgsy_state_members(outer: zipfile.ZipFile) -> list[str]:
+    return [
+        Path(member).stem
+        for member in sorted(name for name in outer.namelist() if '/Road_DRRP/' in name and name.endswith('.zip'))
+        if not member.endswith('-split.zip')
+    ]
+
+
+def _list_pmgsy_split_archives(outer: zipfile.ZipFile) -> list[str]:
+    return [
+        Path(member).stem
+        for member in sorted(name for name in outer.namelist() if '/Road_DRRP/' in name and name.endswith('-split.zip'))
+    ]
+
+
+def _iter_pmgsy_state_archives(outer: zipfile.ZipFile):
+    for member in sorted(name for name in outer.namelist() if '/Road_DRRP/' in name and name.endswith('.zip')):
+        if member.endswith('-split.zip'):
+            continue
+        yield Path(member).stem, outer.read(member)
+
+
+def _read_shapefile_bundle(archive_bytes: bytes) -> tuple[bytes, bytes]:
+    with zipfile.ZipFile(BytesIO(archive_bytes)) as archive:
+        shp_names = [name for name in archive.namelist() if name.lower().endswith('.shp')]
+        dbf_names = [name for name in archive.namelist() if name.lower().endswith('.dbf')]
+        if not shp_names or not dbf_names:
+            raise ValueError('Missing shapefile members')
+        return archive.read(shp_names[0]), archive.read(dbf_names[0])
+
+
+def _iter_dbf_rows(dbf_bytes: bytes) -> list[dict[str, object]]:
+    header_length = struct.unpack('<H', dbf_bytes[8:10])[0]
+    record_length = struct.unpack('<H', dbf_bytes[10:12])[0]
+    field_specs = []
+    pos = 32
+    offset = 1
+    while pos < header_length - 1:
+        field = dbf_bytes[pos:pos + 32]
+        if field[0] == 0x0D:
+            break
+        field_specs.append(
+            (
+                field[:11].split(b'\x00', 1)[0].decode('ascii', 'ignore'),
+                chr(field[11]),
+                field[16],
+                field[17],
+                offset,
+            )
+        )
+        offset += field[16]
+        pos += 32
+
+    records = struct.unpack('<I', dbf_bytes[4:8])[0]
+    row_start = header_length
+    for _ in range(records):
+        record = dbf_bytes[row_start:row_start + record_length]
+        row_start += record_length
+        if not record or record[0:1] == b'*':
+            continue
+        row: dict[str, object] = {}
+        for name, field_type, field_len, decimals, value_offset in field_specs:
+            raw = record[value_offset:value_offset + field_len]
+            text = raw.decode('latin1', 'ignore').strip()
+            if not text:
+                continue
+            if field_type == 'N':
+                if decimals:
+                    try:
+                        row[name] = float(text)
+                    except ValueError:
+                        row[name] = text
+                else:
+                    try:
+                        row[name] = int(text)
+                    except ValueError:
+                        row[name] = text
+            else:
+                row[name] = text
+        yield row
+
+
+def _iter_polyline_geometries(shp_bytes: bytes) -> list[dict[str, object] | None]:
+    pos = 100
+    total_size = len(shp_bytes)
+    while pos + 8 <= total_size:
+        content_length_words = struct.unpack('>i', shp_bytes[pos + 4:pos + 8])[0]
+        record_end = pos + 8 + content_length_words * 2
+        record = shp_bytes[pos + 8:record_end]
+        pos = record_end
+        if len(record) < 44:
+            yield None
+            continue
+
+        shape_type = struct.unpack('<i', record[:4])[0]
+        if shape_type == 0:
+            yield None
+            continue
+        if shape_type not in {3, 13, 23}:
+            yield None
+            continue
+
+        num_parts = struct.unpack('<i', record[36:40])[0]
+        num_points = struct.unpack('<i', record[40:44])[0]
+        parts_offset = 44
+        points_offset = parts_offset + 4 * num_parts
+        parts = [
+            struct.unpack('<i', record[parts_offset + index * 4:parts_offset + (index + 1) * 4])[0]
+            for index in range(num_parts)
+        ]
+        points = [
+            struct.unpack('<2d', record[points_offset + index * 16:points_offset + (index + 1) * 16])
+            for index in range(num_points)
+        ]
+
+        coordinates = []
+        for index, start in enumerate(parts):
+            end = parts[index + 1] if index + 1 < len(parts) else len(points)
+            line = _downsample_line(points[start:end], max_points=PMGSY_MAX_POINTS_PER_SEGMENT)
+            if len(line) < 2:
+                continue
+            coordinates.append([[round(lon, 6), round(lat, 6)] for lon, lat in line])
+
+        if not coordinates:
+            yield None
+        elif len(coordinates) == 1:
+            yield {'type': 'LineString', 'coordinates': coordinates[0]}
+        else:
+            yield {'type': 'MultiLineString', 'coordinates': coordinates}
+
+
+def _downsample_line(points: list[tuple[float, float]], *, max_points: int) -> list[tuple[float, float]]:
+    if len(points) <= max_points:
+        return points
+    last_index = len(points) - 1
+    indexes = {
+        0,
+        last_index,
+        *(
+            min(last_index, round(step * last_index / (max_points - 1)))
+            for step in range(1, max_points - 1)
+        ),
+    }
+    return [points[index] for index in sorted(indexes)]
+
+
+def _build_pmgsy_properties(row: dict[str, object], state_name: str) -> dict[str, object]:
+    props: dict[str, object] = {'pmgsy_state': state_name}
+    field_map = {
+        'ER_ID': 'er_id',
+        'STATE_ID': 'state_id',
+        'BLOCK_ID': 'block_id',
+        'DISTRICT_I': 'district_id',
+        'DRRP_ROAD_': 'road_code',
+        'RoadCatego': 'road_category',
+        'RoadName': 'road_name',
+        'RoadOwner': 'road_owner',
+    }
+    for source_key, target_key in field_map.items():
+        value = row.get(source_key)
+        if value not in (None, ''):
+            props[target_key] = value
+    return props
+
+
+def _build_road_summary_rows() -> list[dict[str, str]]:
+    rows: list[dict[str, str]] = []
+    for path in sorted(ROADS_DIR.glob('*.csv')):
+        if path.name in {'national_highways.csv', 'tolls-with-metadata.csv'}:
+            continue
+        if path.name.endswith('-metadata-hotosm_ind_roads_lines_geojson-zip.csv'):
+            continue
+        rows.extend(_normalize_road_summary_table(path))
+    return rows
+
+
+def _normalize_road_summary_table(path: Path) -> list[dict[str, str]]:
+    with path.open('r', encoding='utf-8-sig', newline='') as handle:
+        reader = csv.DictReader(handle)
+        if reader.fieldnames is None:
+            return []
+
+        geography_column = _detect_geography_column(reader.fieldnames)
+        serial_columns = {'Sr. No.', 'Sl. No.', 'Sl.No.', 'S.No.', 'S. No.'}
+        notes = (
+            'Generated from local road programme CSVs because no direct NHAI/NH master CSV '
+            'was present in chatbot_service/data/roads.'
+        )
+        rows: list[dict[str, str]] = []
+        for raw in reader:
+            geography_name = (raw.get(geography_column) or '').strip() if geography_column else ''
+            if not geography_name:
+                continue
+            for column, value in raw.items():
+                if column in serial_columns or column == geography_column:
+                    continue
+                metric_value = _normalize_metric_value(value or '')
+                if metric_value is None:
+                    continue
+                metric_name, period = _split_metric_column(column)
+                rows.append(
+                    {
+                        'source_file': path.name,
+                        'geography_level': 'district' if geography_column == 'District Name' else 'state',
+                        'geography_name': geography_name,
+                        'period': period,
+                        'metric_name': metric_name,
+                        'value': metric_value,
+                        'unit': 'km_or_count',
+                        'notes': notes,
+                    }
+                )
+        return rows
+
+
+def _detect_geography_column(fieldnames: list[str]) -> str | None:
+    candidates = ['District Name', 'State/UT', 'State', 'District', 'State/UT ']
+    for candidate in candidates:
+        if candidate in fieldnames:
+            return candidate
+    return None
+
+
+def _normalize_metric_value(value: str) -> str | None:
+    cleaned = value.strip()
+    if not cleaned or cleaned.upper() in {'NA', 'N/A', '-'}:
+        return None
+    try:
+        return str(int(cleaned))
+    except ValueError:
+        try:
+            return str(float(cleaned))
+        except ValueError:
+            return None
+
+
+def _split_metric_column(column: str) -> tuple[str, str]:
+    cleaned = column.strip()
+    period_match = None
+    for token in ('2024-25', '2023-24', '2022-23', '2021-22', '2020-21', '2019-20'):
+        if token in cleaned:
+            period_match = token
+            break
+    if period_match is None:
+        return cleaned, ''
+
+    metric_name = cleaned.replace(period_match, '').replace(' - ', ' ').replace('(as on 14.07.2022)', '').strip()
+    metric_name = ' '.join(metric_name.split()) or cleaned
+    return metric_name, period_match
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description='Build app-facing assets from chatbot_service/data local datasets.')
+    parser.add_argument('--skip-pmgsy', action='store_true', help='Skip extracting PMGSY shapefiles into GeoJSON.')
+    args = parser.parse_args()
+
+    sync_challan_assets()
+    sync_first_aid_bundle()
+    build_emergency_geojson()
+    export_national_highways_csv()
+    if not args.skip_pmgsy:
+        export_pmgsy_geojson()
+
+
+if __name__ == '__main__':
+    main()

scripts/scripts/data/check_all_scripts.py

@@ -0,0 +1,74 @@
+import subprocess, sys
+from pathlib import Path
+
+ROOT = Path(".")
+
+scripts = [
+    # Root scripts/data/
+    "scripts/data/bootstrap_local_data.py",
+    "scripts/data/download_legal_pdfs.py",
+    "scripts/data/extract_morth2022_tables.py",
+    "scripts/data/verify_data.py",
+    "scripts/data/seed_blackspots.py",
+    "scripts/data/fetch_hospitals.py",
+    "scripts/data/fetch_police.py",
+    "scripts/data/fetch_fire.py",
+    "scripts/data/fetch_ambulance.py",
+    "scripts/data/fetch_blood_banks.py",
+    "scripts/data/_overpass_utils.py",
+    "scripts/data/inspect_zips.py",
+    # Root scripts/app/
+    "scripts/app/seed_nhp_hospitals.py",
+    "scripts/app/seed_emergency.py",
+    # Backend scripts/data/
+    "backend/scripts/data/seed_violations.py",
+    "backend/scripts/data/prepare_road_sources.py",
+    "backend/scripts/data/sample_pmgsy.py",
+    # Backend scripts/app/
+    "backend/scripts/app/build_vectorstore.py",
+    "backend/scripts/app/seed_emergency.py",
+    "backend/scripts/app/build_offline_bundle.py",
+    "backend/scripts/app/seed_roadwatch_sample.py",
+    "backend/scripts/app/import_road_infrastructure.py",
+    "backend/scripts/app/import_official_road_sources.py",
+    # Chatbot scripts/data/
+    "chatbot_service/scripts/data/fetch_hospitals.py",
+    "chatbot_service/scripts/data/fetch_police.py",
+    "chatbot_service/scripts/data/fetch_ambulance.py",
+    "chatbot_service/scripts/data/fetch_blood_banks.py",
+    "chatbot_service/scripts/data/fetch_fire.py",
+    "chatbot_service/scripts/data/_overpass_utils.py",
+    # Chatbot scripts/app/
+    "chatbot_service/scripts/app/seed_emergency.py",
+]
+
+passed = []
+failed = []
+
+for s in scripts:
+    p = ROOT / s
+    if not p.exists():
+        failed.append((s, "FILE NOT FOUND"))
+        continue
+    result = subprocess.run(
+        [sys.executable, "-m", "py_compile", str(p)],
+        capture_output=True, text=True
+    )
+    if result.returncode == 0:
+        passed.append(s)
+    else:
+        err = (result.stderr or result.stdout).strip().splitlines()[-1]
+        failed.append((s, err))
+
+print()
+print("=" * 70)
+print(f"  SCRIPT SYNTAX CHECK — {len(scripts)} scripts")
+print("=" * 70)
+for s in passed:
+    print(f"  [PASS]  {s}")
+for s, err in failed:
+    print(f"  [FAIL]  {s}")
+    print(f"          {err}")
+print("=" * 70)
+print(f"  {len(passed)} PASS | {len(failed)} FAIL")
+print("=" * 70)

scripts/scripts/data/download_legal_pdfs.py

@@ -0,0 +1,154 @@
+"""
+download_legal_pdfs.py
+======================
+Downloads the three critical RAG knowledge-base PDFs from official government
+and WHO sources. All URLs are verified working as of April 2026.
+
+Run:
+    python scripts/download_legal_pdfs.py
+
+The three placeholder files will be replaced with real PDFs.
+"""
+from __future__ import annotations
+
+import sys
+import urllib.request
+import urllib.error
+from pathlib import Path
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+CHATBOT_DATA = PROJECT_ROOT / "chatbot_service" / "data"
+
+TARGETS: list[dict] = [
+    {
+        "name": "Motor Vehicles Act 1988",
+        "destinations": [CHATBOT_DATA / "legal" / "motor_vehicles_act_1988.pdf"],
+        "sources": [
+            # indiacode.nic.in — official government portal
+            "https://indiacode.nic.in/bitstream/123456789/15577/1/the_motor_vehicles_act_1988.pdf",
+            # legislative.gov.in — Ministry of Law fallback
+            "https://legislative.gov.in/sites/default/files/A1988-59.pdf",
+        ],
+    },
+    {
+        "name": "Motor Vehicles Amendment Act 2019",
+        "destinations": [CHATBOT_DATA / "legal" / "mv_amendment_act_2019.pdf"],
+        "sources": [
+            # gazette of India official notification
+            "https://egazette.nic.in/WriteReadData/2019/210355.pdf",
+            # MoRTH official page
+            "https://morth.nic.in/sites/default/files/MV_Amendment_Act_2019.pdf",
+        ],
+    },
+    {
+        "name": "WHO Emergency Care Systems Guidelines (Trauma)",
+        "destinations": [CHATBOT_DATA / "medical" / "who_trauma_care_guidelines.pdf"],
+        "sources": [
+            # WHO publications — direct PDF download
+            "https://iris.who.int/bitstream/handle/10665/350523/9789240052215-eng.pdf",
+            # Alternative WHO trauma care document
+            "https://www.who.int/publications/i/item/9789241548526",
+        ],
+    },
+]
+
+PLACEHOLDER_MARKERS = {
+    b"# Placeholder",
+    b"Placeholder",
+}
+
+
+def is_placeholder(path: Path) -> bool:
+    """Return True if the file is one of the tiny text placeholder stubs."""
+    if not path.exists():
+        return True
+    if path.stat().st_size < 256:
+        try:
+            preview = path.read_bytes()[:64]
+            return any(marker in preview for marker in PLACEHOLDER_MARKERS)
+        except OSError:
+            return True
+    return False
+
+
+def download_first_working(sources: list[str], destination: Path) -> bool:
+    """Try each source URL in order; return True on the first successful download."""
+    for url in sources:
+        print(f"  Trying: {url}")
+        try:
+            req = urllib.request.Request(
+                url,
+                headers={
+                    "User-Agent": "Mozilla/5.0 (RoadSoS-DataPipeline/1.0; +https://github.com)"
+                },
+            )
+            with urllib.request.urlopen(req, timeout=60) as response:
+                data = response.read()
+            if len(data) < 1024:
+                print(f"    Response too small ({len(data)} bytes) — likely not a PDF, skipping")
+                continue
+            destination.parent.mkdir(parents=True, exist_ok=True)
+            destination.write_bytes(data)
+            print(f"    Downloaded: {len(data):,} bytes -> {destination.name}")
+            return True
+        except urllib.error.HTTPError as exc:
+            print(f"    HTTP {exc.code}: {exc.reason}")
+        except urllib.error.URLError as exc:
+            print(f"    Network error: {exc.reason}")
+        except Exception as exc:  # noqa: BLE001
+            print(f"    Unexpected error: {exc}")
+    return False
+
+
+def main() -> None:
+    failed: list[str] = []
+
+    for target in TARGETS:
+        name: str = target["name"]
+        destinations: list[Path] = target["destinations"]
+        sources: list[str] = target["sources"]
+
+        print(f"\n{'='*60}")
+        print(f"  {name}")
+
+        placeholder_paths = [p for p in destinations if is_placeholder(p)]
+        if not placeholder_paths:
+            real_paths = [p for p in destinations if p.exists()]
+            sizes = ", ".join(f"{p.name} ({p.stat().st_size:,}B)" for p in real_paths)
+            print(f"  Already present: {sizes} — skipping")
+            continue
+
+        print(f"  Placeholder detected — downloading real PDF...")
+        success = download_first_working(sources, destinations[0])
+
+        if success and len(destinations) > 1:
+            # Mirror to additional destination paths
+            base = destinations[0]
+            for extra_dest in destinations[1:]:
+                extra_dest.parent.mkdir(parents=True, exist_ok=True)
+                extra_dest.write_bytes(base.read_bytes())
+                print(f"  Mirrored to: {extra_dest}")
+
+        if not success:
+            failed.append(name)
+            print(
+                f"\n  !!! DOWNLOAD FAILED for: {name}\n"
+                f"  Manual steps:\n"
+                f"    1. Open a browser and go to one of these URLs:\n"
+                + "\n".join(f"       {url}" for url in sources)
+                + f"\n    2. Save the PDF to: {destinations[0]}"
+            )
+
+    print(f"\n{'='*60}")
+    if failed:
+        print(f"RESULT: {len(TARGETS) - len(failed)}/{len(TARGETS)} downloaded successfully")
+        print(f"Manual download required for: {', '.join(failed)}")
+        sys.exit(1)
+    else:
+        print(f"RESULT: All {len(TARGETS)} PDFs downloaded successfully")
+        print("RAG pipeline now has real legal and medical knowledge.")
+
+
+if __name__ == "__main__":
+    main()

scripts/scripts/data/extract_morth2022_tables.py

@@ -0,0 +1,147 @@
+"""
+extract_morth2022_tables.py
+===========================
+Extracts tabular accident data from the raw MoRTH 2022 PDF reports that were
+downloaded into chatbot_service/data/accidents/morth_2022/.
+
+The morth_2022 folder currently has two large PDFs but only one tabular CSV.
+This script uses pdfplumber to extract all tables from those PDFs and saves
+them as clean, labelled CSVs — matching the format of morth_2021/ and morth_2020/.
+
+Run:
+    pip install pdfplumber
+    python scripts/extract_morth2022_tables.py
+
+Output:
+    chatbot_service/data/accidents/morth_2022/extracted_table_*.csv
+"""
+from __future__ import annotations
+
+import csv
+import re
+import sys
+from pathlib import Path
+
+try:
+    import pdfplumber
+except ImportError:
+    print("ERROR: pdfplumber not installed. Run: pip install pdfplumber")
+    sys.exit(1)
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+MORTH_2022_DIR = PROJECT_ROOT / "chatbot_service" / "data" / "accidents" / "morth_2022"
+
+
+def _clean_cell(text: str | None) -> str:
+    """Normalise whitespace in a table cell value."""
+    if text is None:
+        return ""
+    return re.sub(r"\s+", " ", text.strip())
+
+
+def _is_empty_row(row: list[str]) -> bool:
+    return all(c == "" for c in row)
+
+
+def _is_header_row(row: list[str]) -> bool:
+    """Heuristic: a row is a header if most cells look like labels not numbers."""
+    non_empty = [c for c in row if c]
+    if not non_empty:
+        return False
+    numeric_count = sum(1 for c in non_empty if re.match(r"^[\d,.\s]+$", c))
+    return numeric_count < len(non_empty) / 2
+
+
+def extract_tables_from_pdf(pdf_path: Path, output_dir: Path) -> int:
+    """Extract all tables from a PDF and write them to numbered CSVs."""
+    output_dir.mkdir(parents=True, exist_ok=True)
+    stem = pdf_path.stem[:24]  # keep filename manageable
+    tables_written = 0
+
+    print(f"\nProcessing: {pdf_path.name} ({pdf_path.stat().st_size / 1_048_576:.1f} MB)")
+
+    with pdfplumber.open(pdf_path) as pdf:
+        global_table_idx = 0
+        buffer_rows: list[list[str]] = []
+        buffer_header: list[str] = []
+
+        for page_num, page in enumerate(pdf.pages, start=1):
+            tables = page.extract_tables()
+            if not tables:
+                continue
+
+            for table in tables:
+                if not table:
+                    continue
+
+                cleaned = [
+                    [_clean_cell(cell) for cell in row]
+                    for row in table
+                ]
+                cleaned = [r for r in cleaned if not _is_empty_row(r)]
+
+                if not cleaned:
+                    continue
+
+                # Detect if this page continues a previous table (no header in first row)
+                first_row_looks_like_header = _is_header_row(cleaned[0])
+
+                if first_row_looks_like_header and buffer_rows:
+                    # Flush previous buffer
+                    _write_table(output_dir, stem, global_table_idx, buffer_header, buffer_rows)
+                    tables_written += 1
+                    global_table_idx += 1
+                    buffer_rows = []
+                    buffer_header = []
+
+                if first_row_looks_like_header:
+                    buffer_header = cleaned[0]
+                    buffer_rows = cleaned[1:]
+                else:
+                    # Continuation of previous table
+                    buffer_rows.extend(cleaned)
+
+        # Flush any remaining buffer
+        if buffer_rows:
+            _write_table(output_dir, stem, global_table_idx, buffer_header, buffer_rows)
+            tables_written += 1
+
+    return tables_written
+
+
+def _write_table(
+    output_dir: Path,
+    stem: str,
+    index: int,
+    header: list[str],
+    rows: list[list[str]],
+) -> None:
+    filename = output_dir / f"extracted_{stem}_table_{index:03d}.csv"
+    with filename.open("w", newline="", encoding="utf-8") as fp:
+        writer = csv.writer(fp)
+        if header:
+            writer.writerow(header)
+        writer.writerows(rows)
+    print(f"  Wrote: {filename.name} ({len(rows)} data rows)")
+
+
+def main() -> None:
+    pdfs = sorted(MORTH_2022_DIR.glob("*.pdf"))
+    if not pdfs:
+        print(f"No PDFs found in {MORTH_2022_DIR}")
+        print("Download the MoRTH 2022 report from:")
+        print("  https://morth.nic.in/road-accident-in-india")
+        sys.exit(1)
+
+    total_tables = 0
+    for pdf_path in pdfs:
+        n = extract_tables_from_pdf(pdf_path, MORTH_2022_DIR)
+        total_tables += n
+        print(f"  => {n} tables extracted from {pdf_path.name}")
+
+    print(f"\nDone: {total_tables} total table CSVs written to {MORTH_2022_DIR}")
+    print("These CSVs can now be used by seed_blackspots.py for accident data seeding.")
+
+
+if __name__ == "__main__":
+    main()

scripts/scripts/data/fetch_ambulance.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+LOGGER = logging.getLogger(__name__)
+
+from _overpass_utils import ROOT_DIR, build_arg_parser, build_india_query, fetch_elements, normalize_row, write_rows
+
+
+DEFAULT_OUTPUT = ROOT_DIR / 'chatbot_service' / 'data' / 'emergency' / 'ambulance_stations.csv'
+SELECTORS = [
+    'node["emergency"="ambulance_station"](area.searchArea);',
+    'way["emergency"="ambulance_station"](area.searchArea);',
+    'relation["emergency"="ambulance_station"](area.searchArea);',
+    'node["amenity"="ambulance_station"](area.searchArea);',
+    'way["amenity"="ambulance_station"](area.searchArea);',
+    'relation["amenity"="ambulance_station"](area.searchArea);',
+    'node["healthcare"="ambulance_station"](area.searchArea);',
+    'way["healthcare"="ambulance_station"](area.searchArea);',
+    'relation["healthcare"="ambulance_station"](area.searchArea);',
+]
+
+
+def main() -> None:
+    parser = build_arg_parser('Fetch India ambulance station data from Overpass.', DEFAULT_OUTPUT)
+    args = parser.parse_args()
+
+    query = build_india_query(SELECTORS, timeout=args.timeout)
+    elements = fetch_elements(query, endpoint=args.endpoint, timeout=args.timeout)
+    rows = [
+        row
+        for element in elements
+        if (row := normalize_row(element, default_type='ambulance', fallback_name='Unnamed ambulance station')) is not None
+    ]
+    count = write_rows(args.output, rows)
+    LOGGER.info(f'Saved {count} ambulance station records to {args.output}')
+
+
+if __name__ == '__main__':
+    main()

scripts/scripts/data/fetch_blood_banks.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+LOGGER = logging.getLogger(__name__)
+
+from _overpass_utils import ROOT_DIR, build_arg_parser, build_india_query, fetch_elements, normalize_row, write_rows
+
+
+DEFAULT_OUTPUT = ROOT_DIR / 'chatbot_service' / 'data' / 'hospitals' / 'blood_bank_directory.csv'
+SELECTORS = [
+    'node["amenity"="blood_bank"](area.searchArea);',
+    'way["amenity"="blood_bank"](area.searchArea);',
+    'relation["amenity"="blood_bank"](area.searchArea);',
+    'node["healthcare"="blood_bank"](area.searchArea);',
+    'way["healthcare"="blood_bank"](area.searchArea);',
+    'relation["healthcare"="blood_bank"](area.searchArea);',
+]
+
+
+def main() -> None:
+    parser = build_arg_parser('Fetch India blood bank data from Overpass.', DEFAULT_OUTPUT)
+    args = parser.parse_args()
+
+    query = build_india_query(SELECTORS, timeout=args.timeout)
+    elements = fetch_elements(query, endpoint=args.endpoint, timeout=args.timeout)
+    rows = [
+        row
+        for element in elements
+        if (row := normalize_row(element, default_type='blood_bank', fallback_name='Unnamed blood bank')) is not None
+    ]
+    count = write_rows(args.output, rows)
+    LOGGER.info(f'Saved {count} blood bank records to {args.output}')
+
+
+if __name__ == '__main__':
+    main()

scripts/scripts/data/fetch_fire.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+LOGGER = logging.getLogger(__name__)
+
+from _overpass_utils import ROOT_DIR, build_arg_parser, build_india_query, fetch_elements, normalize_row, write_rows
+
+
+DEFAULT_OUTPUT = ROOT_DIR / 'chatbot_service' / 'data' / 'emergency' / 'fire_stations.csv'
+SELECTORS = [
+    'node["amenity"="fire_station"](area.searchArea);',
+    'way["amenity"="fire_station"](area.searchArea);',
+    'relation["amenity"="fire_station"](area.searchArea);',
+]
+
+
+def main() -> None:
+    parser = build_arg_parser('Fetch India fire station data from Overpass.', DEFAULT_OUTPUT)
+    args = parser.parse_args()
+
+    query = build_india_query(SELECTORS, timeout=args.timeout)
+    elements = fetch_elements(query, endpoint=args.endpoint, timeout=args.timeout)
+    rows = [
+        row
+        for element in elements
+        if (row := normalize_row(element, default_type='fire_station', fallback_name='Unnamed fire station')) is not None
+    ]
+    count = write_rows(args.output, rows)
+    LOGGER.info(f'Saved {count} fire station records to {args.output}')
+
+
+if __name__ == '__main__':
+    main()

scripts/scripts/data/fetch_hospitals.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+LOGGER = logging.getLogger(__name__)
+
+from _overpass_utils import ROOT_DIR, build_arg_parser, build_india_query, fetch_elements, normalize_row, write_rows
+
+
+DEFAULT_OUTPUT = ROOT_DIR / 'chatbot_service' / 'data' / 'hospitals' / 'hospital_directory.csv'
+SELECTORS = [
+    'node["amenity"~"hospital|clinic"](area.searchArea);',
+    'way["amenity"~"hospital|clinic"](area.searchArea);',
+    'relation["amenity"~"hospital|clinic"](area.searchArea);',
+]
+
+
+def main() -> None:
+    parser = build_arg_parser('Fetch India hospital and clinic data from Overpass.', DEFAULT_OUTPUT)
+    args = parser.parse_args()
+
+    query = build_india_query(SELECTORS, timeout=args.timeout)
+    elements = fetch_elements(query, endpoint=args.endpoint, timeout=args.timeout)
+    rows = [
+        row
+        for element in elements
+        if (row := normalize_row(element, default_type='hospital', fallback_name='Unnamed hospital')) is not None
+    ]
+    count = write_rows(args.output, rows)
+    LOGGER.info(f'Saved {count} hospital records to {args.output}')
+
+
+if __name__ == '__main__':
+    main()

scripts/scripts/data/fetch_police.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+LOGGER = logging.getLogger(__name__)
+
+from _overpass_utils import ROOT_DIR, build_arg_parser, build_india_query, fetch_elements, normalize_row, write_rows
+
+
+DEFAULT_OUTPUT = ROOT_DIR / 'chatbot_service' / 'data' / 'emergency' / 'police_stations.csv'
+SELECTORS = [
+    'node["amenity"="police"](area.searchArea);',
+    'way["amenity"="police"](area.searchArea);',
+    'relation["amenity"="police"](area.searchArea);',
+]
+
+
+def main() -> None:
+    parser = build_arg_parser('Fetch India police station data from Overpass.', DEFAULT_OUTPUT)
+    args = parser.parse_args()
+
+    query = build_india_query(SELECTORS, timeout=args.timeout)
+    elements = fetch_elements(query, endpoint=args.endpoint, timeout=args.timeout)
+    rows = [
+        row
+        for element in elements
+        if (row := normalize_row(element, default_type='police', fallback_name='Unnamed police station')) is not None
+    ]
+    count = write_rows(args.output, rows)
+    LOGGER.info(f'Saved {count} police station records to {args.output}')
+
+
+if __name__ == '__main__':
+    main()

scripts/scripts/data/inspect_zips.py

@@ -0,0 +1,33 @@
+import zipfile
+from pathlib import Path
+
+ROOT = Path(".")
+
+zips = [
+    "backend/datasets/accidents/kaggle/AccidentsBig.csv.zip",
+    "chatbot_service/data/legal/indian_kanoon/indian_kanoon_statistics_v1.zip",
+    "chatbot_service/data/pothole_training/road_damage_2025/archive.zip",
+    "chatbot_service/data/qa_pairs/file-1745432916167-910662924.zip",
+    "chatbot_service/data/roads/pmgsy-geosadak-master.zip",
+]
+
+for zpath in zips:
+    p = ROOT / zpath
+    if not p.exists():
+        print(f"MISSING: {zpath}")
+        continue
+    size_mb = p.stat().st_size / 1024 / 1024
+    print(f"\n[{size_mb:.1f}MB] {p.name}")
+    try:
+        with zipfile.ZipFile(p) as z:
+            members = z.namelist()
+            print(f"  Total entries: {len(members)}")
+            top = sorted(set(m.split("/")[0] for m in members))
+            for t in top[:6]:
+                print(f"  root-dir: {t}/")
+            sample = [m for m in members if not m.endswith("/")][:6]
+            for s in sample:
+                info = z.getinfo(s)
+                print(f"  file: {s}  ({info.file_size:,}B uncompressed)")
+    except Exception as e:
+        print(f"  Cannot open: {e}")

scripts/scripts/data/seed_blackspots.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+from pathlib import Path
+
+
+ROOT_DIR = Path(__file__).resolve().parents[1]
+DEFAULT_INPUT = ROOT_DIR / 'chatbot_service' / 'data' / 'accidents' / 'morth_2022'
+DEFAULT_OUTPUT_CSV = ROOT_DIR / 'chatbot_service' / 'data' / 'accidents' / 'accident_blackspots_preview.csv'
+DEFAULT_OUTPUT_GEOJSON = ROOT_DIR / 'frontend' / 'public' / 'offline-data' / 'accident-blackspots.geojson'
+STATE_CENTROIDS = {
+    'andhra pradesh': (15.9129, 79.74),
+    'arunachal pradesh': (28.2180, 94.7278),
+    'assam': (26.2006, 92.9376),
+    'bihar': (25.0961, 85.3131),
+    'chhattisgarh': (21.2787, 81.8661),
+    'delhi': (28.7041, 77.1025),
+    'goa': (15.2993, 74.1240),
+    'gujarat': (22.2587, 71.1924),
+    'haryana': (29.0588, 76.0856),
+    'himachal pradesh': (31.1048, 77.1734),
+    'jharkhand': (23.6102, 85.2799),
+    'karnataka': (15.3173, 75.7139),
+    'kerala': (10.8505, 76.2711),
+    'madhya pradesh': (22.9734, 78.6569),
+    'maharashtra': (19.7515, 75.7139),
+    'manipur': (24.6637, 93.9063),
+    'meghalaya': (25.4670, 91.3662),
+    'mizoram': (23.1645, 92.9376),
+    'nagaland': (26.1584, 94.5624),
+    'odisha': (20.9517, 85.0985),
+    'punjab': (31.1471, 75.3412),
+    'rajasthan': (27.0238, 74.2179),
+    'sikkim': (27.5330, 88.5122),
+    'tamil nadu': (11.1271, 78.6569),
+    'telangana': (18.1124, 79.0193),
+    'tripura': (23.9408, 91.9882),
+    'uttar pradesh': (26.8467, 80.9462),
+    'uttarakhand': (30.0668, 79.0193),
+    'west bengal': (22.9868, 87.8550),
+}
+STATE_FIELDS = ('state', 'state_name', 'state_ut', 'state/ut', 'state_ut_name')
+CITY_FIELDS = ('city', 'city_name', 'district', 'district_name', 'location')
+LAT_FIELDS = ('lat', 'latitude')
+LON_FIELDS = ('lon', 'lng', 'longitude')
+ACCIDENT_FIELDS = ('total_accidents', 'accidents', 'road_accidents', 'fatal_accidents')
+DEATH_FIELDS = ('persons_killed', 'killed', 'deaths')
+INJURY_FIELDS = ('persons_injured', 'injured')
+
+
+def _first_value(row: dict[str, str], names: tuple[str, ...]) -> str:
+    for name in names:
+        value = (row.get(name) or '').strip()
+        if value:
+            return value
+    return ''
+
+
+def _parse_float(value: str) -> float | None:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _parse_int(value: str) -> int:
+    try:
+        return int(float(value))
+    except (TypeError, ValueError):
+        return 0
+
+
+def _discover_csvs(path: Path) -> list[Path]:
+    if path.is_file():
+        return [path]
+    return sorted(candidate for candidate in path.rglob('*.csv') if candidate.is_file())
+
+
+def _normalize_row(row: dict[str, str], *, source_file: str, index: int) -> dict | None:
+    state = _first_value(row, STATE_FIELDS)
+    city = _first_value(row, CITY_FIELDS)
+    lat = _parse_float(_first_value(row, LAT_FIELDS))
+    lon = _parse_float(_first_value(row, LON_FIELDS))
+
+    if (lat is None or lon is None) and state.lower() in STATE_CENTROIDS:
+        lat, lon = STATE_CENTROIDS[state.lower()]
+
+    if lat is None or lon is None:
+        return None
+
+    accidents = _parse_int(_first_value(row, ACCIDENT_FIELDS))
+    killed = _parse_int(_first_value(row, DEATH_FIELDS))
+    injured = _parse_int(_first_value(row, INJURY_FIELDS))
+    severity_score = accidents + (2 * killed) + injured
+
+    return {
+        'blackspot_id': f'{source_file}:{index}',
+        'state': state,
+        'city': city,
+        'lat': f'{lat:.6f}',
+        'lon': f'{lon:.6f}',
+        'accidents': accidents,
+        'killed': killed,
+        'injured': injured,
+        'severity_score': severity_score,
+        'source_file': source_file,
+    }
+
+
+def _load_records(input_path: Path) -> list[dict]:
+    records: list[dict] = []
+    for csv_path in _discover_csvs(input_path):
+        with csv_path.open('r', encoding='utf-8', newline='') as handle:
+            reader = csv.DictReader(handle)
+            for index, row in enumerate(reader, start=1):
+                normalized = _normalize_row(row, source_file=csv_path.name, index=index)
+                if normalized is not None:
+                    records.append(normalized)
+    return records
+
+
+def _write_csv(path: Path, rows: list[dict]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open('w', encoding='utf-8', newline='') as handle:
+        writer = csv.DictWriter(
+            handle,
+            fieldnames=['blackspot_id', 'state', 'city', 'lat', 'lon', 'accidents', 'killed', 'injured', 'severity_score', 'source_file'],
+        )
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def _write_geojson(path: Path, rows: list[dict]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    geojson = {
+        'type': 'FeatureCollection',
+        'features': [
+            {
+                'type': 'Feature',
+                'geometry': {'type': 'Point', 'coordinates': [float(row['lon']), float(row['lat'])]},
+                'properties': {
+                    'blackspot_id': row['blackspot_id'],
+                    'state': row['state'],
+                    'city': row['city'],
+                    'accidents': row['accidents'],
+                    'killed': row['killed'],
+                    'injured': row['injured'],
+                    'severity_score': row['severity_score'],
+                    'source_file': row['source_file'],
+                },
+            }
+            for row in rows
+        ],
+    }
+    path.write_text(json.dumps(geojson, indent=2), encoding='utf-8')
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description='Normalize accident CSVs into a blackspot preview CSV and GeoJSON bundle.',
+    )
+    parser.add_argument('--input', type=Path, default=DEFAULT_INPUT, help=f'CSV file or directory. Defaults to {DEFAULT_INPUT}')
+    parser.add_argument('--output-csv', type=Path, default=DEFAULT_OUTPUT_CSV, help=f'Normalized CSV output. Defaults to {DEFAULT_OUTPUT_CSV}')
+    parser.add_argument(
+        '--output-geojson',
+        type=Path,
+        default=DEFAULT_OUTPUT_GEOJSON,
+        help=f'GeoJSON output for offline mapping. Defaults to {DEFAULT_OUTPUT_GEOJSON}',
+    )
+    args = parser.parse_args()
+
+    if not args.input.exists():
+        raise SystemExit(f'Input path not found: {args.input}')
+
+    rows = _load_records(args.input)
+    if not rows:
+        raise SystemExit('No accident CSV rows could be normalized from the provided input.')
+
+    rows.sort(key=lambda item: item['severity_score'], reverse=True)
+    _write_csv(args.output_csv, rows)
+    _write_geojson(args.output_geojson, rows)
+    print(f'Wrote {len(rows)} normalized blackspot rows to {args.output_csv}')
+    print(f'Wrote GeoJSON preview to {args.output_geojson}')
+
+
+if __name__ == '__main__':
+    main()

scripts/scripts/data/setup_kaggle.ps1

@@ -0,0 +1,50 @@
+param(
+    [string]$RepoRoot = (Split-Path -Parent $PSScriptRoot)
+)
+
+function Get-KaggleToken {
+    param(
+        [string[]]$EnvFiles
+    )
+
+    foreach ($envFile in $EnvFiles) {
+        if (-not (Test-Path -LiteralPath $envFile)) {
+            continue
+        }
+
+        foreach ($line in Get-Content -LiteralPath $envFile) {
+            if ($line -match '^\s*(?:export\s+)?KAGGLE_API_TOKEN\s*=\s*(.+?)\s*$') {
+                $token = $matches[1].Trim()
+                if (
+                    ($token.StartsWith('"') -and $token.EndsWith('"')) -or
+                    ($token.StartsWith("'") -and $token.EndsWith("'"))
+                ) {
+                    $token = $token.Substring(1, $token.Length - 2)
+                }
+                if ($token) {
+                    return $token
+                }
+            }
+        }
+    }
+
+    throw "KAGGLE_API_TOKEN was not found in backend/.env or chatbot_service/.env."
+}
+
+$envFiles = @(
+    (Join-Path $RepoRoot 'backend\.env'),
+    (Join-Path $RepoRoot 'chatbot_service\.env')
+)
+
+$token = Get-KaggleToken -EnvFiles $envFiles
+$kaggleDir = Join-Path $HOME '.kaggle'
+$accessTokenPath = Join-Path $kaggleDir 'access_token'
+$repoDatasetDir = Join-Path $RepoRoot 'backend\datasets\accidents\kaggle'
+
+New-Item -ItemType Directory -Force -Path $kaggleDir | Out-Null
+Set-Content -LiteralPath $accessTokenPath -Value $token -NoNewline
+New-Item -ItemType Directory -Force -Path $repoDatasetDir | Out-Null
+
+Write-Output "Configured Kaggle token file: $accessTokenPath"
+Write-Output "Confirmed dataset folder: $repoDatasetDir"
+Write-Output "Authentication is configured, but datasets still need an explicit download command."

scripts/scripts/data/verify_data.py

@@ -0,0 +1,98 @@
+from pathlib import Path
+import json, csv
+
+ROOT = Path(".")
+DATA = ROOT / "chatbot_service/data"
+FRONTEND = ROOT / "frontend/public/offline-data"
+
+checks = []
+
+def check(label, path, min_bytes=100, check_fn=None):
+    p = Path(path)
+    if not p.exists():
+        checks.append(("FAIL", label, "FILE MISSING"))
+        return
+    size = p.stat().st_size
+    if size < min_bytes:
+        checks.append(("FAIL", label, f"Too small: {size} bytes"))
+        return
+    if check_fn:
+        try:
+            result = check_fn(p)
+            checks.append(("PASS", label, result))
+        except Exception as e:
+            checks.append(("WARN", label, str(e)))
+    else:
+        checks.append(("PASS", label, f"{size:,} bytes"))
+
+def count_csv(p):
+    with p.open(encoding="utf-8-sig") as f:
+        return f"{sum(1 for _ in csv.DictReader(f))} rows"
+
+def check_pdf(p):
+    data = p.read_bytes()
+    if data[:4] != b"%PDF":
+        preview = data[:30].decode("latin-1", errors="replace")
+        return f"NOT REAL PDF -- {preview}"
+    return f"{p.stat().st_size:,} bytes (valid PDF)"
+
+def count_json(p):
+    data = json.loads(p.read_text(encoding="utf-8"))
+    if isinstance(data, list):
+        return f"{len(data)} items"
+    if isinstance(data, dict):
+        return f"{len(data)} keys"
+    return "JSON ok"
+
+def geojson_features(p):
+    data = json.loads(p.read_text(encoding="utf-8"))
+    return f"{len(data['features']):,} features"
+
+# PDFs
+check("MVA 1988 PDF", DATA/"legal/motor_vehicles_act_1988.pdf", 100000, check_pdf)
+check("MVA Amendment 2019 PDF", DATA/"legal/mv_amendment_act_2019.pdf", 500, check_pdf)
+check("WHO Trauma Guidelines", DATA/"medical/who_trauma_care_guidelines.pdf", 500, check_pdf)
+check("MVA 1988 TXT summary", DATA/"legal/motor_vehicles_act_1988_summary.txt", 10000)
+
+# CSVs
+check("violations_seed.csv", DATA/"violations_seed.csv", 500, count_csv)
+check("state_overrides.csv", DATA/"state_overrides.csv", 200, count_csv)
+check("toll_plazas.csv", DATA/"roads/toll_plazas.csv", 50000, count_csv)
+check("hospital_directory.csv", DATA/"hospitals/hospital_directory.csv", 1000000)
+check("nin_facilities.csv", DATA/"hospitals/nin_facilities.csv", 5000000)
+check("police_stations.csv", DATA/"emergency/police_stations.csv", 50000, count_csv)
+check("fire_stations.csv", DATA/"emergency/fire_stations.csv", 10000, count_csv)
+
+# Backend challan CSVs
+check("backend violations.csv", "backend/datasets/challan/violations.csv", 500, count_csv)
+check("backend state_overrides.csv", "backend/datasets/challan/state_overrides.csv", 200, count_csv)
+
+# Frontend JSONs
+check("first-aid.json (frontend)", FRONTEND/"first-aid.json", 5000, count_json)
+check("first_aid.json (chatbot)", DATA/"first_aid.json", 5000, count_json)
+check("india-emergency.geojson", FRONTEND/"india-emergency.geojson", 1000000, geojson_features)
+check("violations.csv (frontend)", FRONTEND/"violations.csv", 200, count_csv)
+
+# Large files
+check("pmgsy_roads.geojson", DATA/"roads/pmgsy_roads.geojson", 50_000_000)
+check("kaggle_india_accidents.csv", DATA/"accidents/kaggle_india_accidents.csv", 10000000)
+
+# morth_2022 extracted
+morth_dir = DATA / "accidents/morth_2022"
+extracted = list(morth_dir.glob("extracted_*.csv"))
+check("morth_2022 extracted tables", morth_dir, 10000,
+      lambda p: f"{len(extracted)} extracted CSVs")
+
+print()
+print("=" * 70)
+print(f"  DATA PIPELINE FINAL VERIFICATION -- {len(checks)} checks")
+print("=" * 70)
+fail = warn = 0
+for status, label, detail in checks:
+    icon = "[PASS]" if status == "PASS" else ("[FAIL]" if status == "FAIL" else "[WARN]")
+    print(f"  {icon} {label:<45} {detail}")
+    if status == "FAIL": fail += 1
+    if status == "WARN": warn += 1
+print("=" * 70)
+print(f"  Result: {len(checks)-fail-warn} PASS | {warn} WARN | {fail} FAIL")
+print("=" * 70)