coord-ingest 0.1.0__tar.gz

coord_ingest-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gabriel Mahia / AfriKaziOS
+
+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.

coord_ingest-0.1.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: coord-ingest
+Version: 0.1.0
+Summary: Turn open world-signal feeds (quakes, disasters, outbreaks) into africa-coord-bus coordination events — East Africa scoped, MIT, no API keys.
+Author: AfriKaziOS maintainers
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/gabrielmahia/coord-ingest
+Project-URL: Repository, https://github.com/gabrielmahia/coord-ingest
+Keywords: osint,east-africa,coordination,mcp,early-warning,feeds
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: africa-coord-bus>=0.2.0
+Dynamic: license-file
+
+# coord-ingest
+
+Global situational-awareness dashboards ingest hundreds of live feeds and turn them into an actionable picture — but they score the world's Tier-1 countries, and East Africa isn't on that list. The signals that matter here (drought onset, basin flooding, cholera clusters, rift-zone quakes) are in the same public feeds; nothing was turning them into events a regional coordination system could act on.
+
+`coord-ingest` is that missing rail: an MIT-licensed adapter that converts open, key-free world-signal feeds into [`africa-coord-bus`](https://github.com/gabrielmahia/africa-coord-bus) coordination events, **filtered to East Africa**, so the bus can cascade them to the right domains (insurance, crop advisory, water testing, cross-border alerts).
+
+It ingests and normalizes; the bus routes. Clean separation, composable rails.
+
+## What it does
+
+- **Adapters** for public sources — USGS earthquakes, ReliefWeb disasters, GDACS alerts — each mapping raw records to typed `CoordinationEvent`s. Add a feed by adding an adapter.
+- **East-Africa filter** — a signal becomes an event only if it lands in the regional bounding box or names a regional country. Global noise is dropped at ingest.
+- **Offline-capable** — ships with a `SampleAdapter` over bundled fixtures, so the full pipeline (and its tests) run with no network and no API keys.
+- **Feeds the bus, doesn't replace it** — routing, cascading, and cross-border logic stay in `africa-coord-bus`.
+
+## Use it
+
+```bash
+pip install coord-ingest
+```
+
+```python
+from coord_ingest import IngestPipeline, SampleAdapter
+
+# Offline demo — no keys, no network
+summary = IngestPipeline([SampleAdapter()]).run()
+print(summary["collected"], "East Africa events")   # global noise already dropped
+print(summary["by_domain"])                          # {'water': 3, 'health': 1, 'transport': 1}
+
+# With live feeds + the bus:
+# from coord_ingest import USGSQuakeAdapter, GDACSAdapter
+# from africa_coord_bus import EventBus
+# IngestPipeline([USGSQuakeAdapter(), GDACSAdapter()]).run(bus=EventBus(...))
+```
+
+## Why not just fork a dashboard?
+
+The global open-source dashboards that inspired this are AGPL applications. This is deliberately the opposite: a small **MIT library** that produces standard bus events any tool can consume — including a dashboard, if someone wants to build one. Rails, not another train.
+
+## IP & Collaboration
+
+MIT. New feed adapters welcome via GitHub Issues (public, key-free sources, East-Africa relevant). Full policy: [docs/architecture/IP_POLICY.md](docs/architecture/IP_POLICY.md). Security: [SECURITY.md](SECURITY.md).

coord_ingest-0.1.0/README.md

@@ -0,0 +1,42 @@
+# coord-ingest
+
+Global situational-awareness dashboards ingest hundreds of live feeds and turn them into an actionable picture — but they score the world's Tier-1 countries, and East Africa isn't on that list. The signals that matter here (drought onset, basin flooding, cholera clusters, rift-zone quakes) are in the same public feeds; nothing was turning them into events a regional coordination system could act on.
+
+`coord-ingest` is that missing rail: an MIT-licensed adapter that converts open, key-free world-signal feeds into [`africa-coord-bus`](https://github.com/gabrielmahia/africa-coord-bus) coordination events, **filtered to East Africa**, so the bus can cascade them to the right domains (insurance, crop advisory, water testing, cross-border alerts).
+
+It ingests and normalizes; the bus routes. Clean separation, composable rails.
+
+## What it does
+
+- **Adapters** for public sources — USGS earthquakes, ReliefWeb disasters, GDACS alerts — each mapping raw records to typed `CoordinationEvent`s. Add a feed by adding an adapter.
+- **East-Africa filter** — a signal becomes an event only if it lands in the regional bounding box or names a regional country. Global noise is dropped at ingest.
+- **Offline-capable** — ships with a `SampleAdapter` over bundled fixtures, so the full pipeline (and its tests) run with no network and no API keys.
+- **Feeds the bus, doesn't replace it** — routing, cascading, and cross-border logic stay in `africa-coord-bus`.
+
+## Use it
+
+```bash
+pip install coord-ingest
+```
+
+```python
+from coord_ingest import IngestPipeline, SampleAdapter
+
+# Offline demo — no keys, no network
+summary = IngestPipeline([SampleAdapter()]).run()
+print(summary["collected"], "East Africa events")   # global noise already dropped
+print(summary["by_domain"])                          # {'water': 3, 'health': 1, 'transport': 1}
+
+# With live feeds + the bus:
+# from coord_ingest import USGSQuakeAdapter, GDACSAdapter
+# from africa_coord_bus import EventBus
+# IngestPipeline([USGSQuakeAdapter(), GDACSAdapter()]).run(bus=EventBus(...))
+```
+
+## Why not just fork a dashboard?
+
+The global open-source dashboards that inspired this are AGPL applications. This is deliberately the opposite: a small **MIT library** that produces standard bus events any tool can consume — including a dashboard, if someone wants to build one. Rails, not another train.
+
+## IP & Collaboration
+
+MIT. New feed adapters welcome via GitHub Issues (public, key-free sources, East-Africa relevant). Full policy: [docs/architecture/IP_POLICY.md](docs/architecture/IP_POLICY.md). Security: [SECURITY.md](SECURITY.md).

coord_ingest-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "coord-ingest"
+version = "0.1.0"
+description = "Turn open world-signal feeds (quakes, disasters, outbreaks) into africa-coord-bus coordination events — East Africa scoped, MIT, no API keys."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "AfriKaziOS maintainers"}]
+keywords = ["osint","east-africa","coordination","mcp","early-warning","feeds"]
+dependencies = ["africa-coord-bus>=0.2.0"]
+
+[project.urls]
+Homepage = "https://github.com/gabrielmahia/coord-ingest"
+Repository = "https://github.com/gabrielmahia/coord-ingest"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+packages = ["coord_ingest"]
+
+[tool.setuptools.package-data]
+coord_ingest = ["data/*.json"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"

coord_ingest-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

coord_ingest-0.1.0/src/coord_ingest/__init__.py

@@ -0,0 +1,50 @@
+"""coord-ingest — turn open world-signal feeds into coordination events.
+
+WHY THIS EXISTS
+---------------
+The coordination stack can *route* events (africa-coord-bus) and *serve* domain
+data (35 MCP servers), but nothing turned raw, real-world signals INTO
+coordination events. Dashboards like worldmonitor prove the ingest+correlate
+pattern at global scale — but they are AGPL applications scored on Tier-1
+countries, and East Africa is not Tier-1. This is the missing *rail*: an
+MIT-licensed adapter that maps public feeds (USGS quakes, ReliefWeb disasters,
+GDACS alerts, WHO outbreaks) into typed CoordinationEvents the bus already knows
+how to cascade — scoped to the region the global dashboards skip.
+
+DESIGN
+------
+- **Source-agnostic.** Each adapter implements `FeedAdapter.fetch() -> list[dict]`
+  and `.to_events() -> list[CoordinationEvent]`. Add a feed by adding an adapter.
+- **East-Africa filtered.** A signal only becomes an event if it lands in the
+  region bounding box or names a regional country. Global noise is dropped at
+  ingest, not routing.
+- **No keys, offline-capable.** Ships with a `SampleAdapter` (bundled fixtures)
+  so the whole pipeline runs and tests without network — the same local-first
+  ethos, applied to our region.
+- **Feeds the bus, doesn't replace it.** Output is CoordinationEvents; routing,
+  cascading, and cross-border logic stay in africa-coord-bus where they belong.
+"""
+
+from __future__ import annotations
+
+from .adapters import (
+    FeedAdapter,
+    SampleAdapter,
+    USGSQuakeAdapter,
+    ReliefWebAdapter,
+    GDACSAdapter,
+)
+from .pipeline import IngestPipeline, EAST_AFRICA_BBOX, in_east_africa
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "FeedAdapter",
+    "SampleAdapter",
+    "USGSQuakeAdapter",
+    "ReliefWebAdapter",
+    "GDACSAdapter",
+    "IngestPipeline",
+    "EAST_AFRICA_BBOX",
+    "in_east_africa",
+]

