civic-data 0.1.0__tar.gz

civic_data-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NewGuyAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

civic_data-0.1.0/LICENSE-data

@@ -0,0 +1,37 @@
+Data & Documentation License
+============================
+
+The DATA and DOCUMENTATION produced by this project — the cleaned/normalized
+tables, the generated data dictionary, the transformation-lineage records, and
+the prose in this repository — are licensed under the
+
+    Creative Commons Attribution 4.0 International License (CC BY 4.0).
+
+Full legal text: https://creativecommons.org/licenses/by/4.0/legalcode
+Human-readable summary: https://creativecommons.org/licenses/by/4.0/
+
+You are free to share and adapt this material for any purpose, including
+commercially, provided you give appropriate credit ("civic-data"), link to the
+license, and indicate if changes were made.
+
+(The project's SOURCE CODE is licensed separately under the MIT License; see
+the LICENSE file.)
+
+------------------------------------------------------------------------------
+What this license does and does NOT cover
+------------------------------------------------------------------------------
+
+This project adds value to public open data by cleaning, normalizing, and
+documenting it. The CC BY 4.0 license above covers ONLY that added value.
+
+The UNDERLYING RAW DATA is public record obtained from third-party open-data
+portals (Louisville Metro / LOJIC Open Data on ArcGIS Hub, and others as cities
+are added). That raw data is provided by its sources "as is," and its own terms
+of use are set by those sources, not by this project. Per-layer source terms are
+UNVERIFIED in this repository (see each domain's "License / terms" line in the
+generated data dictionary).
+
+Before republishing a specific source dataset externally, confirm that layer's
+terms of use on its portal item page and attribute the original source
+(e.g. "Louisville Metro / LOJIC Open Data"). Treat commercial redistribution
+rights on the underlying raw data as unconfirmed until checked.

