fleetmesh-node 0.2.0__py3-none-any.whl

node/planes/store/blob_wire/core.py

@@ -0,0 +1,359 @@
+"""The blob_wire compartment: serve pulls for what this node holds, take
+offers within the operator's caps, drop replicas when the grant ends.
+"""
+from __future__ import annotations
+
+import base64
+import hashlib
+from typing import Any, Callable, Mapping, Optional
+
+from node.compartment import stores as st
+from node.channels import Channel, INFO, TROUBLE
+from node.metrics import COUNTER, Metric
+from node.config import BlobWireConfig
+from node.config.parameter import Parameter
+from node.compartment import Command, Handler, Need, Outbound, WireProtocol
+from .client import TransportBlobClient
+from .intake import IntakeStore
+from .messages import (CAP_DEFAULTS, DEFAULT_CHUNK_BYTES, HTTP_SCHEMES, MAX_CHUNK_BYTES, PIURI, PULL_TIMEOUT, blossom_url, make_chunk,
+                       make_have, make_pull, make_refuse)
+
+
+class BlobWire(WireProtocol):
+    """Answers have and pull for blobs this node holds; takes offers under policy."""
+
+    name = 'blob_wire'
+    piuris: tuple[str, ...] = (PIURI,)
+    reads = ('blob_wire',)
+    config_cls = BlobWireConfig
+    live = ('blob_wire',)
+    SCHEMA = IntakeStore.SCHEMA
+    STORE_CLS = IntakeStore     # builds its own; the base opens nothing for it (B5)
+    CHANNELS = (
+        Channel('blob_served', 'Blob chunk or have served to peer', level=INFO, say='blob chunk served to peer {peer}', tags=('blob', 'wire')),
+        Channel('offer_refused', 'Blob offer refused under policy', level=TROUBLE, say='blob offer refused from peer {peer}: {reason}', tags=('blob', 'wire')),
+    )
+    METRICS = (
+        Metric(name='blob_wire_chunks_served', description='Times blob chunks were served.', kind=COUNTER, counts='blob_served', tags=('blob', 'wire')),
+        Metric(name='blob_wire_offers_refused', description='Times blob offers were refused.', kind=COUNTER, counts='offer_refused', tags=('blob', 'wire')),
+    )
+    STORES = (
+        st.Store(key='_inflight', description='concurrent blob transfers per peer',
+                 kind=st.TABLE, shape=int, bound=1024, keyed_by='peer', evict=st.LRU),
+    )
+    COMMANDS = (
+        Command(
+            key='held',
+            name='Held Replicas',
+            description='replicas taken over the transport, per peer',
+            tags=('blob_wire', 'held'),
+            parameters=(
+                Parameter(key='peer', name='peer', description='peer pubkey to filter by', type=str, default=None, required=False),
+            ),
+            permission='blob_wire/held',
+            run='cmd_held',
+            reply='{peer: [{sha256, size, at}]}',
+        ),
+        Command(
+            key='drop',
+            name='Drop Peer Replicas',
+            description='drop every replica held for a peer now',
+            tags=('blob_wire', 'drop'),
+            parameters=(
+                Parameter(key='peer', name='peer', description='peer pubkey', type=str, default='', required=True),
+            ),
+            permission='blob_wire/drop',
+            run='cmd_drop',
+            reply='{peer, dropped}',
+        ),
+    )
+
+    HANDLERS = (
+        Handler('have', run='handle_have', reads=('blobs',), doc='answer have with held hashes'),
+        Handler('pull', run='handle_pull', reads=('blobs',), doc='serve requested chunk of held blob'),
+        Handler('offer', run='handle_offer', writes=('blobs',), doc='evaluate offer and pull if accepted'),
+        Handler('chunk', run='handle_chunk', doc='handle unprompted chunk'),
+        Handler('refuse', run='handle_refuse', doc='handle unprompted refuse'),
+    )
+
+    OUTBOUND = (
+        Outbound('have', doc='query peer for held hashes or reply with held hashes'),
+        Outbound('offer', reply=('have', 'refuse'), doc='offer blob to peer'),
+        Outbound('pull', reply=('chunk', 'refuse'), doc='request chunk from peer'),
+        Outbound('chunk', doc='serve chunk bytes to pull requester'),
+        Outbound('refuse', doc='refuse unheld or disallowed pull/offer'),
+    )
+
+    REPLICAS_DB: str = 'blob_replicas.sqlite'
+    NEEDS = (
+        Need('blobs', 'stores.blobs'),
+        Need('transport', 'transport'),
+        Need('db_path', path='REPLICAS_DB'),
+        Need('cfg', 'cfg', getter=True),
+        Need('grants', 'stores.grants'),
+    )
+
+    def __init__(
+        self,
+        blobs: Any,
+        transport: Any,
+        db_path: str,
+        cfg: Callable[[], Mapping[str, Any]],
+        grantees: Optional[Callable[[], list[str]]] = None,
+        clock: Optional[Callable[[], int]] = None,
+        node: Any = None,
+        grants: Optional[Any] = None,
+    ) -> None:
+        super().__init__(node, clock)
+        self.blobs = blobs
+        self.transport = transport
+        self.db = IntakeStore(db_path)
+        self._cfg = cfg
+        if grantees is None and grants is not None:
+            self._grantees = lambda: grants.peers()
+        else:
+            self._grantees = grantees or (lambda: [])
+        self.client = TransportBlobClient(self)
+        self._inflight: st.Table[str, int]
+        self.taken = 0
+        self.dropped = 0
+        self.refused = 0
+        self._closed = False
+
+    # ---- configuration ----------------------------------------------------------------
+    def rc(self) -> BlobWireConfig:
+        """The operator's `blob_wire` block as it is now; it reads live."""
+        return BlobWireConfig.from_dict((self._cfg() or {}).get('blob_wire') or {})
+
+    def settings(self) -> BlobWireConfig:   # the Compartment hook, through the injected cfg
+        return self.rc()
+
+    def cap(self, name: str) -> int:
+        v = getattr(self.rc(), name)
+        return max(0, int(v)) if v is not None else CAP_DEFAULTS[name]
+
+    def chunk_bytes(self) -> int:
+        v = self.rc().chunk_bytes
+        return max(1, min(int(v), MAX_CHUNK_BYTES)) if v is not None else DEFAULT_CHUNK_BYTES
+
+    def accepts(self, peer: str) -> bool:
+        pol = self.rc().accept_from
+        if isinstance(pol, tuple):
+            return peer in pol
+        if pol == 'grantees':
+            return peer in self._grantees()
+        return False
+
+    def why_not(self, peer: str, size: int, now: int) -> Optional[str]:
+        """The first reason an offer from this peer may not be taken, or None."""
+        if not self.accepts(peer):
+            return 'not accepting replicas from this peer'
+        if size > self.cap('max_blob_bytes'):
+            return 'blob larger than max_blob_bytes'
+        if self.db.total_for(peer) + size > self.cap('max_total_bytes'):
+            return 'would exceed max_total_bytes for this peer'
+        if self.db.today(peer, now) + size > self.cap('bytes_per_day'):
+            return 'would exceed bytes_per_day for this peer'
+        if self._inflight.get(peer, 0) >= self.cap('max_concurrent'):
+            return 'max_concurrent pulls already in flight for this peer'
+        return None
+
+    # ---- serving: what I hold, on request ------------------------------------------------
+    def handle_have(self, inbound: Any, sender: str) -> tuple[Any, ...]:
+        m = getattr(inbound, 'message', inbound)
+        peer = str(sender).lower()
+        body = m.get('body', {})
+        held = [h for h in body.get('sha256', []) if self.blobs.has(h)]
+        self.wire_client.reply(inbound, make_have(held), sender=peer)
+        return ('blob_wire', 'have', peer[:16], len(held))
+
+    def handle_pull(self, inbound: Any, sender: str) -> tuple[Any, ...]:
+        return self._serve_pull(inbound, sender)
+
+    def handle_offer(self, inbound: Any, sender: str) -> tuple[Any, ...]:
+        return self._take_offer(inbound, sender)
+
+    def handle_chunk(self, inbound: Any, sender: str) -> tuple[Any, ...]:
+        return ('ignored', 'chunk')
+
+    def handle_refuse(self, inbound: Any, sender: str) -> tuple[Any, ...]:
+        return ('ignored', 'refuse')
+
+    def _serve_pull(self, inbound: Any, sender: str) -> tuple[Any, ...]:
+        m = getattr(inbound, 'message', inbound)
+        peer = str(sender).lower()
+        body = m['body']
+        h = str(body['sha256']).lower()
+        data = self.blobs.get(h)
+        if data is None:
+            self.wire_client.reply(inbound, make_refuse(h, 'not held'), sender=peer)
+            return ('blob_wire', 'pull refused', peer[:16], h[:16], 'not held')
+        off, ln = int(body['offset']), int(body['length'])
+        if off < 0 or ln <= 0 or off > len(data):
+            self.wire_client.reply(inbound, make_refuse(h, 'range out of bounds'), sender=peer)
+            return ('blob_wire', 'pull refused', peer[:16], h[:16], 'range')
+        ln = min(ln, self.chunk_bytes())
+        self.wire_client.reply(inbound, make_chunk(h, off, data[off:off + ln]), sender=peer)
+        return ('blob_wire', 'chunk', peer[:16], h[:16], off)
+
+    # ---- taking: the receiver's pull loop ---------------------------------------------------
+    def _take_offer(self, inbound: Any, sender: str) -> tuple[Any, ...]:
+        m = getattr(inbound, 'message', inbound)
+        peer = str(sender).lower()
+        body = m['body']
+        h = str(body['sha256']).lower()
+        size = int(body['size'])
+        now = self.clock()
+        if self.blobs.has(h):
+            # Already here, whoever brought it. Say so; pin it for this peer too.
+            self.blobs.pin(h)
+            if not self.db.holds(h):
+                self.db.took(h, peer, 0, now)
+            self.wire_client.reply(inbound, make_have([h]), sender=peer)
+            return ('blob_wire', 'already held', peer[:16], h[:16])
+        why = self.why_not(peer, size, now)
+        if why is not None:
+            self.refused += 1
+            self.refusals.refuse('blob_wire', 'offer refused', subject=peer, detail={'blob': h[:16], 'why': why}, at=now)
+            self.wire_client.reply(inbound, make_refuse(h, why), sender=peer)
+            return ('blob_wire', 'offer refused', peer[:16], h[:16], why)
+        chunk = max(1, min(int(body.get('chunk_bytes', DEFAULT_CHUNK_BYTES)), self.chunk_bytes()))
+        self._inflight[peer] = self._inflight.get(peer, 0) + 1
+        try:
+            data = self._pull(peer, h, size, chunk)
+        except Exception as e:
+            why = '%s: %s' % (type(e).__name__, str(e)[:120])
+            self.refused += 1
+            self.refusals.refuse('blob_wire', 'pull failed', subject=peer, detail={'blob': h[:16], 'why': why}, at=now)
+            self.wire_client.reply(inbound, make_refuse(h, why), sender=peer)
+            return ('blob_wire', 'pull failed', peer[:16], h[:16], why)
+        finally:
+            self._inflight[peer] -= 1
+            if self._inflight[peer] <= 0:
+                self._inflight.pop(peer, None)
+        self.blobs.put(data, content_type=str(body.get('type') or 'application/octet-stream'),
+                       uploaded_by='replica:' + peer, now=now)
+        self.blobs.pin(h)
+        self.db.took(h, peer, size, now)
+        self.taken += 1
+        self.wire_client.reply(inbound, make_have([h]), sender=peer)
+        return ('blob_wire', 'took', peer[:16], h[:16], size)
+
+    def _pull(self, peer: str, h: str, size: int, chunk: int) -> bytes:
+        hasher = hashlib.sha256()
+        out = bytearray()
+        off = 0
+        while off < size:
+            want = min(chunk, size - off)
+            reply = self.wire_client.request(peer, make_pull(h, off, want), timeout=PULL_TIMEOUT)
+            if reply is None:
+                raise TimeoutError('no chunk at offset %d' % off)
+            rm = reply.message
+            k = self.wire_client.kind_of(rm)
+            if k == 'refuse':
+                raise ValueError('source refused: %s' % rm.get('body', {}).get('why', '?'))
+            if k != 'chunk':
+                raise ValueError('expected chunk, got %s' % (k or rm.get('type')))
+            rb = rm['body']
+            if str(rb.get('sha256', '')).lower() != h or int(rb.get('offset', -1)) != off:
+                raise ValueError('chunk for the wrong blob or offset')
+            piece = base64.b64decode(rb['data'], validate=True)
+            if not piece or len(piece) > want:
+                raise ValueError('chunk of the wrong size at offset %d' % off)
+            hasher.update(piece)
+            out += piece
+            off += len(piece)
+        if hasher.hexdigest() != h:
+            raise ValueError('sha256 mismatch after %d bytes' % off)
+        return bytes(out)
+
+    # ---- the compartment contract ---------------------------------------------------------------
+    def drop_peer(self, peer: str, now: Optional[int] = None) -> Mapping[str, Any]:
+        """Let go of every replica held for a peer: unpin, delete, forget."""
+        peer = peer.lower()
+        gone = self.db.forget_peer(peer)
+        for h in gone:
+            try:
+                self.blobs.unpin(h)
+                stat = self.blobs.stat(h)
+                if stat and str(stat.get('uploaded_by') or '') == 'replica:' + peer:
+                    self.blobs.delete(h)
+            except Exception:
+                pass
+        self.dropped += len(gone)
+        return {'peer': peer, 'dropped': len(gone)}
+
+    def tick(self, now: int) -> list[tuple[Any, ...]]:
+        did: list[tuple[Any, ...]] = []
+        if self._closed:
+            return did
+        live = set(self._grantees())
+        for peer in self.db.peers():
+            if peer not in live:
+                r = self.drop_peer(peer, now)
+                if r['dropped']:
+                    did.append(('blob_wire', 'grant ended, dropped', peer[:16], r['dropped']))
+        self.db.prune_days(now)
+        return did
+
+    def state(self) -> Mapping[str, Any]:
+        if self._closed:
+            return {'stopped': True, 'taken': self.taken, 'dropped': self.dropped, 'refused': self.refused}
+        peers = self.db.peers()
+        pol = self.rc().accept_from
+        return {'accept_from': list(pol) if isinstance(pol, tuple) else pol,
+                'caps': {k: self.cap(k) for k in CAP_DEFAULTS},
+                'peers': len(peers),
+                'held_bytes': sum(self.db.total_for(p) for p in peers),
+                'inflight': dict(self._inflight),
+                'taken': self.taken, 'dropped': self.dropped, 'refused': self.refused}
+
+    def trouble(self) -> list[str]:
+        if self._closed:
+            return []
+        pol = self.rc().accept_from
+        if pol != 'none' and pol and not all(self.cap(k) for k in ('bytes_per_day', 'max_blob_bytes', 'max_total_bytes')):
+            return ['blob_wire.accept_from is set but a cap is 0, so every offer is refused: '
+                    'set bytes_per_day, max_blob_bytes, max_total_bytes and max_concurrent']
+        return []
+
+    def cmd_held(self, args: Mapping[str, Any]) -> Mapping[str, Any]:
+        peers = [str(args['peer']).lower()] if args.get('peer') else self.db.peers()
+        return {p: self.db.held_for(p) for p in peers}
+
+    def cmd_drop(self, args: Mapping[str, Any]) -> Mapping[str, Any]:
+        return self.drop_peer(str(args['peer']))
+
+    def stop(self) -> Any:
+        self._closed = True
+        try:
+            self.db.close()
+        except Exception:
+            pass
+        super().stop()
+        return None
+
+
+def partner_transport_peers(node: Any) -> list[str]:
+    """`peer:<pk>` for every grantee that has no Blossom URL in its descriptor.
+
+    Peers with an HTTP endpoint take the Blossom path; this is for the rest.
+    """
+    out: list[str] = []
+    grants = getattr(node, 'grants', None)
+    peers = getattr(node, 'peers', None)
+    if grants is None or peers is None:
+        return out
+    for pk in grants.peers():
+        try:
+            d = peers.descriptor(pk)
+        except Exception:
+            d = None
+        has_http = False
+        for t in (d or {}).get('tags', []):
+            if t and t[0] == 'endpoint' and len(t) > 2 and t[1] in HTTP_SCHEMES and blossom_url(t[2]):
+                has_http = True
+                break
+        if not has_http:
+            out.append(TransportBlobClient.PREFIX + pk)
+    return out