coord_ingest-0.1.0/src/coord_ingest/adapters.py

@@ -0,0 +1,196 @@
+"""Feed adapters: public world-signal source -> CoordinationEvent.
+
+Each adapter is small and single-purpose. Real network adapters fetch public,
+key-free feeds; SampleAdapter uses bundled fixtures so the pipeline runs offline.
+All adapters emit africa-coord-bus CoordinationEvents — the bus owns routing.
+"""
+
+from __future__ import annotations
+
+import json
+from abc import ABC, abstractmethod
+from importlib import resources
+
+from africa_coord_bus.event import CoordinationEvent, EventDomain, EventSeverity
+
+
+def _severity_from_magnitude(mag: float) -> EventSeverity:
+    if mag >= 7.0:
+        return EventSeverity.CRITICAL
+    if mag >= 6.0:
+        return EventSeverity.ALERT
+    if mag >= 5.0:
+        return EventSeverity.WARNING
+    return EventSeverity.INFO
+
+
+class FeedAdapter(ABC):
+    """Base contract: fetch raw records, convert to CoordinationEvents."""
+
+    #: bus domain this feed primarily maps to
+    domain: EventDomain = EventDomain.CIVIC
+    #: event_type emitted (must match routing-table triggers to cascade)
+    event_type: str = "external_signal"
+    #: stable source label
+    source: str = "coord-ingest"
+
+    @abstractmethod
+    def fetch(self) -> list[dict]:
+        """Return raw feed records as dicts. Network or fixtures."""
+
+    def to_events(self) -> list[CoordinationEvent]:
+        events = []
+        for rec in self.fetch():
+            ev = self._record_to_event(rec)
+            if ev is not None:
+                events.append(ev)
+        return events
+
+    @abstractmethod
+    def _record_to_event(self, rec: dict) -> CoordinationEvent | None:
+        """Map one raw record to a CoordinationEvent (or None to drop)."""
+
+
+class SampleAdapter(FeedAdapter):
+    """Offline adapter over bundled fixtures — runs the whole pipeline with no
+    network and no keys. Fixtures cover quake, flood, and outbreak signals in
+    East Africa so cascades can be demonstrated end to end."""
+
+    domain = EventDomain.WATER
+    event_type = "external_signal"
+    source = "coord-ingest.sample"
+
+    def fetch(self) -> list[dict]:
+        text = resources.files("coord_ingest").joinpath("data/sample_feed.json").read_text("utf-8")
+        return json.loads(text)
+
+    def _record_to_event(self, rec: dict) -> CoordinationEvent | None:
+        domain = EventDomain(rec["domain"])
+        return CoordinationEvent(
+            domain=domain,
+            event_type=rec["event_type"],
+            source=self.source,
+            severity=EventSeverity(rec.get("severity", "warning")),
+            data={
+                "title": rec.get("title", ""),
+                "lat": rec.get("lat"),
+                "lon": rec.get("lon"),
+                "country": rec.get("country"),
+                "border_adjacent": rec.get("border_adjacent", False),
+                "origin_feed": "sample",
+            },
+        )
+
+
+class USGSQuakeAdapter(FeedAdapter):
+    """USGS earthquakes (public GeoJSON, no key). Quakes near dams, lakes, or
+    settlements are routed as water/transport signals for downstream assessment."""
+
+    domain = EventDomain.TRANSPORT
+    event_type = "infrastructure_shock"
+    source = "coord-ingest.usgs"
+    FEED_URL = "https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/4.5_day.geojson"
+
+    def __init__(self, records: list[dict] | None = None):
+        # allow injected records for testing without network
+        self._injected = records
+
+    def fetch(self) -> list[dict]:
+        if self._injected is not None:
+            return self._injected
+        import urllib.request
+
+        with urllib.request.urlopen(self.FEED_URL, timeout=20) as r:
+            payload = json.load(r)
+        return payload.get("features", [])
+
+    def _record_to_event(self, rec: dict) -> CoordinationEvent | None:
+        props = rec.get("properties", {})
+        geom = rec.get("geometry", {})
+        coords = geom.get("coordinates", [None, None])
+        lon, lat = coords[0], coords[1]
+        mag = props.get("mag") or 0.0
+        return CoordinationEvent(
+            domain=self.domain,
+            event_type=self.event_type,
+            source=self.source,
+            severity=_severity_from_magnitude(mag),
+            data={
+                "title": props.get("place", ""),
+                "magnitude": mag,
+                "lat": lat,
+                "lon": lon,
+                "origin_feed": "usgs",
+            },
+        )
+
+
+class ReliefWebAdapter(FeedAdapter):
+    """ReliefWeb disaster reports (public API). Maps humanitarian disaster
+    signals to the water/health domains for coordination follow-up."""
+
+    domain = EventDomain.HEALTH
+    event_type = "disaster_report"
+    source = "coord-ingest.reliefweb"
+
+    def __init__(self, records: list[dict] | None = None):
+        self._injected = records
+
+    def fetch(self) -> list[dict]:
+        if self._injected is not None:
+            return self._injected
+        import urllib.request
+
+        url = ("https://api.reliefweb.int/v1/disasters?appname=coord-ingest"
+               "&profile=list&preset=latest&limit=20")
+        with urllib.request.urlopen(url, timeout=20) as r:
+            return json.load(r).get("data", [])
+
+    def _record_to_event(self, rec: dict) -> CoordinationEvent | None:
+        fields = rec.get("fields", {})
+        name = fields.get("name", "")
+        return CoordinationEvent(
+            domain=self.domain,
+            event_type=self.event_type,
+            source=self.source,
+            severity=EventSeverity.WARNING,
+            data={"title": name, "origin_feed": "reliefweb"},
+        )
+
+
+class GDACSAdapter(FeedAdapter):
+    """GDACS global disaster alerts. Alert colour maps to severity; the pipeline
+    filters to East Africa downstream."""
+
+    domain = EventDomain.WATER
+    event_type = "disaster_alert"
+    source = "coord-ingest.gdacs"
+    _COLOUR = {"Green": EventSeverity.INFO, "Orange": EventSeverity.ALERT, "Red": EventSeverity.CRITICAL}
+
+    def __init__(self, records: list[dict] | None = None):
+        self._injected = records
+
+    def fetch(self) -> list[dict]:
+        if self._injected is not None:
+            return self._injected
+        import urllib.request
+
+        with urllib.request.urlopen("https://www.gdacs.org/gdacsapi/api/events/geteventlist/SEARCH", timeout=20) as r:
+            return json.load(r).get("features", [])
+
+    def _record_to_event(self, rec: dict) -> CoordinationEvent | None:
+        props = rec.get("properties", rec)
+        colour = props.get("alertlevel", "Green")
+        return CoordinationEvent(
+            domain=self.domain,
+            event_type=self.event_type,
+            source=self.source,
+            severity=self._COLOUR.get(colour, EventSeverity.INFO),
+            data={
+                "title": props.get("eventname") or props.get("description", ""),
+                "lat": props.get("latitude"),
+                "lon": props.get("longitude"),
+                "country": props.get("country"),
+                "origin_feed": "gdacs",
+            },
+        )