civic_data-0.1.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: civic-data
+Version: 0.1.0
+Summary: Cleaned, documented civic open data — a DuckDB/GeoParquet consumer CLI plus the extraction/normalization spine that builds it, with a generated data dictionary and transformation-lineage layer.
+Author: NewGuyAI
+License: MIT
+Project-URL: Homepage, https://newguyai.com
+Keywords: civic-data,open-data,duckdb,geoparquet,louisville,data-dictionary
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: GIS
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: LICENSE-data
+Requires-Dist: duckdb>=1.1
+Requires-Dist: pytz>=2024.1
+Provides-Extra: producer
+Requires-Dist: psycopg2-binary>=2.9; extra == "producer"
+Requires-Dist: httpx>=0.27; extra == "producer"
+Requires-Dist: python-dotenv>=1.0; extra == "producer"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
+# civic-data
+
+**Cleaned, normalized, and documented public open data — with a generated, code-coupled data
+dictionary and transformation-lineage layer, consumable as a GeoParquet lake with a self-describing
+CLI.**
+
+The city gives away raw open data. civic-data's value is not the data — it's the honest,
+reproducible record of **what we did to it, why, and what's lost**: schema, grain, NULL rates,
+per-year coverage, quarantine loss, bias caveats, and a step-by-step transformation lineage that
+doubles as the reproduction recipe. Because that record is *generated from the live database and the
+ingest code*, it cannot drift from reality.
+
+v1 covers **Louisville, KY**: ten domain datasets (crime, 311 service requests, landbank sales,
+lien orders, foreclosures, food-service establishments, ABC licenses, restaurant inspections,
+construction permits, short-term-rental licenses) plus the geography spine (ZIP boundaries, council
+districts, neighborhoods, HUD zones, crosswalks, Census population) — ~3.5M rows, all ingested from
+source, all lineage-documented.
+
+## Quick start (60 seconds, no database required)
+
+```bash
+pip install civic-data             # consumer install — DuckDB only, no Postgres
+civic-data cities                  # list published city lakes
+civic-data get louisville          # download the lake (sha256-verified) into ./export
+civic-data query -d crime --zip 40202 --limit 5
+```
+
+## Consuming the data
+
+The consumer product is a **GeoParquet lake** described by a machine-readable `catalog.json`, read
+with DuckDB — no server, no Docker, no Postgres. Every verb takes `--json` (for agents) and
+`--lake <dir>` (default: `./export`):
+
+```bash
+civic-data catalog --json          # the discoverability contract — start here
+civic-data datasets                # list datasets by catalog key
+civic-data schema crime            # one dataset's columns + shape
+civic-data query -d crime --zip 40202 --year 2024 --limit 5
+civic-data query -d crime --district 6          # point-in-polygon; geocoded rows only (it says so)
+civic-data place 40202             # one place across every dataset: identity + counts
+civic-data sql "SELECT zip_code, count(*) FROM crime GROUP BY 1"   # raw DuckDB; keys are views
+civic-data query -d crime --sources   # provenance: source pulls, license, how-to-cite
+```
+
+**Hand someone a place as a folder:** `civic-data place 6 --export` writes a self-contained
+mini-lake (filtered Parquet + the district's boundary/crosswalks/population + a scoped catalog +
+generated `llms.txt`/`AGENTS.md`). Every verb above works against that folder via `--lake`.
+
+The lake root also carries generated **`llms.txt`** and **`AGENTS.md`** so an AI agent can bootstrap
+itself from the artifact alone. Both are regenerated from the catalog on every export — never
+hand-edited (a test enforces it).
+
+## Producing the data (the reproduction path)
+
+```bash
+docker compose up -d              # PostgreSQL 16 + PostGIS on host port 5434
+python -m venv .venv && . .venv/Scripts/activate   # (Windows: .venv\Scripts\activate)
+pip install -e .[producer]        # the pipeline extras (Postgres driver, HTTP client)
+
+civic-data ingest-zips                          # canonical ZIP boundary set (MDM) — run first
+civic-data ingest-refs                          # LOJIC geocoding references (address points + intersections)
+civic-data ingest-geo && civic-data ingest-population   # boundaries, crosswalks, Census ACS
+civic-data ingest crime --all --promote         # source -> bronze -> silver (any of the 10 domains)
+civic-data geocode-crime --write --apply        # place ~1.2M crime records (geom + derived ZIP)
+civic-data datadict --with-source-audit         # generate the data dictionary + lineage
+civic-data export                               # silver -> GeoParquet lake + catalog + agent docs
+```
+
+The generated dictionary lands in [`docs/data-dictionary/`](docs/data-dictionary/) — a human-readable
+`README.md` and a machine-readable `data-reality.json` (diffing successive runs is drift detection).
+
+Ingest order matters: `ingest-zips` first. The ZIP set is the canonical geography (MDM) every record
+validates against; crime/311 ingest refuse to run without it.
+
+## Honesty, by construction
+
+- **Trust tiers** on every dataset (`trendable` / `viewable_caveated` / `snapshot_only`) — a current
+  roster is not a time series, and the catalog says which is which.
+- **Documented loss, not silent loss:** quarantine counts, geocode coverage (spatial filters match
+  geocoded rows only, and the CLI says so), source-shape divergences recorded as findings.
+- **Generated, never hand-maintained:** the dictionary, the catalog, and the agent docs are all
+  derived from the live database + code; drift guards raise when authored prose falls out of sync.
+
+## Licensing
+
+- **Code:** MIT — see [`LICENSE`](LICENSE).
+- **Data & documentation:** CC BY 4.0 — see [`LICENSE-data`](LICENSE-data).
+
+The underlying raw data is **public record, provided as-is**, and its terms were verified per origin
+(2026-07-11): Louisville Metro publishes under the **PDDL** (public domain; when republishing
+modified data, identify the source, version, and modifications — which the generated lineage layer
+does per dataset); LOJIC layers are public domain (*Mapping Data Source: LOJIC*); Census ACS is a
+U.S. government work — *this product uses the Census Bureau Data API but is not endorsed or
+certified by the Census Bureau.* Every dataset's exact license text ships in its catalog provenance:
+`civic-data query -d <dataset> --sources`.
+
+## Provenance
+
+Born out of civic-graph (the private flagship built on top of this layer, and the origin of this
+spine). See `wiki.md` for the source of truth and `ai-working/plans/` for the phase plans.

