@@ -264,6 +292,29 @@ export function SourceCatalogPanel({ datasets }: SourceCatalogPanelProps): JSX.E
) : null}
+
Officiële bronnen die hierna kunnen worden ingeladen
diff --git a/frontend/src/services/api/datasets.ts b/frontend/src/services/api/datasets.ts
index a7b8cb66..9285b02b 100644
--- a/frontend/src/services/api/datasets.ts
+++ b/frontend/src/services/api/datasets.ts
@@ -23,6 +23,7 @@ import type {
FloodHazardProductRead,
FloodHazardSelectionResponse,
BathymetryProfileAcquireRequest,
+ BathymetrySourceProbeRead,
BathymetrySourceRead,
DhmvProductRead,
TerrainSelectionResponse,
@@ -173,6 +174,10 @@ export const datasetsApi = {
apiGet<{ items: BathymetrySourceRead[]; total: number }>(
`/api/v1/projects/${projectId}/datasets/bathymetry/sources`,
),
+ probeMdkBathymetry: (projectId: string): Promise =>
+ apiGet(
+ `/api/v1/projects/${projectId}/datasets/bathymetry/sources/mdk_bcp_bathymetry/readiness`,
+ ),
acquireBathymetryProfiles: (projectId: string, payload: BathymetryProfileAcquireRequest): Promise =>
apiPost(`/api/v1/projects/${projectId}/datasets/bathymetry/profiles/acquire`, payload),
acquireThematicRaster: (projectId: string, payload: ThematicRasterAcquireRequest): Promise =>
diff --git a/frontend/src/types.ts b/frontend/src/types.ts
index 40ced7c3..c8fcc40e 100644
--- a/frontend/src/types.ts
+++ b/frontend/src/types.ts
@@ -459,7 +459,7 @@ export interface BathymetrySourceRead {
vertical_reference: string
horizontal_crs: string
native_resolution?: string | null
- integration_status: 'operational' | 'available_not_integrated' | 'catalog_only'
+ integration_status: 'operational' | 'probe_only' | 'available_not_integrated' | 'catalog_only'
acquisition_supported: boolean
configured: boolean
service_url?: string | null
@@ -469,6 +469,30 @@ export interface BathymetrySourceRead {
limitation_message: string
}
+export interface BathymetrySourceProbeRead {
+ source_key: 'mdk_bcp_bathymetry'
+ status:
+ | 'disabled'
+ | 'invalid_configuration'
+ | 'tls_error'
+ | 'endpoint_unavailable'
+ | 'invalid_capabilities'
+ | 'reachable'
+ configured_url: string
+ capabilities_url?: string | null
+ tls_verified: boolean
+ capabilities_reachable: boolean
+ acquisition_supported: false
+ wcs_version?: string | null
+ coverage_identifiers: string[]
+ advertised_formats: string[]
+ advertised_crs: string[]
+ response_sha256?: string | null
+ checked_at: string
+ message: string
+ limitation_message: string
+}
+
export interface ThematicRasterAcquireRequest {
bbox: VectorSelectionBBox
area_id?: string | null
diff --git a/scripts/README.md b/scripts/README.md
index bf45bd78..b61d75d6 100644
--- a/scripts/README.md
+++ b/scripts/README.md
@@ -1909,3 +1909,32 @@ python scripts/provision_mol_bathymetry_profiles.py \
The output is a point dataset with historical evidence. It is not a continuous
water-bottom raster and cannot calculate current water volume.
+
+## Flanders VHA bathymetry partitions
+
+Create the complete official Flemish land scope from the current VRBG
+municipality collection:
+
+```bash
+docker exec geointel python /app/scripts/provision_flanders_geographic_scope.py
+```
+
+Acquire VHA profile partitions with atomic resume evidence:
+
+```bash
+docker exec geointel python /app/scripts/provision_flanders_bathymetry_profiles.py
+```
+
+Use `--members Mol Geel` or `--max-partitions 5` only for a partial operational
+check. Partial runs do not activate regional coverage. The complete run
+finalizes only when every official municipality has either one ready Dataset
+or an explicit zero-profile source result.
+
+Probe the official-metadata MDK WCS safely:
+
+```bash
+docker exec geointel python /app/scripts/probe_mdk_bathymetry.py
+```
+
+This performs only `GetCapabilities`, keeps strict TLS verification enabled
+and returns exit code `2` for an honest non-ready source.
diff --git a/scripts/probe_mdk_bathymetry.py b/scripts/probe_mdk_bathymetry.py
new file mode 100644
index 00000000..315a8474
--- /dev/null
+++ b/scripts/probe_mdk_bathymetry.py
@@ -0,0 +1,57 @@
+"""Run the safe MDK WCS readiness probe through the canonical GeoIntel API."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+
+import requests
+
+
+DEFAULT_API_URL = "http://127.0.0.1:8000"
+DEFAULT_PROJECT_NAME = "Kempen Regional Workbench"
+
+
+def parse_args() -> argparse.Namespace:
+ parser = argparse.ArgumentParser(description="Probe MDK bathymetry WCS readiness without downloading coverage.")
+ parser.add_argument("--base-url", default=os.environ.get("GEOINTEL_INTERNAL_API_URL", DEFAULT_API_URL))
+ parser.add_argument("--project-name", default=DEFAULT_PROJECT_NAME)
+ parser.add_argument("--timeout", type=int, default=60)
+ return parser.parse_args()
+
+
+def unwrap(response: requests.Response):
+ response.raise_for_status()
+ payload = response.json()
+ if not isinstance(payload, dict) or "data" not in payload:
+ raise RuntimeError(f"Non-canonical API response from {response.url}")
+ return payload["data"]
+
+
+def main() -> int:
+ args = parse_args()
+ base_url = args.base_url.rstrip("/")
+ session = requests.Session()
+ projects = unwrap(
+ session.get(
+ f"{base_url}/api/v1/projects",
+ params={"name": args.project_name, "limit": 1},
+ timeout=args.timeout,
+ )
+ )["items"]
+ if not projects:
+ raise RuntimeError(f"Project {args.project_name!r} was not found")
+ result = unwrap(
+ session.get(
+ f"{base_url}/api/v1/projects/{projects[0]['id']}/datasets/"
+ "bathymetry/sources/mdk_bcp_bathymetry/readiness",
+ timeout=args.timeout,
+ )
+ )
+ print(json.dumps(result, ensure_ascii=False, indent=2))
+ return 0 if result["status"] == "reachable" else 2
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/scripts/provision_flanders_bathymetry_profiles.py b/scripts/provision_flanders_bathymetry_profiles.py
new file mode 100644
index 00000000..92e4a20e
--- /dev/null
+++ b/scripts/provision_flanders_bathymetry_profiles.py
@@ -0,0 +1,400 @@
+"""Provision VHA cross-section profiles for every persisted Flemish municipality.
+
+The operator is resumable and calls only canonical GeoIntel API endpoints.
+Regional completeness is finalized server-side only when every municipality
+has either one ready profile Dataset or an explicit no-profile source result.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable
+
+import requests
+
+
+DEFAULT_API_URL = "http://127.0.0.1:8000"
+DEFAULT_PROJECT_NAME = "Flanders Regional Workbench"
+DEFAULT_MANIFEST_PATH = Path("/app/storage/operator-data/bathymetry/vha-flanders/manifest.json")
+
+
+def parse_args() -> argparse.Namespace:
+ parser = argparse.ArgumentParser(description="Provision partitioned VHA profiles for Flanders.")
+ parser.add_argument("--base-url", default=os.environ.get("GEOINTEL_INTERNAL_API_URL", DEFAULT_API_URL))
+ parser.add_argument("--project-name", default=DEFAULT_PROJECT_NAME)
+ parser.add_argument(
+ "--manifest-path",
+ type=Path,
+ default=Path(os.environ.get("GEOINTEL_VHA_FLANDERS_MANIFEST", DEFAULT_MANIFEST_PATH)),
+ )
+ parser.add_argument("--timeout", type=int, default=900)
+ parser.add_argument("--force", action="store_true")
+ parser.add_argument("--continue-on-error", action="store_true")
+ parser.add_argument("--members", nargs="*", default=[])
+ parser.add_argument("--max-partitions", type=int, default=0)
+ return parser.parse_args()
+
+
+def unwrap(response: requests.Response) -> Any:
+ try:
+ payload = response.json()
+ except ValueError as exc:
+ raise RuntimeError(f"GeoIntel returned non-JSON ({response.status_code}): {response.text[:300]}") from exc
+ if not response.ok:
+ error_code = payload.get("error") if isinstance(payload, dict) else None
+ message = payload.get("message") if isinstance(payload, dict) else None
+ raise RuntimeError(f"{error_code or response.status_code}: {message or response.text[:300]}")
+ if not isinstance(payload, dict) or "data" not in payload:
+ raise RuntimeError(f"Non-canonical API response from {response.url}")
+ return payload["data"]
+
+
+def list_paginated(session: requests.Session, url: str, *, timeout: int) -> list[dict[str, Any]]:
+ items: list[dict[str, Any]] = []
+ offset = 0
+ total: int | None = None
+ while True:
+ page = unwrap(session.get(url, params={"limit": 200, "offset": offset}, timeout=timeout))
+ page_items = list(page.get("items") or [])
+ items.extend(page_items)
+ total = int(page.get("total") or 0) if total is None else total
+ if not page_items or len(items) >= total:
+ break
+ offset += len(page_items)
+ if total is not None and len(items) != total:
+ raise RuntimeError(f"Paginated API returned {len(items)} of {total} records for {url}")
+ return items
+
+
+def coordinates(geometry: dict[str, Any]) -> Iterable[tuple[float, float]]:
+ def walk(value: Any):
+ if isinstance(value, list) and len(value) >= 2 and all(isinstance(item, (int, float)) for item in value[:2]):
+ yield float(value[0]), float(value[1])
+ return
+ if isinstance(value, list):
+ for child in value:
+ yield from walk(child)
+
+ yield from walk(geometry.get("coordinates", []))
+
+
+def geometry_bbox(geometry: dict[str, Any]) -> dict[str, float | str]:
+ points = list(coordinates(geometry))
+ if not points:
+ raise RuntimeError("Persisted municipality Area contains no coordinates")
+ xs = [point[0] for point in points]
+ ys = [point[1] for point in points]
+ return {
+ "min_x": min(xs),
+ "min_y": min(ys),
+ "max_x": max(xs),
+ "max_y": max(ys),
+ "crs": "EPSG:4326",
+ }
+
+
+def area_identity(area: dict[str, Any]) -> str:
+ canonical = {
+ "id": area.get("id"),
+ "name": area.get("name"),
+ "geometry": area.get("geometry"),
+ }
+ return hashlib.sha256(
+ json.dumps(canonical, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+ ).hexdigest()
+
+
+def write_manifest(path: Path, payload: dict[str, Any]) -> None:
+ path.parent.mkdir(parents=True, exist_ok=True)
+ temporary = path.with_suffix(path.suffix + ".partial")
+ temporary.write_text(
+ json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True),
+ encoding="utf-8",
+ )
+ temporary.replace(path)
+
+
+def load_manifest(path: Path) -> dict[str, Any]:
+ if not path.is_file():
+ return {}
+ try:
+ payload = json.loads(path.read_text(encoding="utf-8"))
+ except (OSError, json.JSONDecodeError):
+ return {}
+ return payload if isinstance(payload, dict) else {}
+
+
+def source_error(response: requests.Response) -> tuple[str | None, str]:
+ try:
+ payload = response.json()
+ except ValueError:
+ return None, response.text[:300]
+ if not isinstance(payload, dict):
+ return None, response.text[:300]
+ return (
+ str(payload.get("error")) if payload.get("error") else None,
+ str(payload.get("message") or response.text[:300]),
+ )
+
+
+def acquire_partition(
+ session: requests.Session,
+ *,
+ base_url: str,
+ project_id: str,
+ area: dict[str, Any],
+ timeout: int,
+ force: bool,
+) -> dict[str, Any]:
+ bbox = geometry_bbox(area["geometry"])
+ response = session.post(
+ f"{base_url}/api/v1/projects/{project_id}/datasets/bathymetry/profiles/acquire",
+ json={"bbox": bbox, "area_id": area["id"], "force_refresh": force},
+ timeout=timeout,
+ )
+ if response.status_code == 404:
+ code, message = source_error(response)
+ if code == "BATHYMETRY_NO_PROFILES":
+ return {
+ "status": "no_profiles",
+ "area_id": area["id"],
+ "area_name": area["name"],
+ "area_identity_sha256": area_identity(area),
+ "bbox": bbox,
+ "message": message,
+ "completed_at": datetime.now(timezone.utc).isoformat(),
+ }
+ data = unwrap(response)
+ if data.get("status") != "success" or not data.get("output_dataset_id"):
+ raise RuntimeError(f"VHA acquisition failed for {area['name']}: {data.get('error_message') or data}")
+ result = data.get("result_json") or {}
+ return {
+ "status": "complete",
+ "area_id": area["id"],
+ "area_name": area["name"],
+ "area_identity_sha256": area_identity(area),
+ "bbox": bbox,
+ "dataset_id": data["output_dataset_id"],
+ "reused": bool(result.get("reused")),
+ "profile_count": int(result.get("profile_count") or 0),
+ "document_count": int(result.get("document_count") or 0),
+ "structured_depth_count": int(result.get("structured_depth_count") or 0),
+ "measurement_date_min": result.get("measurement_date_min"),
+ "measurement_date_max": result.get("measurement_date_max"),
+ "completed_at": datetime.now(timezone.utc).isoformat(),
+ }
+
+
+def manifest_identity(
+ *,
+ project_id: str,
+ partitions: list[dict[str, Any]],
+) -> tuple[dict[str, Any], str]:
+ identity = {
+ "schema_version": 1,
+ "source": "vmm_vha_bathymetry_profiles",
+ "partition_scope_key": "flanders",
+ "project_id": project_id,
+ "partitions": [
+ {
+ key: partition.get(key)
+ for key in (
+ "area_id",
+ "area_name",
+ "area_identity_sha256",
+ "status",
+ "dataset_id",
+ "profile_count",
+ "document_count",
+ "structured_depth_count",
+ "measurement_date_min",
+ "measurement_date_max",
+ )
+ }
+ for partition in sorted(partitions, key=lambda item: str(item["area_id"]))
+ ],
+ }
+ digest = hashlib.sha256(
+ json.dumps(identity, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+ ).hexdigest()
+ return identity, digest
+
+
+def main() -> int:
+ args = parse_args()
+ if args.max_partitions < 0:
+ print(json.dumps({"status": "error", "message": "--max-partitions cannot be negative"}), file=sys.stderr)
+ return 2
+ base_url = args.base_url.rstrip("/")
+ session = requests.Session()
+ session.headers.update({"User-Agent": "GeoIntel-VHA-Flanders-Operator/1.0"})
+ manifest = load_manifest(args.manifest_path)
+
+ try:
+ projects = list_paginated(session, f"{base_url}/api/v1/projects", timeout=60)
+ project = next((item for item in projects if item.get("name") == args.project_name), None)
+ if project is None:
+ raise RuntimeError(
+ f"Project {args.project_name!r} was not found; run provision_flanders_geographic_scope.py first"
+ )
+ all_areas = list_paginated(
+ session,
+ f"{base_url}/api/v1/projects/{project['id']}/areas",
+ timeout=120,
+ )
+ municipalities = sorted(
+ (area for area in all_areas if str(area.get("name") or "").casefold().startswith("gemeente ")),
+ key=lambda item: str(item["name"]).casefold(),
+ )
+ if not 270 <= len(municipalities) <= 300:
+ raise RuntimeError(
+ f"Flanders workspace exposes {len(municipalities)} municipality Areas; expected 270..300"
+ )
+ requested_names = {name.casefold() for name in args.members}
+ selected = [
+ area
+ for area in municipalities
+ if not requested_names
+ or str(area["name"]).removeprefix("Gemeente ").split(" - ", 1)[0].casefold() in requested_names
+ ]
+ if requested_names:
+ found = {
+ str(area["name"]).removeprefix("Gemeente ").split(" - ", 1)[0].casefold()
+ for area in selected
+ }
+ missing = sorted(requested_names - found)
+ if missing:
+ raise RuntimeError(f"Unknown Flanders municipality selections: {', '.join(missing)}")
+ if args.max_partitions:
+ selected = selected[: args.max_partitions]
+
+ prior_by_area = {
+ str(item.get("area_id")): item
+ for item in (manifest.get("partitions") or [])
+ if isinstance(item, dict) and item.get("area_id")
+ }
+ current: list[dict[str, Any]] = []
+ failures: list[dict[str, Any]] = []
+ observed_at = datetime.now(timezone.utc).isoformat()
+ working_manifest = {
+ "schema_version": 1,
+ "status": "running",
+ "source": "vmm_vha_bathymetry_profiles",
+ "partition_scope_key": "flanders",
+ "project_id": project["id"],
+ "project_name": project["name"],
+ "municipality_inventory_count": len(municipalities),
+ "selected_partition_count": len(selected),
+ "observed_at": observed_at,
+ "partitions": current,
+ }
+ for index, area in enumerate(selected, start=1):
+ identity = area_identity(area)
+ prior = prior_by_area.get(str(area["id"]))
+ if (
+ not args.force
+ and prior
+ and prior.get("area_identity_sha256") == identity
+ and prior.get("status") in {"complete", "no_profiles"}
+ ):
+ result = prior
+ else:
+ try:
+ result = acquire_partition(
+ session,
+ base_url=base_url,
+ project_id=str(project["id"]),
+ area=area,
+ timeout=args.timeout,
+ force=args.force,
+ )
+ except (RuntimeError, requests.RequestException) as exc:
+ result = {
+ "status": "failed",
+ "area_id": area["id"],
+ "area_name": area["name"],
+ "area_identity_sha256": identity,
+ "message": str(exc),
+ "failed_at": datetime.now(timezone.utc).isoformat(),
+ }
+ failures.append(result)
+ current.append(result)
+ working_manifest["completed_partition_count"] = index
+ working_manifest["partitions"] = current
+ write_manifest(args.manifest_path, working_manifest)
+ if result["status"] == "failed" and not args.continue_on_error:
+ raise RuntimeError(f"Partition failed for {area['name']}: {result['message']}")
+
+ full_inventory_selected = len(selected) == len(municipalities) and not requested_names and not args.max_partitions
+ complete = not failures and all(item["status"] in {"complete", "no_profiles"} for item in current)
+ identity_payload, identity_sha = manifest_identity(
+ project_id=str(project["id"]),
+ partitions=current,
+ )
+ finalization = None
+ if complete and full_inventory_selected:
+ dataset_ids = [item["dataset_id"] for item in current if item["status"] == "complete"]
+ no_profile_area_ids = [item["area_id"] for item in current if item["status"] == "no_profiles"]
+ finalization = unwrap(
+ session.post(
+ f"{base_url}/api/v1/projects/{project['id']}/datasets/bathymetry/profiles/partitions/finalize",
+ json={
+ "partition_scope_key": "flanders",
+ "expected_area_ids": [area["id"] for area in municipalities],
+ "dataset_ids": dataset_ids,
+ "no_profile_area_ids": no_profile_area_ids,
+ "manifest_sha256": identity_sha,
+ "observed_at": observed_at,
+ },
+ timeout=args.timeout,
+ )
+ )
+
+ working_manifest.update(
+ {
+ "status": "complete" if complete else "failed",
+ "completed_at": datetime.now(timezone.utc).isoformat(),
+ "coverage_manifest": identity_payload,
+ "coverage_manifest_sha256": identity_sha,
+ "regional_finalized": finalization is not None,
+ "finalization": finalization,
+ "failed_partition_count": len(failures),
+ }
+ )
+ write_manifest(args.manifest_path, working_manifest)
+ except (OSError, RuntimeError, ValueError, KeyError, requests.RequestException) as exc:
+ print(json.dumps({"status": "error", "message": str(exc)}, ensure_ascii=False), file=sys.stderr)
+ return 1
+
+ print(
+ json.dumps(
+ {
+ "status": working_manifest["status"],
+ "project_id": project["id"],
+ "municipality_inventory_count": len(municipalities),
+ "processed_partition_count": len(current),
+ "data_partition_count": sum(item["status"] == "complete" for item in current),
+ "no_profile_partition_count": sum(item["status"] == "no_profiles" for item in current),
+ "failed_partition_count": len(failures),
+ "profile_count": sum(int(item.get("profile_count") or 0) for item in current),
+ "document_count": sum(int(item.get("document_count") or 0) for item in current),
+ "regional_finalized": finalization is not None,
+ "manifest_path": str(args.manifest_path),
+ "manifest_sha256": identity_sha,
+ "finalization": finalization,
+ },
+ ensure_ascii=False,
+ indent=2,
+ )
+ )
+ return 0 if working_manifest["status"] == "complete" else 1
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/scripts/provision_flanders_geographic_scope.py b/scripts/provision_flanders_geographic_scope.py
new file mode 100644
index 00000000..dbdadd28
--- /dev/null
+++ b/scripts/provision_flanders_geographic_scope.py
@@ -0,0 +1,220 @@
+"""Provision all current official Flemish municipality Areas.
+
+The municipality inventory is discovered from the official VRBG RefGem
+collection at runtime. The script uses the existing geographic-scope artifact
+and API persistence flow; it never writes directly to PostGIS.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from geographic_scopes import GeographicScope, ScopeMember
+from provision_geographic_scope import (
+ VRBG_ATTRIBUTION,
+ VRBG_ITEMS_URL,
+ build_scope_payloads,
+ build_source_session,
+ provision_scope,
+ sha256_file,
+ write_json_atomic,
+)
+
+
+DEFAULT_API_URL = "http://127.0.0.1:8000"
+DEFAULT_OUTPUT_ROOT = Path("/app/storage/operator-data/geographic-scopes")
+MIN_EXPECTED_MUNICIPALITIES = 270
+MAX_EXPECTED_MUNICIPALITIES = 300
+
+
+def parse_args() -> argparse.Namespace:
+ parser = argparse.ArgumentParser(description="Provision the current official Flanders municipality scope.")
+ parser.add_argument("--base-url", default=os.environ.get("GEOINTEL_INTERNAL_API_URL", DEFAULT_API_URL))
+ parser.add_argument(
+ "--output-root",
+ type=Path,
+ default=Path(os.environ.get("GEOINTEL_SCOPE_OUTPUT_ROOT", DEFAULT_OUTPUT_ROOT)),
+ )
+ parser.add_argument("--request-timeout", type=int, default=180)
+ parser.add_argument("--import-timeout", type=int, default=3600)
+ parser.add_argument("--force", action="store_true")
+ parser.add_argument("--fetch-only", action="store_true")
+ parser.add_argument("--min-municipalities", type=int, default=MIN_EXPECTED_MUNICIPALITIES)
+ parser.add_argument("--max-municipalities", type=int, default=MAX_EXPECTED_MUNICIPALITIES)
+ return parser.parse_args()
+
+
+def discover_flanders_scope(
+ session: requests.Session,
+ *,
+ timeout: int,
+ min_municipalities: int,
+ max_municipalities: int,
+) -> tuple[GeographicScope, list[dict[str, Any]], str]:
+ if min_municipalities <= 0 or max_municipalities < min_municipalities:
+ raise ValueError("Municipality count safety limits are invalid")
+ response = session.get(
+ VRBG_ITEMS_URL,
+ params={"f": "application/geo+json", "limit": "1000"},
+ timeout=timeout,
+ )
+ response.raise_for_status()
+ payload = response.json()
+ features = payload.get("features")
+ if not isinstance(features, list):
+ raise RuntimeError("Official VRBG response does not contain a feature list")
+ if not min_municipalities <= len(features) <= max_municipalities:
+ raise RuntimeError(
+ f"Official VRBG returned {len(features)} municipalities; expected "
+ f"{min_municipalities}..{max_municipalities}. Refusing an incomplete or broadened scope."
+ )
+
+ by_code: dict[str, dict[str, Any]] = {}
+ names: set[str] = set()
+ for feature in features:
+ if not isinstance(feature, dict) or not isinstance(feature.get("geometry"), dict):
+ raise RuntimeError("Official VRBG contains a malformed municipality feature")
+ properties = feature.get("properties")
+ if not isinstance(properties, dict):
+ raise RuntimeError("Official VRBG municipality is missing properties")
+ nis_code = str(properties.get("NISCODE") or "").strip()
+ name = str(properties.get("NAAM") or "").strip()
+ if len(nis_code) != 5 or not nis_code.isdigit() or not name:
+ raise RuntimeError(f"Official VRBG municipality identity is invalid: {nis_code!r} / {name!r}")
+ if nis_code in by_code or name.casefold() in names:
+ raise RuntimeError(f"Official VRBG contains a duplicate municipality: {nis_code} / {name}")
+ by_code[nis_code] = feature
+ names.add(name.casefold())
+
+ ordered = [by_code[code] for code in sorted(by_code)]
+ members = tuple(
+ ScopeMember(
+ name=str(feature["properties"]["NAAM"]).strip(),
+ nis_code=str(feature["properties"]["NISCODE"]).strip(),
+ )
+ for feature in ordered
+ )
+ scope = GeographicScope(
+ key="flanders",
+ display_name=f"Vlaanderen ({len(members)} gemeenten)",
+ project_name="Flanders Regional Workbench",
+ project_region="Vlaanderen, België",
+ area_name="Vlaanderen - officiële operationele grens",
+ authority_name="Digitaal Vlaanderen VRBG",
+ authority_url=VRBG_ITEMS_URL,
+ scope_type="region",
+ limitation_message=(
+ "Officiële unie van de actuele VRBG-gemeentegrenzen. De operationele regio omvat het Vlaamse "
+ "landgebied; territoriale zee, EEZ en continentaal plat zijn afzonderlijke maritieme scopes."
+ ),
+ members=members,
+ )
+ return scope, ordered, response.url
+
+
+def prepare_artifacts(
+ args: argparse.Namespace,
+ scope: GeographicScope,
+ features: list[dict[str, Any]],
+ source_url: str,
+) -> tuple[Path, Path, dict[str, Any]]:
+ output_dir = args.output_root / scope.key
+ manifest_path = output_dir / "flanders_scope_manifest.json"
+ generated_at = datetime.now(timezone.utc).isoformat()
+ snapshot_date = generated_at[:10]
+ boundary_path = output_dir / f"flanders_boundary_{snapshot_date}.geojson"
+ members_path = output_dir / f"flanders_municipalities_{snapshot_date}.geojson"
+ member_codes = list(scope.nis_codes)
+
+ if not args.force and manifest_path.is_file():
+ manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+ cached_boundary = output_dir / str(manifest.get("boundary_filename") or "")
+ cached_members = output_dir / str(manifest.get("municipalities_filename") or "")
+ if (
+ manifest.get("status") == "complete"
+ and manifest.get("member_nis_codes") == member_codes
+ and cached_boundary.is_file()
+ and cached_members.is_file()
+ and sha256_file(cached_boundary) == manifest.get("boundary_sha256")
+ and sha256_file(cached_members) == manifest.get("municipalities_sha256")
+ ):
+ return cached_boundary, cached_members, manifest
+
+ boundary_payload, members_payload, summary = build_scope_payloads(
+ scope,
+ features,
+ source_url=source_url,
+ generated_at=generated_at,
+ )
+ write_json_atomic(boundary_path, boundary_payload)
+ write_json_atomic(members_path, members_payload)
+ manifest = {
+ "schema_version": 1,
+ "status": "complete",
+ "generated_at": generated_at,
+ "observed_at": f"{snapshot_date}T00:00:00Z",
+ "boundary_filename": boundary_path.name,
+ "boundary_sha256": sha256_file(boundary_path),
+ "municipalities_filename": members_path.name,
+ "municipalities_sha256": sha256_file(members_path),
+ "vrbg_source_url": source_url,
+ "vrbg_attribution": VRBG_ATTRIBUTION,
+ "scope_authority_name": scope.authority_name,
+ "scope_authority_url": scope.authority_url,
+ "scope_limitation": scope.limitation_message,
+ **summary,
+ }
+ write_json_atomic(manifest_path, manifest, pretty=True)
+ return boundary_path, members_path, manifest
+
+
+def main() -> int:
+ args = parse_args()
+ args.operator_tool = "provision_flanders_geographic_scope.py"
+ try:
+ with build_source_session() as session:
+ scope, features, source_url = discover_flanders_scope(
+ session,
+ timeout=args.request_timeout,
+ min_municipalities=args.min_municipalities,
+ max_municipalities=args.max_municipalities,
+ )
+ boundary_path, members_path, manifest = prepare_artifacts(args, scope, features, source_url)
+ workspace = None if args.fetch_only else provision_scope(
+ args, scope, boundary_path, members_path, manifest
+ )
+ except (OSError, RuntimeError, ValueError, KeyError, requests.RequestException) as exc:
+ print(json.dumps({"status": "error", "message": str(exc)}, ensure_ascii=False), file=sys.stderr)
+ return 1
+
+ print(
+ json.dumps(
+ {
+ "status": "ok",
+ "mode": "fetch_only" if args.fetch_only else "provisioned",
+ "scope": scope.key,
+ "member_count": manifest["member_count"],
+ "area_km2": manifest["area_km2"],
+ "wgs84_bbox": manifest["wgs84_bbox"],
+ "boundary_path": str(boundary_path),
+ "municipalities_path": str(members_path),
+ "workspace": workspace,
+ "limitation": scope.limitation_message,
+ },
+ ensure_ascii=False,
+ indent=2,
+ )
+ )
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/scripts/provision_geographic_scope.py b/scripts/provision_geographic_scope.py
index 31648d24..cea01182 100644
--- a/scripts/provision_geographic_scope.py
+++ b/scripts/provision_geographic_scope.py
@@ -478,7 +478,7 @@ def provision_scope(
"attribution": VRBG_ATTRIBUTION,
}
common_provenance = {
- "operator_tool": "provision_geographic_scope.py",
+ "operator_tool": getattr(args, "operator_tool", "provision_geographic_scope.py"),
"operator_explicit_fetch": True,
"manifest_path": str(args.output_root / scope.key / f"{scope.key.replace('-', '_')}_scope_manifest.json"),
"source_url": manifest["vrbg_source_url"],
diff --git a/scripts/run_readiness_check.sh b/scripts/run_readiness_check.sh
index 8f6b38c1..e85b4daf 100755
--- a/scripts/run_readiness_check.sh
+++ b/scripts/run_readiness_check.sh
@@ -51,6 +51,9 @@ ${PYTHON_BIN} -m py_compile scripts/provision_mol_historical_landuse.py
${PYTHON_BIN} -m py_compile scripts/provision_regional_historical_landuse.py
${PYTHON_BIN} -m py_compile scripts/provision_official_landuse_timeseries.py
${PYTHON_BIN} -m py_compile scripts/provision_waterinfo_station_history.py
+${PYTHON_BIN} -m py_compile scripts/provision_flanders_geographic_scope.py
+${PYTHON_BIN} -m py_compile scripts/provision_flanders_bathymetry_profiles.py
+${PYTHON_BIN} -m py_compile scripts/probe_mdk_bathymetry.py
${PYTHON_BIN} -m py_compile scripts/provision_mol_bwk_natura2000.py
${PYTHON_BIN} -m py_compile scripts/provision_regional_bwk_natura2000.py
${PYTHON_BIN} -m py_compile scripts/provision_agricultural_parcel_history.py