synpath 0.1.0__py3-none-any.whl

synpath/engine/eod.py

@@ -0,0 +1,154 @@
+"""End of day: close the books, say what happened, start the next one.
+
+Prediction markets trade almost around the clock, so "end of day" is a
+choice rather than a bell. It is whatever hour the operator names, and what
+it does is bookkeeping, not trading:
+
+1. read the settlements each venue reports and book them, so a resolved
+   market stops counting as an open position;
+2. write the day's report -- realized profit, fees, volume, fills, and the
+   open positions carried into tomorrow, per strategy and per account;
+3. roll the risk day, which is what makes the daily loss limit mean
+   "today" rather than "since the engine started";
+4. journal the report so the next morning's question, "what did we make
+   yesterday", is answered by reading rather than recomputing.
+
+Nothing here cancels or trades. A desk that wants orders pulled at the close
+says so with the kill switch's `cancel` policy, which is a decision, not a
+side effect of a report.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta, timezone
+from decimal import Decimal
+from typing import Any
+
+from ..trading.types import Settlement
+from .engine import Engine
+
+ZERO = Decimal("0")
+
+
+@dataclass(slots=True)
+class DailyReport:
+    """One day, closed."""
+
+    date: str
+    started_ms: int
+    ended_ms: int
+    realized: Decimal = ZERO
+    fees: Decimal = ZERO
+    volume: Decimal = ZERO
+    fills: int = 0
+    settlements: int = 0
+    settled_realized: Decimal = ZERO
+    by_book: dict[str, dict[str, str]] = field(default_factory=dict)
+    by_account: dict[str, dict[str, str]] = field(default_factory=dict)
+    open_positions: list[dict[str, Any]] = field(default_factory=list)
+    unrealized: Decimal | None = None
+    marked: int = 0
+    unmarked: int = 0
+
+    def summary(self) -> dict[str, Any]:
+        return {
+            "date": self.date, "realized": str(self.realized), "fees": str(self.fees), "volume": str(self.volume),
+            "fills": self.fills, "settlements": self.settlements, "settled_realized": str(self.settled_realized),
+            "unrealized": str(self.unrealized) if self.unrealized is not None else None,
+            "open_positions": len(self.open_positions), "marked": self.marked, "unmarked": self.unmarked,
+            "by_book": self.by_book, "by_account": self.by_account,
+        }
+
+
+class EndOfDay:
+    """Runs the close, on demand or on a timer."""
+
+    def __init__(self, engine: Engine, *, hour_utc: int = 0, minute_utc: int = 5):
+        self.engine = engine
+        self.hour_utc = hour_utc
+        self.minute_utc = minute_utc
+
+    async def run(self, *, date: str | None = None, book_settlements: bool = True) -> DailyReport:
+        engine = self.engine
+        started = int(engine.clock() * 1000)
+        day = date or datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        report = DailyReport(date=day, started_ms=started, ended_ms=started)
+
+        if book_settlements:
+            report.settlements, report.settled_realized = await self._settle()
+
+        since = engine.risk.day_start_ms
+        for fill in await engine.journal.fills(since_ts=since):
+            report.fills += 1
+            report.volume += fill.amount
+            report.fees += fill.fee or ZERO
+
+        marks = engine.fair_values.marks()
+        for level, target in (("book", report.by_book), ("account", report.by_account)):
+            for key, row in engine.ledger.rollup(level, marks).items():  # type: ignore[arg-type]
+                target[key] = {
+                    "realized": str(row.realized), "unrealized": str(row.unrealized) if row.unrealized is not None else "",
+                    "fees": str(row.fees), "volume": str(row.volume), "open_positions": str(row.positions),
+                }
+        total = engine.ledger.total(marks)
+        report.realized = total.realized
+        report.unrealized = total.unrealized
+        for state in engine.ledger.open_positions():
+            mark = marks.get((state.account_key, state.market_id))
+            report.marked += 1 if mark is not None else 0
+            report.unmarked += 0 if mark is not None else 1
+            report.open_positions.append({
+                "account": state.account_key, "book": state.book, "market_id": state.market_id,
+                "contracts": str(state.contracts), "average_cost": str(state.average_cost),
+                "mark": str(mark) if mark is not None else None,
+            })
+
+        report.ended_ms = int(engine.clock() * 1000)
+        await engine.bus.publish("eod.report", report.summary(), key=day)
+        engine.risk.roll_day(realized_now=total.realized)
+        await engine.journal.set_cursor("eod:last", day)
+        return report
+
+    async def _settle(self) -> tuple[int, Decimal]:
+        """Book every settlement the venues report since the last close."""
+        booked, realized = 0, ZERO
+        for venue, adapter in self.engine.adapters.items():
+            if not adapter.has.get("fetch_settlements"):
+                continue
+            since = int(await self.engine.journal.cursor(f"settlements:{venue}", 0) or 0)
+            try:
+                settlements = await adapter.fetch_settlements(since=since or None, limit=500)
+            except Exception:
+                continue
+            newest = since
+            for settlement in settlements:
+                newest = max(newest, settlement.timestamp or 0)
+                realized += self.engine.ledger.apply_settlement(settlement)
+                await self.engine.bus.publish("settlement.booked", settlement.model_dump(mode="json"),
+                                              key=f"{venue}:{settlement.market_id}")
+                booked += 1
+            if newest > since:
+                await self.engine.journal.set_cursor(f"settlements:{venue}", newest)
+        return booked, realized
+
+    def seconds_until_next(self, *, now: float | None = None) -> float:
+        """How long until the next close, for a caller scheduling it."""
+        stamp = datetime.fromtimestamp(now if now is not None else self.engine.clock(), tz=timezone.utc)
+        target = stamp.replace(hour=self.hour_utc, minute=self.minute_utc, second=0, microsecond=0)
+        if target <= stamp:
+            target += timedelta(days=1)
+        return (target - stamp).total_seconds()
+
+    async def loop(self) -> None:
+        """Run the close every day at the configured hour."""
+        import asyncio
+
+        while self.engine.running:
+            await asyncio.sleep(self.seconds_until_next())
+            try:
+                await self.run()
+            except Exception:
+                import logging
+
+                logging.getLogger("synpath.engine").exception("synpath.engine: the daily close failed")

synpath/engine/events.py

@@ -0,0 +1,140 @@
+"""The engine's event bus: one stream, many readers, replayable.
+
+Everything the engine does becomes an event: an order accepted, a fill
+booked, a risk rule refusing, a halt, a reconciliation finding an order
+nobody asked for. Strategies, the server and the operator all read the same
+stream, so what a user sees in a dashboard is what the journal recorded.
+
+Two properties matter more than speed:
+
+**A slow reader does not stall the engine.** Each subscriber gets its own
+bounded queue. A reader that stops draining loses its oldest events and is
+told how many, rather than blocking order entry behind it.
+
+**The stream survives a restart.** Every event carries the journal sequence
+number it was written under, so a reader that saved its cursor asks for
+`replay(since)` and continues without a gap.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from dataclasses import dataclass, field
+from typing import Any, AsyncIterator, Callable, Iterable
+
+from .journal import Journal
+
+log = logging.getLogger("synpath.engine")
+
+
+@dataclass(frozen=True, slots=True)
+class EngineEvent:
+    """One thing that happened. `kind` is a dotted name (`order.accepted`,
+    `risk.rejected`, `reconcile.orphan`), `key` the thing it happened to."""
+
+    kind: str
+    payload: dict[str, Any] = field(default_factory=dict)
+    key: str | None = None
+    ts: int = field(default_factory=lambda: int(time.time() * 1000))
+    seq: int | None = None
+    """The journal sequence number, once it has one."""
+
+    def __str__(self) -> str:
+        return f"{self.kind}({self.key})" if self.key else self.kind
+
+
+class Subscription:
+    """One reader's view of the stream."""
+
+    def __init__(self, bus: "EventBus", *, kinds: tuple[str, ...] | None = None, maxsize: int = 10_000):
+        self.bus = bus
+        self.kinds = kinds
+        self.queue: asyncio.Queue[EngineEvent] = asyncio.Queue(maxsize=maxsize)
+        self.dropped = 0
+
+    def wants(self, event: EngineEvent) -> bool:
+        return not self.kinds or any(event.kind == k or event.kind.startswith(k + ".") for k in self.kinds)
+
+    def offer(self, event: EngineEvent) -> None:
+        if not self.wants(event):
+            return
+        try:
+            self.queue.put_nowait(event)
+        except asyncio.QueueFull:
+            # Drop the oldest: a stalled dashboard must not hold up trading.
+            try:
+                self.queue.get_nowait()
+                self.dropped += 1
+                self.queue.put_nowait(event)
+            except asyncio.QueueEmpty:  # pragma: no cover - raced with the reader
+                pass
+
+    async def __aiter__(self) -> AsyncIterator[EngineEvent]:
+        while True:
+            yield await self.queue.get()
+
+    def close(self) -> None:
+        self.bus.unsubscribe(self)
+
+
+class EventBus:
+    """Publish once, persist once, fan out to every reader."""
+
+    def __init__(self, journal: Journal | None = None, *, persist: bool = True):
+        self.journal = journal
+        self.persist = persist and journal is not None
+        self.subscribers: list[Subscription] = []
+        self.hooks: list[Callable[[EngineEvent], Any]] = []
+        self.published = 0
+
+    def subscribe(self, *kinds: str, maxsize: int = 10_000) -> Subscription:
+        """A reader of the whole stream, or of `kinds` and their children
+        (`subscribe("order")` also gets `order.accepted`)."""
+        sub = Subscription(self, kinds=kinds or None, maxsize=maxsize)
+        self.subscribers.append(sub)
+        return sub
+
+    def unsubscribe(self, sub: Subscription) -> None:
+        if sub in self.subscribers:
+            self.subscribers.remove(sub)
+
+    def on(self, hook: Callable[[EngineEvent], Any]) -> Callable[[EngineEvent], Any]:
+        """Call `hook` for every event. A hook that raises is logged, not fatal."""
+        self.hooks.append(hook)
+        return hook
+
+    async def publish(self, kind: str, payload: dict[str, Any] | None = None, *, key: str | None = None, persist: bool | None = None) -> EngineEvent:
+        event = EngineEvent(kind=kind, payload=payload or {}, key=key)
+        if (self.persist if persist is None else persist) and self.journal is not None:
+            seq = await self.journal.append(kind, payload or {}, key=key)
+            event = EngineEvent(kind=kind, payload=event.payload, key=key, ts=event.ts, seq=seq)
+        self.emit(event)
+        return event
+
+    def emit(self, event: EngineEvent) -> None:
+        """Fan out an event that is already written (or deliberately not)."""
+        self.published += 1
+        for sub in list(self.subscribers):
+            sub.offer(event)
+        for hook in list(self.hooks):
+            try:
+                result = hook(event)
+                if asyncio.iscoroutine(result):
+                    asyncio.get_running_loop().create_task(_guard(result))
+            except Exception:
+                log.exception("synpath.engine: event hook failed on %s", event.kind)
+
+    async def replay(self, since: int = 0, *, kinds: Iterable[str] | None = None) -> AsyncIterator[EngineEvent]:
+        """Events already in the journal, oldest first, for a reader catching up."""
+        if self.journal is None:
+            return
+        async for row in self.journal.replay(since, kinds=kinds):
+            yield EngineEvent(kind=row.kind, payload=row.payload, key=row.key, ts=row.ts, seq=row.seq)
+
+
+async def _guard(coro: Any) -> None:
+    try:
+        await coro
+    except Exception:
+        log.exception("synpath.engine: async event hook failed")