civic_data-0.1.0/README.md

@@ -0,0 +1,100 @@
+# civic-data
+
+**Cleaned, normalized, and documented public open data — with a generated, code-coupled data
+dictionary and transformation-lineage layer, consumable as a GeoParquet lake with a self-describing
+CLI.**
+
+The city gives away raw open data. civic-data's value is not the data — it's the honest,
+reproducible record of **what we did to it, why, and what's lost**: schema, grain, NULL rates,
+per-year coverage, quarantine loss, bias caveats, and a step-by-step transformation lineage that
+doubles as the reproduction recipe. Because that record is *generated from the live database and the
+ingest code*, it cannot drift from reality.
+
+v1 covers **Louisville, KY**: ten domain datasets (crime, 311 service requests, landbank sales,
+lien orders, foreclosures, food-service establishments, ABC licenses, restaurant inspections,
+construction permits, short-term-rental licenses) plus the geography spine (ZIP boundaries, council
+districts, neighborhoods, HUD zones, crosswalks, Census population) — ~3.5M rows, all ingested from
+source, all lineage-documented.
+
+## Quick start (60 seconds, no database required)
+
+```bash
+pip install civic-data             # consumer install — DuckDB only, no Postgres
+civic-data cities                  # list published city lakes
+civic-data get louisville          # download the lake (sha256-verified) into ./export
+civic-data query -d crime --zip 40202 --limit 5
+```
+
+## Consuming the data
+
+The consumer product is a **GeoParquet lake** described by a machine-readable `catalog.json`, read
+with DuckDB — no server, no Docker, no Postgres. Every verb takes `--json` (for agents) and
+`--lake <dir>` (default: `./export`):
+
+```bash
+civic-data catalog --json          # the discoverability contract — start here
+civic-data datasets                # list datasets by catalog key
+civic-data schema crime            # one dataset's columns + shape
+civic-data query -d crime --zip 40202 --year 2024 --limit 5
+civic-data query -d crime --district 6          # point-in-polygon; geocoded rows only (it says so)
+civic-data place 40202             # one place across every dataset: identity + counts
+civic-data sql "SELECT zip_code, count(*) FROM crime GROUP BY 1"   # raw DuckDB; keys are views
+civic-data query -d crime --sources   # provenance: source pulls, license, how-to-cite
+```
+
+**Hand someone a place as a folder:** `civic-data place 6 --export` writes a self-contained
+mini-lake (filtered Parquet + the district's boundary/crosswalks/population + a scoped catalog +
+generated `llms.txt`/`AGENTS.md`). Every verb above works against that folder via `--lake`.
+
+The lake root also carries generated **`llms.txt`** and **`AGENTS.md`** so an AI agent can bootstrap
+itself from the artifact alone. Both are regenerated from the catalog on every export — never
+hand-edited (a test enforces it).
+
+## Producing the data (the reproduction path)
+
+```bash
+docker compose up -d              # PostgreSQL 16 + PostGIS on host port 5434
+python -m venv .venv && . .venv/Scripts/activate   # (Windows: .venv\Scripts\activate)
+pip install -e .[producer]        # the pipeline extras (Postgres driver, HTTP client)
+
+civic-data ingest-zips                          # canonical ZIP boundary set (MDM) — run first
+civic-data ingest-refs                          # LOJIC geocoding references (address points + intersections)
+civic-data ingest-geo && civic-data ingest-population   # boundaries, crosswalks, Census ACS
+civic-data ingest crime --all --promote         # source -> bronze -> silver (any of the 10 domains)
+civic-data geocode-crime --write --apply        # place ~1.2M crime records (geom + derived ZIP)
+civic-data datadict --with-source-audit         # generate the data dictionary + lineage
+civic-data export                               # silver -> GeoParquet lake + catalog + agent docs
+```
+
+The generated dictionary lands in [`docs/data-dictionary/`](docs/data-dictionary/) — a human-readable
+`README.md` and a machine-readable `data-reality.json` (diffing successive runs is drift detection).
+
+Ingest order matters: `ingest-zips` first. The ZIP set is the canonical geography (MDM) every record
+validates against; crime/311 ingest refuse to run without it.
+
+## Honesty, by construction
+
+- **Trust tiers** on every dataset (`trendable` / `viewable_caveated` / `snapshot_only`) — a current
+  roster is not a time series, and the catalog says which is which.
+- **Documented loss, not silent loss:** quarantine counts, geocode coverage (spatial filters match
+  geocoded rows only, and the CLI says so), source-shape divergences recorded as findings.
+- **Generated, never hand-maintained:** the dictionary, the catalog, and the agent docs are all
+  derived from the live database + code; drift guards raise when authored prose falls out of sync.
+
+## Licensing
+
+- **Code:** MIT — see [`LICENSE`](LICENSE).
+- **Data & documentation:** CC BY 4.0 — see [`LICENSE-data`](LICENSE-data).
+
+The underlying raw data is **public record, provided as-is**, and its terms were verified per origin
+(2026-07-11): Louisville Metro publishes under the **PDDL** (public domain; when republishing
+modified data, identify the source, version, and modifications — which the generated lineage layer
+does per dataset); LOJIC layers are public domain (*Mapping Data Source: LOJIC*); Census ACS is a
+U.S. government work — *this product uses the Census Bureau Data API but is not endorsed or
+certified by the Census Bureau.* Every dataset's exact license text ships in its catalog provenance:
+`civic-data query -d <dataset> --sources`.
+
+## Provenance
+
+Born out of civic-graph (the private flagship built on top of this layer, and the origin of this
+spine). See `wiki.md` for the source of truth and `ai-working/plans/` for the phase plans.