coord_ingest-0.1.0/src/coord_ingest/data/sample_feed.json

@@ -0,0 +1,8 @@
+[
+  {"domain":"water","event_type":"drought_alert","severity":"alert","title":"Prolonged dry spell, northern rangeland","lat":2.3,"lon":37.9,"country":"Kenya","border_adjacent":true},
+  {"domain":"water","event_type":"flood_alert","severity":"warning","title":"River basin rising after heavy rains","lat":-7.8,"lon":38.3,"country":"Tanzania","border_adjacent":false},
+  {"domain":"health","event_type":"disease_outbreak","severity":"alert","title":"Cholera cases reported near lake shore","lat":0.1,"lon":34.7,"country":"Kenya","border_adjacent":false},
+  {"domain":"transport","event_type":"infrastructure_shock","severity":"warning","title":"Magnitude 5.2 quake near rift settlements","lat":-1.3,"lon":36.1,"country":"Kenya","border_adjacent":false},
+  {"domain":"water","event_type":"drought_alert","severity":"info","title":"Seasonal forecast: below-average rainfall","lat":9.0,"lon":40.5,"country":"Ethiopia","border_adjacent":false},
+  {"domain":"water","event_type":"flood_alert","severity":"critical","title":"Flash flooding — GLOBAL NOISE (should be dropped)","lat":51.5,"lon":-0.1,"country":"United Kingdom","border_adjacent":false}
+]