synpath/engine/fair_values.py

@@ -0,0 +1,117 @@
+"""Fair values: the number the engine marks a position at.
+
+A mark is a decision, not a fact, so it is stored rather than computed on
+the fly: per account and instrument, with where it came from and when. The
+ledger marks unrealized profit with it, and later the synthetic order types
+peg to it and the router compares venues with it.
+
+Three sources, in the order the engine prefers them:
+
+* one the caller set, because a desk's own model outranks anything here;
+* the midpoint of a book the engine already has, which is free and honest
+  while the book is tight;
+* the last trade, when a side of the book is empty and a midpoint would be
+  invented.
+
+A mark that nothing has refreshed goes stale. `stale_after_s` decides when,
+and a stale mark is returned as `None` rather than used quietly, so a
+position shows its cost instead of a profit computed from yesterday's price.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from decimal import Decimal
+from typing import Any, Iterable
+
+from .journal import Journal
+
+ZERO = Decimal("0")
+ONE = Decimal("1")
+
+
+@dataclass(frozen=True, slots=True)
+class FairValue:
+    account_key: str
+    market_id: str
+    value: Decimal
+    source: str
+    ts: int
+
+    def stale(self, *, after_s: float, now_ms: int | None = None) -> bool:
+        stamp = now_ms if now_ms is not None else int(time.time() * 1000)
+        return (stamp - self.ts) / 1000 > after_s
+
+
+class FairValues:
+    """Marks per account and instrument, kept in memory and in the journal."""
+
+    def __init__(self, journal: Journal | None = None, *, stale_after_s: float = 300.0, face_value: Decimal = ONE):
+        self.journal = journal
+        self.stale_after_s = stale_after_s
+        self.face_value = face_value
+        self._values: dict[tuple[str, str], FairValue] = {}
+
+    async def load(self) -> None:
+        """Read what the journal has, so a restart does not start blind."""
+        if self.journal is None:
+            return
+        stamp = int(time.time() * 1000)
+        for (account_key, market_id), value in (await self.journal.fair_values()).items():
+            self._values[(account_key, market_id)] = FairValue(account_key, market_id, value, "journal", stamp)
+
+    async def set(self, account_key: str, market_id: str, value: Decimal, *, source: str = "manual", persist: bool = True) -> FairValue:
+        mark = FairValue(account_key, market_id, Decimal(value), source, int(time.time() * 1000))
+        self._values[(account_key, market_id)] = mark
+        if persist and self.journal is not None:
+            await self.journal.set_fair_value(account_key, market_id, mark.value, source=source)
+        return mark
+
+    def get(self, account_key: str, market_id: str) -> Decimal | None:
+        """The mark, or `None` if there is none or it has gone stale."""
+        mark = self._values.get((account_key, market_id))
+        if mark is None or mark.stale(after_s=self.stale_after_s):
+            return None
+        return mark.value
+
+    def entry(self, account_key: str, market_id: str) -> FairValue | None:
+        return self._values.get((account_key, market_id))
+
+    def marks(self) -> dict[tuple[str, str], Decimal]:
+        """Every live mark, in the shape `Ledger.rollup` wants."""
+        stamp = int(time.time() * 1000)
+        return {
+            key: mark.value for key, mark in self._values.items()
+            if not mark.stale(after_s=self.stale_after_s, now_ms=stamp)
+        }
+
+    async def from_book(
+        self,
+        account_key: str,
+        market_id: str,
+        *,
+        bid: Decimal | None = None,
+        ask: Decimal | None = None,
+        last: Decimal | None = None,
+        persist: bool = False,
+    ) -> FairValue | None:
+        """Mark from a book: the midpoint where both sides exist, otherwise the
+        last trade, otherwise the one side there is. `None` when there is
+        nothing to mark with."""
+        if bid is not None and ask is not None and ask >= bid:
+            return await self.set(account_key, market_id, (bid + ask) / 2, source="mid", persist=persist)
+        if last is not None:
+            return await self.set(account_key, market_id, last, source="last", persist=persist)
+        one_side = bid if bid is not None else ask
+        if one_side is not None:
+            return await self.set(account_key, market_id, one_side, source="touch", persist=persist)
+        return None
+
+    async def from_books(self, account_key: str, books: Iterable[tuple[str, Any]], *, persist: bool = False) -> int:
+        """Mark a batch of `(market_id, LocalBook)` from the streaming layer."""
+        marked = 0
+        for market_id, book in books:
+            bid, ask = getattr(book, "best_bid", None), getattr(book, "best_ask", None)
+            if await self.from_book(account_key, market_id, bid=bid, ask=ask, persist=persist):
+                marked += 1
+        return marked

synpath/engine/feeds.py

@@ -0,0 +1,220 @@
+"""Feeds: the venues' streams, wired into a running engine.
+
+The engine decides; it does not listen. Something has to subscribe the
+venues' WebSockets and hand what they say to the engine, or a stop never sees
+a price and a parent never hears that its child filled. That is this module.
+
+Two kinds of stream per venue, and where each one goes:
+
+* **Market data** (books and public prints). Every market a live engine-held
+  order watches is subscribed on its venue's market stream. The stream keeps a
+  `LocalBook` up to date in place; the engine is handed that same object once
+  (`Engine.set_book`) and told about every change (`Engine.on_book`), so a
+  parent always reads the book as the stream last left it. A book the stream
+  has not snapshotted yet, or lost confidence in after a gap, is not `ready`,
+  and parents read it as no book at all.
+* **This account's orders and fills.** Order updates go to `Engine.on_order`,
+  which is how parents learn what their children filled: the venue's order
+  record, one channel, latest overwrites. Fill events go to `Engine.on_fill`,
+  which books them in the ledger and nothing else.
+
+Subscriptions follow the engine: every `sync_interval_s` the markets its live
+parents watch are compared with what is subscribed, and the difference is
+subscribed. A stream that reports `reconcile_required` (a reconnect with
+private channels, a gap it cannot replay) makes the engine poll that venue's
+REST state straight away, rather than waiting for the next poll.
+
+Venues without a stream here are still traded: orders reach the engine
+through its poll loop, only more slowly. That covers the paper venue, which
+delivers its own events, and the Polymarket US exchange API, whose streams are
+gRPC and an optional install.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from typing import Any, Coroutine, Mapping
+
+from .. import ids
+from ..ws.base import BookEvent, FillEvent, OrderEvent, StreamStatusEvent, TradeEvent
+
+log = logging.getLogger("synpath.engine.feeds")
+
+
+@dataclass
+class VenueStreams:
+    """One venue's streams. `private` may be the same object as `market`
+    (Kalshi carries both on one connection) or absent (no credentials)."""
+
+    market: Any | None = None
+    private: Any | None = None
+
+
+def default_streams(adapters: Mapping[str, Any], credentials: Mapping[str, Any]) -> dict[str, VenueStreams]:
+    """The library's own streams for each configured venue that has one.
+    Kalshi and Polymarket US need credentials even for books; Polymarket's
+    books are public and its user stream authenticates through the adapter."""
+    out: dict[str, VenueStreams] = {}
+    for venue, adapter in adapters.items():
+        creds = credentials.get(venue)
+        if venue == "kalshi" and creds is not None:
+            from ..ws.kalshi import KalshiStream
+            stream = KalshiStream(creds)
+            out[venue] = VenueStreams(market=stream, private=stream)
+        elif venue == "polymarket":
+            from ..ws.polymarket import PolymarketMarketStream, PolymarketUserStream
+            out[venue] = VenueStreams(
+                market=PolymarketMarketStream(),
+                private=PolymarketUserStream(trading=adapter) if creds is not None else None,
+            )
+        elif venue == "polymarket_us" and creds is not None:
+            from ..ws.polymarket_us import PolymarketUSMarketStream, PolymarketUSPrivateStream
+            out[venue] = VenueStreams(market=PolymarketUSMarketStream(creds), private=PolymarketUSPrivateStream(creds))
+        else:
+            log.info("synpath.engine.feeds: no stream for %s; its orders reach the engine by polling", venue)
+    return out
+
+
+def _has(stream: Any, capability: str) -> bool:
+    return bool((getattr(stream, "has", None) or {}).get(capability)) and callable(getattr(stream, capability, None))
+
+
+class Feeds:
+    def __init__(self, engine: Any, streams: Mapping[str, VenueStreams], *, sync_interval_s: float = 1.0):
+        self.engine = engine
+        self.streams: dict[str, VenueStreams] = dict(streams)
+        self.sync_interval_s = sync_interval_s
+        self.watching: dict[str, set[str]] = {venue: set() for venue in self.streams}
+        self.dispatched = 0
+        self.closing = False
+
+    def distinct(self) -> list[tuple[str, Any]]:
+        """Every stream object once, with the venue it belongs to."""
+        seen: set[int] = set()
+        out: list[tuple[str, Any]] = []
+        for venue, pair in self.streams.items():
+            for stream in (pair.market, pair.private):
+                if stream is not None and id(stream) not in seen:
+                    seen.add(id(stream))
+                    out.append((venue, stream))
+        return out
+
+    # -- subscribing ----------------------------------------------------------
+
+    async def start(self) -> None:
+        """Start every stream, subscribe this account's orders and fills, and
+        the books every live parent already watches (restored ones included)."""
+        for _, stream in self.distinct():
+            stream.start()
+        for venue, pair in self.streams.items():
+            private = pair.private
+            if private is None:
+                continue
+            for capability in ("watch_orders", "watch_my_trades"):
+                if _has(private, capability):
+                    try:
+                        await getattr(private, capability)()
+                    except Exception as exc:
+                        log.warning("synpath.engine.feeds: %s %s failed: %s", venue, capability, exc)
+        await self.sync()
+
+    def wanted(self) -> dict[str, set[str]]:
+        """Markets live parents watch, by venue, on venues with a market stream."""
+        out: dict[str, set[str]] = {}
+        for market_id in list(self.engine.orders.by_market):
+            if not self.engine.orders.watching(market_id):
+                continue
+            venue, _ = ids.split(market_id)
+            if venue is None or venue not in self.streams or self.streams[venue].market is None:
+                continue
+            out.setdefault(venue, set()).add(market_id)
+        return out
+
+    async def sync(self) -> int:
+        """Subscribe what is wanted and not yet watched. Returns how many."""
+        added = 0
+        for venue, markets in self.wanted().items():
+            new = sorted(markets - self.watching[venue])
+            if not new:
+                continue
+            stream = self.streams[venue].market
+            try:
+                await stream.watch_order_book(new)
+            except Exception as exc:
+                log.warning("synpath.engine.feeds: subscribing %s on %s failed: %s", new, venue, exc)
+                continue
+            self.watching[venue].update(new)
+            for market_id in new:
+                self.register(stream, market_id)
+            added += len(new)
+        return added
+
+    def register(self, stream: Any, market_id: str) -> None:
+        """Hand the engine the stream's own book object for this market."""
+        book = stream.book(market_id)
+        if book is not None and self.engine.books.get(market_id) is not book:
+            self.engine.set_book(market_id, book)
+
+    # -- delivering -----------------------------------------------------------
+
+    async def dispatch(self, venue: str, stream: Any, event: Any) -> None:
+        self.dispatched += 1
+        if isinstance(event, BookEvent):
+            self.register(stream, event.market_id)
+            await self.engine.on_book(event)
+        elif isinstance(event, TradeEvent):
+            await self.engine.on_trade(event)
+        elif isinstance(event, OrderEvent):
+            await self.engine.on_order(event.order)
+        elif isinstance(event, FillEvent):
+            await self.engine.on_fill(event.fill)
+        elif isinstance(event, StreamStatusEvent):
+            if event.reconcile_required and venue in self.engine.adapters:
+                await self.engine.poll(venue)
+            if event.state == "failed":
+                log.error("synpath.engine.feeds: %s %s failed for good: %s", venue, event.stream, event.detail)
+
+    async def pump(self, venue: str, stream: Any) -> None:
+        """Deliver one stream's events until it ends. One bad event is logged
+        and skipped; it does not stop the stream.
+
+        A stream that ends on its own (the venue refused it for good) does not
+        end the pump until the engine stops or the feeds close: a host that
+        waits for the first of its tasks to finish must not take a lost
+        stream for a stopped engine. That venue's orders keep arriving by
+        polling."""
+        async for event in stream:
+            try:
+                await self.dispatch(venue, stream, event)
+            except Exception:
+                log.exception("synpath.engine.feeds: handling a %s event from %s failed", type(event).__name__, venue)
+        if self.closing:
+            return
+        log.warning("synpath.engine.feeds: the %s %s stream ended; that venue is polled until a restart",
+                    venue, getattr(stream, "name", "stream"))
+        while self.engine.running and not self.closing:
+            await asyncio.sleep(1.0)
+
+    async def _sync_loop(self) -> None:
+        while self.engine.running:
+            await asyncio.sleep(self.sync_interval_s)
+            try:
+                await self.sync()
+            except Exception:
+                log.exception("synpath.engine.feeds: sync failed")
+
+    def background(self) -> dict[str, Coroutine[Any, Any, None]]:
+        """The coroutines a host schedules alongside `Engine.background()`."""
+        loops: dict[str, Coroutine[Any, Any, None]] = {"feeds-sync": self._sync_loop()}
+        for venue, stream in self.distinct():
+            loops[f"feed-{venue}-{getattr(stream, 'name', 'stream')}"] = self.pump(venue, stream)
+        return loops
+
+    async def close(self) -> None:
+        self.closing = True
+        for venue, stream in self.distinct():
+            try:
+                await stream.close()
+            except Exception as exc:
+                log.debug("synpath.engine.feeds: closing %s failed: %s", venue, exc)