civic_data-0.1.0/civic_data/__init__.py

@@ -0,0 +1,14 @@
+"""civic-data — the extraction / normalization / documentation spine.
+
+One canonical home for the data-layer core: source adapters, medallion ingest
+(bronze → silver), and a generated data dictionary with a transformation-lineage
+layer. The product's value is not the data (the city gives that away raw) — it is
+the *documented, reproducible transformation lineage*: what we did, why, and what
+is lost. That lineage is generated from the live DB + code, never hand-maintained,
+so it cannot drift from reality.
+
+civic-graph (the private flagship) was the origin of this code and is now a
+downstream consumer / worked example built on top.
+"""
+
+__version__ = "0.1.0"

civic_data-0.1.0/civic_data/adapters/__init__.py

@@ -0,0 +1,7 @@
+"""Source adapters — the extraction spine.
+
+`arcgis` is the working portal adapter (Louisville / LOJIC, and any ArcGIS Hub
+portal). `socrata` is a dormant placeholder that activates at city #2
+(Cincinnati / Chicago). `validation` is the ZIP/geography gatekeeper shared by
+every ingest path. `base` is the adapter contract.
+"""

civic_data-0.1.0/civic_data/adapters/arcgis.py

@@ -0,0 +1,128 @@
+"""ArcGIS Feature Service adapter.
+
+Louisville's open data portal runs on ArcGIS Hub. Most datasets are
+exposed as ArcGIS Feature Services with a REST query endpoint.
+
+Feature Service query pattern:
+  GET {service_url}/query?where=1=1&outFields=*&f=json&resultOffset=0&resultRecordCount=2000
+
+Pagination: resultOffset increments by resultRecordCount until
+exceededTransferLimit is false.
+"""
+
+import time
+import httpx
+from typing import Any
+
+
+def feature_count(service_url: str, timeout: float = 30.0) -> int | None:
+    """Source row count via ArcGIS returnCountOnly (one tiny call). None on error.
+
+    Captured at ingest as source-pull metadata (the reproducibility substrate): the
+    source_rowcount at pull time, to compare against what we actually fetched/kept.
+    """
+    try:
+        resp = httpx.get(f"{service_url}/query",
+                         params={"where": "1=1", "returnCountOnly": "true", "f": "json"},
+                         timeout=timeout)
+        resp.raise_for_status()
+        return resp.json().get("count")
+    except Exception:
+        return None
+
+
+def _query_page(client, url, params, max_retries: int = 4):
+    """Fetch one page, retrying transient failures. Returns parsed JSON with a 'features' key.
+
+    Raises RuntimeError if the server never returns a valid page — so a transient error
+    (HTTP 5xx, an ArcGIS error payload, a truncated body) can NEVER be mistaken for
+    end-of-data and silently truncate a large pull. Only a *valid* response with an empty
+    'features' array or exceededTransferLimit=False ends pagination (handled by the caller).
+    """
+    last_err = None
+    for attempt in range(max_retries):
+        try:
+            resp = client.get(url, params=params)
+            resp.raise_for_status()
+            data = resp.json()
+            if "error" in data:
+                last_err = f"ArcGIS error payload: {data['error']}"
+            elif "features" not in data:
+                last_err = f"response missing 'features' (keys={list(data)[:6]})"
+            else:
+                return data
+        except (httpx.HTTPError, ValueError) as e:  # ValueError also covers JSON decode errors
+            last_err = repr(e)
+        time.sleep(1.0 * (attempt + 1))  # linear backoff between retries
+    raise RuntimeError(
+        f"ArcGIS page failed after {max_retries} attempts "
+        f"(resultOffset={params.get('resultOffset')}): {last_err}")
+
+
+def fetch_feature_service(
+    service_url: str,
+    where: str = "1=1",
+    out_fields: str = "*",
+    page_size: int = 2000,
+    max_records: int | None = None,
+    delay: float = 0.5,
+) -> list[dict[str, Any]]:
+    """Fetch all records from an ArcGIS Feature Service.
+
+    Args:
+        service_url: The Feature Service layer URL
+            (e.g., https://services1.arcgis.com/.../FeatureServer/0)
+        where: SQL WHERE clause for filtering
+        out_fields: Comma-separated field names or "*" for all
+        page_size: Records per request (max varies by service, 2000 is safe)
+        max_records: Optional cap on total records fetched
+        delay: Seconds between paginated requests (polite scraping)
+
+    Returns:
+        List of feature attribute dicts (geometry stripped to lat/lng if present)
+
+    Pagination terminates only on a *valid* empty page or exceededTransferLimit=False;
+    transient per-page failures are retried (see _query_page), never treated as done.
+    """
+    all_records = []
+    offset = 0
+    url = f"{service_url}/query"
+
+    with httpx.Client(timeout=60.0) as client:
+        while True:
+            params = {
+                "where": where,
+                "outFields": out_fields,
+                "f": "json",
+                "resultOffset": offset,
+                "resultRecordCount": page_size,
+                "outSR": 4326,  # WGS84
+            }
+
+            data = _query_page(client, url, params)
+            features = data.get("features", [])
+            if not features:
+                break
+
+            for f in features:
+                record = f.get("attributes", {})
+                # Extract geometry as flat lat/lng if present
+                geom = f.get("geometry")
+                if geom:
+                    record["_longitude"] = geom.get("x")
+                    record["_latitude"] = geom.get("y")
+                all_records.append(record)
+
+            if max_records and len(all_records) >= max_records:
+                all_records = all_records[:max_records]
+                break
+
+            if not data.get("exceededTransferLimit", False):
+                break
+
+            # Increment by actual records returned, not page_size.
+            # Some services cap below our page_size (e.g., 1000 max).
+            offset += len(features)
+            time.sleep(delay)
+
+    return all_records