coord_ingest-0.1.0/src/coord_ingest/pipeline.py

@@ -0,0 +1,70 @@
+"""IngestPipeline — run adapters, filter to East Africa, hand events to the bus.
+
+The pipeline is deliberately thin: adapters produce events, the pipeline drops
+anything outside the region, and routing/cascading stays in africa-coord-bus.
+This keeps the ingest rail composable and the bus authoritative.
+"""
+
+from __future__ import annotations
+
+from africa_coord_bus.event import CoordinationEvent
+
+# Rough East Africa bounding box (lat_min, lat_max, lon_min, lon_max).
+# Covers Kenya, Tanzania, Uganda, Rwanda, Burundi, Ethiopia, Somalia, S. Sudan.
+EAST_AFRICA_BBOX = (-12.0, 15.0, 28.0, 52.0)
+
+EAST_AFRICA_COUNTRIES = {
+    "kenya", "tanzania", "uganda", "rwanda", "burundi", "ethiopia",
+    "somalia", "south sudan", "sudan", "djibouti", "eritrea",
+}
+
+
+def in_east_africa(event: CoordinationEvent) -> bool:
+    """True if the event's location falls in the region (by bbox or country)."""
+    data = event.data or {}
+    country = str(data.get("country") or "").strip().lower()
+    if country and country in EAST_AFRICA_COUNTRIES:
+        return True
+    lat, lon = data.get("lat"), data.get("lon")
+    if lat is None or lon is None:
+        # No geo and no known country -> cannot confirm region; drop conservatively.
+        return False
+    lat_min, lat_max, lon_min, lon_max = EAST_AFRICA_BBOX
+    return lat_min <= lat <= lat_max and lon_min <= lon <= lon_max
+
+
+class IngestPipeline:
+    """Collects events from adapters, filters to East Africa, optionally routes."""
+
+    def __init__(self, adapters, region_filter=in_east_africa):
+        self.adapters = list(adapters)
+        self.region_filter = region_filter
+
+    def collect(self) -> list[CoordinationEvent]:
+        """All region-relevant events across every adapter."""
+        out: list[CoordinationEvent] = []
+        for adapter in self.adapters:
+            try:
+                events = adapter.to_events()
+            except Exception:  # noqa: BLE001 — one bad feed must not sink the run
+                continue
+            out.extend(e for e in events if self.region_filter(e))
+        return out
+
+    def run(self, bus=None) -> dict:
+        """Collect region events; if a bus is given, publish each and return a
+        summary. Without a bus, returns the events for inspection."""
+        events = self.collect()
+        summary = {"collected": len(events), "by_domain": {}, "published": 0}
+        for e in events:
+            d = e.domain.value
+            summary["by_domain"][d] = summary["by_domain"].get(d, 0) + 1
+        if bus is not None:
+            for e in events:
+                try:
+                    bus.publish(e)
+                    summary["published"] += 1
+                except Exception:  # noqa: BLE001
+                    pass
+        summary["events"] = events
+        return summary