node/planes/store/blob_wire/intake.py

@@ -0,0 +1,74 @@
+"""What this node has taken from whom: the replica ledger behind the caps."""
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from node.compartment.schema import Column, Index, Table
+from node.storage import SqliteStore
+from .messages import DAY
+
+
+class IntakeStore(SqliteStore):
+    """Replicas taken over the transport and the per-peer, per-day byte count.
+
+    Lives in the same file as blob_replication's ReplicaStore so one operator
+    backup carries both directions of the same fact: what I hold for others
+    and what others hold for me.
+    """
+
+    SCHEMA = (
+        Table('replicas_in', (
+            Column('sha256', 'TEXT', not_null=True),
+            Column('peer', 'TEXT', not_null=True),
+            Column('size', 'INTEGER', not_null=True),
+            Column('at', 'INTEGER', not_null=True),
+        ), primary_key=('sha256', 'peer'), indices=(
+            Index('idx_replicas_in_peer', ('peer',)),
+        )),
+        Table('intake_day', (
+            Column('peer', 'TEXT', not_null=True),
+            Column('day', 'INTEGER', not_null=True),
+            Column('bytes', 'INTEGER', not_null=True),
+        ), primary_key=('peer', 'day')),
+    )
+
+    def took(self, h: str, peer: str, size: int, now: int) -> None:
+        with self.transaction() as cur:
+            cur.execute('INSERT OR REPLACE INTO replicas_in (sha256, peer, size, at) VALUES (?, ?, ?, ?)',
+                        (h, peer, int(size), int(now)))
+            cur.execute('INSERT INTO intake_day (peer, day, bytes) VALUES (?, ?, ?) '
+                        'ON CONFLICT(peer, day) DO UPDATE SET bytes = bytes + excluded.bytes',
+                        (peer, int(now) // DAY, int(size)))
+
+    def holds(self, h: str) -> bool:
+        return self._one('SELECT 1 FROM replicas_in WHERE sha256 = ? LIMIT 1', (h,)) is not None
+
+    def held_for(self, peer: str) -> list[Mapping[str, Any]]:
+        rows = self._all('SELECT sha256, size, at FROM replicas_in WHERE peer = ? ORDER BY at', (peer,))
+        return [{'sha256': r[0], 'size': int(r[1]), 'at': int(r[2])} for r in rows]
+
+    def peers(self) -> list[str]:
+        return [r[0] for r in self._all('SELECT DISTINCT peer FROM replicas_in')]
+
+    def total_for(self, peer: str) -> int:
+        row = self._one('SELECT COALESCE(SUM(size), 0) FROM replicas_in WHERE peer = ?', (peer,))
+        return int(row[0]) if row else 0
+
+    def today(self, peer: str, now: int) -> int:
+        row = self._one('SELECT bytes FROM intake_day WHERE peer = ? AND day = ?', (peer, int(now) // DAY))
+        return int(row[0]) if row else 0
+
+    def forget(self, h: str, peer: str) -> None:
+        with self.transaction() as cur:
+            cur.execute('DELETE FROM replicas_in WHERE sha256 = ? AND peer = ?', (h, peer))
+
+    def forget_peer(self, peer: str) -> list[str]:
+        with self.transaction() as cur:
+            gone = [r['sha256'] for r in self.held_for(peer)]
+            cur.execute('DELETE FROM replicas_in WHERE peer = ?', (peer,))
+            cur.execute('DELETE FROM intake_day WHERE peer = ?', (peer,))
+            return gone
+
+    def prune_days(self, now: int, keep_days: int = 2) -> None:
+        with self.transaction() as cur:
+            cur.execute('DELETE FROM intake_day WHERE day < ?', (int(now) // DAY - keep_days,))

node/planes/store/blob_wire/messages.py

@@ -0,0 +1,85 @@
+"""blob/1.0 on the wire: the protocol URI, the five message kinds, the
+numbers the window fixes (chunk sizes, caps) and the constructors.
+"""
+from __future__ import annotations
+
+import base64
+import uuid
+from typing import Any, Mapping, Optional, TypeVar
+
+from fleetmesh_core.accounting import window
+from fleetmesh_core.wire.wire_types import BlobChunkBody, BlobHaveBody, BlobOfferBody, BlobPullBody, BlobRefuseBody, Message
+
+BlobBody = TypeVar('BlobBody', BlobHaveBody, BlobOfferBody, BlobPullBody, BlobChunkBody, BlobRefuseBody)
+
+PIURI: str = 'https://fleetmesh.org/blob/1.0'
+KINDS: tuple[str, ...] = ('have', 'offer', 'pull', 'chunk', 'refuse')
+
+C: Mapping[str, Any] = window.C['blob_wire']
+DEFAULT_CHUNK_BYTES: int = int(C['chunk_bytes'])         # ~30 FIPS datagrams; a Nostr wrap holds it whole
+MAX_CHUNK_BYTES: int = int(C['max_chunk_bytes'])         # above this, the wrap outgrows relay limits
+MAX_HAVE: int = int(C['max_have'])                       # hashes in one have
+PULL_TIMEOUT: float = float(C['pull_timeout_seconds'])
+DAY: int = 86400
+
+# How a descriptor `endpoint` tag is read as a Blossom base URL. Shared by
+# the Blossom path (blob_replication) and the transport path (core); lives
+# in this leaf so neither side has to import the other to agree on it.
+HTTP_SCHEMES: tuple[str, ...] = ('http', 'https', 'ws', 'wss')
+
+
+def blossom_url(address: str) -> Optional[str]:
+    """An endpoint address as an http(s) Blossom base URL, or None."""
+    a = (address or '').strip().rstrip('/')
+    for pre, rep in (('wss://', 'https://'), ('ws://', 'http://')):
+        if a.startswith(pre):
+            return rep + a[len(pre):]
+    if a.startswith(('http://', 'https://')):
+        return a
+    return None
+
+# What an operator may set under `blob_wire` in the config, and what each
+# means when left alone. Zero is "no bytes" everywhere, not "unlimited".
+CAP_DEFAULTS: dict[str, int] = {
+    'bytes_per_day': int(C['bytes_per_day']),        # per peer, taken over the transport path
+    'max_concurrent': int(C['max_concurrent']),      # pulls in flight per peer
+    'max_blob_bytes': int(C['max_blob_bytes']),      # one blob
+    'max_total_bytes': int(C['max_total_bytes']),    # all replicas held for one peer
+}
+
+# ---- messages -------------------------------------------------------------------
+def _msg(kind: str, body: BlobBody, thid: Optional[str] = None) -> Message[BlobBody]:
+    m: Message[BlobBody] = {'id': str(uuid.uuid4()), 'type': '%s/%s' % (PIURI, kind), 'body': body}
+    if thid:
+        m['thid'] = thid
+    return m
+
+
+def make_have(hashes: list[str], thid: Optional[str] = None) -> Message[BlobHaveBody]:
+    return _msg('have', BlobHaveBody(sha256= [h.lower() for h in hashes[:MAX_HAVE]]), thid)
+
+
+def make_offer(sha256: str, size: int, content_type: str, chunk_bytes: int = DEFAULT_CHUNK_BYTES) -> Message[BlobOfferBody]:
+    return _msg('offer', BlobOfferBody(sha256=sha256.lower(), size=int(size), type=content_type or 'application/octet-stream',
+                                       chunk_bytes=max(1, min(int(chunk_bytes), MAX_CHUNK_BYTES))))
+
+
+def make_pull(sha256: str, offset: int, length: int) -> Message[BlobPullBody]:
+    return _msg('pull', BlobPullBody(sha256=sha256.lower(), offset=int(offset), length=int(length)))
+
+
+def make_chunk(sha256: str, offset: int, data: bytes, thid: Optional[str] = None) -> Message[BlobChunkBody]:
+    return _msg('chunk', BlobChunkBody(sha256=sha256.lower(), offset=int(offset),
+                                       data=base64.b64encode(data).decode('ascii')), thid)
+
+
+def make_refuse(sha256: str, why: str, thid: Optional[str] = None) -> Message[BlobRefuseBody]:
+    return _msg('refuse', BlobRefuseBody(sha256=sha256.lower(), why=why[:200]), thid)
+
+
+def kind_of(message: Mapping[str, Any]) -> Optional[str]:
+    t = str(message.get('type', ''))
+    if not t.startswith(PIURI + '/'):
+        return None
+    k = t[len(PIURI) + 1:]
+    return k if k in KINDS else None

node/planes/store/projected/__init__.py

@@ -0,0 +1,7 @@
+"""Co-transactional SQL projections over MeshStore events and P2Panda causal logs.
+
+One-module compartment: everything is in compartment.py.
+"""
+from .compartment import ProjectedDB, ProjectedDBConfig
+
+__all__ = ['ProjectedDB', 'ProjectedDBConfig']