civic_data-0.1.0/civic_data/adapters/base.py

@@ -0,0 +1,71 @@
+"""Base adapter interface for civic data sources."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class IngestResult:
+    """Result of a data ingestion run."""
+    adapter: str
+    source_dataset: str
+    record_count: int
+    status: str  # "ok" or "error"
+    error_message: str | None = None
+
+
+class CivicDataAdapter(ABC):
+    """Abstract base class for all civic data adapters.
+
+    Each adapter handles one data domain (crime, 311, property, etc.)
+    and knows how to:
+    1. Fetch raw data from the source API
+    2. Store raw records in bronze layer (JSONB, append-only)
+    3. Transform raw records into silver layer (typed, geocoded)
+    """
+
+    @property
+    @abstractmethod
+    def adapter_name(self) -> str:
+        """Unique identifier for this adapter (e.g., 'crime', 'service_requests')."""
+        ...
+
+    @abstractmethod
+    def fetch_raw(self, dataset_id: str, **kwargs) -> list[dict[str, Any]]:
+        """Fetch raw records from the source API.
+
+        Returns a list of raw JSON-serializable dicts.
+        """
+        ...
+
+    @abstractmethod
+    def load_bronze(self, records: list[dict[str, Any]], dataset_id: str) -> int:
+        """Store raw records in the bronze layer. Returns count of rows inserted."""
+        ...
+
+    @abstractmethod
+    def promote_to_silver(self, dataset_id: str) -> int:
+        """Transform bronze records into silver layer. Returns count of rows promoted."""
+        ...
+
+    def ingest(self, dataset_id: str, **kwargs) -> IngestResult:
+        """Full ingestion pipeline: fetch → bronze → silver."""
+        try:
+            raw = self.fetch_raw(dataset_id, **kwargs)
+            bronze_count = self.load_bronze(raw, dataset_id)
+            silver_count = self.promote_to_silver(dataset_id)
+            return IngestResult(
+                adapter=self.adapter_name,
+                source_dataset=dataset_id,
+                record_count=silver_count,
+                status="ok",
+            )
+        except Exception as e:
+            return IngestResult(
+                adapter=self.adapter_name,
+                source_dataset=dataset_id,
+                record_count=0,
+                status="error",
+                error_message=str(e),
+            )

civic_data-0.1.0/civic_data/adapters/socrata.py

@@ -0,0 +1,28 @@
+"""Socrata Open Data adapter — DORMANT (activates at city #2).
+
+STATUS: placeholder, not implemented. v1 is Louisville-only (crime + 311) on
+ArcGIS Hub; see `adapters/arcgis.py` for the working pattern. Socrata is the
+multi-city unlock — Cincinnati, Chicago, and ~100 other US cities publish on the
+Socrata platform (SODA API). When city #2 lands, implement `fetch_dataset`
+against the SODA endpoint, mirroring the shape `arcgis.fetch_feature_service`
+returns (a list of flat attribute dicts) so the downstream ingest/validation
+spine is unchanged.
+
+Design note (from the kickoff): this file was listed in the seed manifest as
+inherited from civic-graph, but civic-graph never actually authored a Socrata
+adapter — only the ArcGIS one exists there. So this is a fresh, honest stub, not
+a lift. Multi-city is the thesis, not the v1 scope; do not build it out until a
+real second city is in scope (guardrail: no future-proofing).
+
+SODA query pattern (for reference when implemented):
+  GET https://{domain}/resource/{dataset_id}.json?$limit=50000&$offset=0
+  Pagination via $limit/$offset; optional $$app_token header to raise rate limits.
+"""
+
+
+def fetch_dataset(*args, **kwargs):
+    raise NotImplementedError(
+        "The Socrata adapter is dormant. v1 is Louisville-only (ArcGIS). "
+        "Implement this against the SODA API when city #2 (Cincinnati/Chicago) is in scope, "
+        "returning the same flat-dict shape as adapters.arcgis.fetch_feature_service."
+    )