coord_ingest-0.1.0/src/coord_ingest.egg-info/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: coord-ingest
+Version: 0.1.0
+Summary: Turn open world-signal feeds (quakes, disasters, outbreaks) into africa-coord-bus coordination events — East Africa scoped, MIT, no API keys.
+Author: AfriKaziOS maintainers
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/gabrielmahia/coord-ingest
+Project-URL: Repository, https://github.com/gabrielmahia/coord-ingest
+Keywords: osint,east-africa,coordination,mcp,early-warning,feeds
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: africa-coord-bus>=0.2.0
+Dynamic: license-file
+
+# coord-ingest
+
+Global situational-awareness dashboards ingest hundreds of live feeds and turn them into an actionable picture — but they score the world's Tier-1 countries, and East Africa isn't on that list. The signals that matter here (drought onset, basin flooding, cholera clusters, rift-zone quakes) are in the same public feeds; nothing was turning them into events a regional coordination system could act on.
+
+`coord-ingest` is that missing rail: an MIT-licensed adapter that converts open, key-free world-signal feeds into [`africa-coord-bus`](https://github.com/gabrielmahia/africa-coord-bus) coordination events, **filtered to East Africa**, so the bus can cascade them to the right domains (insurance, crop advisory, water testing, cross-border alerts).
+
+It ingests and normalizes; the bus routes. Clean separation, composable rails.
+
+## What it does
+
+- **Adapters** for public sources — USGS earthquakes, ReliefWeb disasters, GDACS alerts — each mapping raw records to typed `CoordinationEvent`s. Add a feed by adding an adapter.
+- **East-Africa filter** — a signal becomes an event only if it lands in the regional bounding box or names a regional country. Global noise is dropped at ingest.
+- **Offline-capable** — ships with a `SampleAdapter` over bundled fixtures, so the full pipeline (and its tests) run with no network and no API keys.
+- **Feeds the bus, doesn't replace it** — routing, cascading, and cross-border logic stay in `africa-coord-bus`.
+
+## Use it
+
+```bash
+pip install coord-ingest
+```
+
+```python
+from coord_ingest import IngestPipeline, SampleAdapter
+
+# Offline demo — no keys, no network
+summary = IngestPipeline([SampleAdapter()]).run()
+print(summary["collected"], "East Africa events")   # global noise already dropped
+print(summary["by_domain"])                          # {'water': 3, 'health': 1, 'transport': 1}
+
+# With live feeds + the bus:
+# from coord_ingest import USGSQuakeAdapter, GDACSAdapter
+# from africa_coord_bus import EventBus
+# IngestPipeline([USGSQuakeAdapter(), GDACSAdapter()]).run(bus=EventBus(...))
+```
+
+## Why not just fork a dashboard?
+
+The global open-source dashboards that inspired this are AGPL applications. This is deliberately the opposite: a small **MIT library** that produces standard bus events any tool can consume — including a dashboard, if someone wants to build one. Rails, not another train.
+
+## IP & Collaboration
+
+MIT. New feed adapters welcome via GitHub Issues (public, key-free sources, East-Africa relevant). Full policy: [docs/architecture/IP_POLICY.md](docs/architecture/IP_POLICY.md). Security: [SECURITY.md](SECURITY.md).

coord_ingest-0.1.0/src/coord_ingest.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/coord_ingest/__init__.py
+src/coord_ingest/adapters.py
+src/coord_ingest/pipeline.py
+src/coord_ingest.egg-info/PKG-INFO
+src/coord_ingest.egg-info/SOURCES.txt
+src/coord_ingest.egg-info/dependency_links.txt
+src/coord_ingest.egg-info/requires.txt
+src/coord_ingest.egg-info/top_level.txt
+src/coord_ingest/data/sample_feed.json
+tests/test_ingest.py

coord_ingest-0.1.0/src/coord_ingest.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

coord_ingest-0.1.0/src/coord_ingest.egg-info/requires.txt

@@ -0,0 +1 @@
+africa-coord-bus>=0.2.0

coord_ingest-0.1.0/src/coord_ingest.egg-info/top_level.txt

@@ -0,0 +1 @@
+coord_ingest

coord_ingest-0.1.0/tests/test_ingest.py

@@ -0,0 +1,60 @@
+"""Tests: adapters emit valid events, region filter works, pipeline runs offline."""
+from africa_coord_bus.event import CoordinationEvent, EventDomain, EventSeverity
+from coord_ingest import (SampleAdapter, USGSQuakeAdapter, GDACSAdapter,
+                          IngestPipeline, in_east_africa)
+
+
+def test_sample_adapter_emits_events():
+    evs = SampleAdapter().to_events()
+    assert len(evs) == 6
+    assert all(isinstance(e, CoordinationEvent) for e in evs)
+
+
+def test_region_filter_drops_global_noise():
+    pipe = IngestPipeline([SampleAdapter()])
+    events = pipe.collect()
+    # 6 fixtures, 1 is London -> must be dropped
+    assert len(events) == 5
+    titles = [e.data["title"] for e in events]
+    assert not any("GLOBAL NOISE" in t for t in titles)
+
+
+def test_region_filter_by_country_and_bbox():
+    e_ke = CoordinationEvent(domain=EventDomain.WATER, event_type="x", source="t",
+                             data={"country": "Kenya"})
+    e_uk = CoordinationEvent(domain=EventDomain.WATER, event_type="x", source="t",
+                             data={"country": "United Kingdom", "lat": 51.5, "lon": -0.1})
+    e_geo = CoordinationEvent(domain=EventDomain.WATER, event_type="x", source="t",
+                              data={"lat": -1.3, "lon": 36.8})  # Nairobi, no country
+    assert in_east_africa(e_ke)
+    assert not in_east_africa(e_uk)
+    assert in_east_africa(e_geo)
+
+
+def test_usgs_adapter_maps_magnitude_to_severity():
+    feature = {"properties": {"place": "near Nairobi", "mag": 6.3},
+               "geometry": {"coordinates": [36.8, -1.3, 10]}}
+    evs = USGSQuakeAdapter(records=[feature]).to_events()
+    assert len(evs) == 1
+    assert evs[0].severity == EventSeverity.ALERT  # 6.0-6.9
+
+
+def test_gdacs_colour_maps_to_severity():
+    rec = {"properties": {"alertlevel": "Red", "eventname": "Cyclone",
+                          "latitude": -6.8, "longitude": 39.2, "country": "Tanzania"}}
+    evs = GDACSAdapter(records=[rec]).to_events()
+    assert evs[0].severity == EventSeverity.CRITICAL
+
+
+def test_pipeline_summary_offline():
+    summary = IngestPipeline([SampleAdapter()]).run()
+    assert summary["collected"] == 5
+    assert "water" in summary["by_domain"]
+    assert summary["published"] == 0  # no bus passed
+
+
+def test_pipeline_survives_a_broken_adapter():
+    class Broken:
+        def to_events(self): raise RuntimeError("feed down")
+    summary = IngestPipeline([Broken(), SampleAdapter()]).run()
+    assert summary["collected"] == 5  # good adapter still ran