search-as-code 0.0.1__py3-none-any.whl

search_as_code/adapters/qdrant.py

@@ -0,0 +1,133 @@
+"""Qdrant adapter. ``pip install 'search-as-code[qdrant]'``.
+
+Demonstrates the pattern every real adapter follows: translate the portable
+filter dialect to the backend DSL, convert native distances to larger-is-better
+scores, and declare capabilities honestly.
+"""
+
+from __future__ import annotations
+
+import uuid
+from typing import Any, Optional, Sequence
+
+from .._resilience import DEFAULT_BATCH_SIZE, chunked
+from ..errors import MissingDependencyError
+from ..filters import normalize
+from ..types import Capabilities, Document, Hit, ResultSet
+from .base import VectorStore
+
+_OP_MAP = {"$gt": "gt", "$gte": "gte", "$lt": "lt", "$lte": "lte"}
+
+
+class QdrantStore(VectorStore):
+    backend = "qdrant"
+
+    def __init__(
+        self,
+        collection: str,
+        url: Optional[str] = None,
+        location: Optional[str] = ":memory:",
+        dim: Optional[int] = None,
+        distance: str = "Cosine",
+        batch_size: int = DEFAULT_BATCH_SIZE,
+        **client_kwargs: Any,
+    ):
+        try:
+            from qdrant_client import QdrantClient
+            from qdrant_client.http import models as qm
+        except ImportError as e:  # pragma: no cover - optional dep
+            raise MissingDependencyError("qdrant-client", extra="search-as-code[qdrant]") from e
+        self._qm = qm
+        self._client = QdrantClient(url=url, location=None if url else location, **client_kwargs)
+        self.collection = collection
+        self.batch_size = batch_size
+        self._dim = dim
+        self._distance = distance
+        if dim and not self._client.collection_exists(collection):
+            self._client.create_collection(
+                collection,
+                vectors_config=qm.VectorParams(size=dim, distance=getattr(qm.Distance, distance.upper())),
+            )
+
+    def capabilities(self) -> Capabilities:
+        return Capabilities(dense=True, keyword=False, hybrid=False, metadata_filter=True)
+
+    @staticmethod
+    def _pid(doc_id: str) -> Any:
+        """Qdrant point ids must be unsigned int or UUID. Pass ints through;
+        map arbitrary strings to a deterministic uuid5 (original kept in payload)."""
+        s = str(doc_id)
+        if s.isdigit():
+            return int(s)
+        return str(uuid.uuid5(uuid.NAMESPACE_URL, s))
+
+    def upsert(self, docs: Sequence[Document]) -> None:
+        qm = self._qm
+        points = [
+            qm.PointStruct(id=self._pid(d.id), vector=d.vector,
+                           payload={"text": d.text, "_sac_id": str(d.id), **d.metadata})
+            for d in docs
+            if d.vector is not None
+        ]
+        for batch in chunked(points, self.batch_size):
+            self._client.upsert(self.collection, points=batch)
+
+    def _to_filter(self, flt: Optional[dict]) -> Any:
+        if not flt:
+            return None
+        qm = self._qm
+        must = []
+        for field_name, cond in normalize(flt).items():
+            if field_name.startswith("$"):
+                continue  # nested and/or omitted for brevity in the reference adapter
+            for op, val in cond.items():
+                if op == "$eq":
+                    must.append(qm.FieldCondition(key=field_name, match=qm.MatchValue(value=val)))
+                elif op == "$in":
+                    must.append(qm.FieldCondition(key=field_name, match=qm.MatchAny(any=val)))
+                elif op in _OP_MAP:
+                    must.append(qm.FieldCondition(key=field_name, range=qm.Range(**{_OP_MAP[op]: val})))
+        return qm.Filter(must=must) if must else None
+
+    def query_vector(self, vector, top_k=10, flt=None) -> ResultSet:
+        flt_ = self._to_filter(flt)
+        if hasattr(self._client, "query_points"):  # qdrant-client >= 1.10
+            res = self._client.query_points(
+                self.collection, query=list(vector), limit=top_k,
+                query_filter=flt_, with_payload=True,
+            ).points
+        else:  # older clients
+            res = self._client.search(
+                self.collection, query_vector=list(vector), limit=top_k,
+                query_filter=flt_, with_payload=True,
+            )
+        hits = []
+        for p in res:
+            payload = dict(p.payload or {})
+            text = payload.pop("text", None)
+            did = payload.pop("_sac_id", str(p.id))  # restore the original id
+            hits.append(
+                Hit(
+                    id=did,
+                    score=float(p.score),  # Qdrant cosine similarity: larger is better
+                    document=Document(id=did, text=text, metadata=payload),
+                    store=self.backend,
+                )
+            )
+        return ResultSet(hits)
+
+    def get(self, ids: Sequence[str]) -> list[Document]:
+        recs = self._client.retrieve(self.collection, ids=[self._pid(i) for i in ids], with_payload=True)
+        out = []
+        for r in recs:
+            payload = dict(r.payload or {})
+            text = payload.pop("text", None)
+            did = payload.pop("_sac_id", str(r.id))
+            out.append(Document(id=did, text=text, metadata=payload))
+        return out
+
+    def delete(self, ids: Sequence[str]) -> None:
+        self._client.delete(self.collection, points_selector=[self._pid(i) for i in ids])
+
+    def count(self) -> int:
+        return self._client.count(self.collection).count

search_as_code/adapters/registry.py

@@ -0,0 +1,98 @@
+"""Backend registry — ``connect(backend, **opts)`` returns a uniform store.
+
+Real adapters are imported lazily so their heavy client libraries are only
+required when actually used. Registering a custom backend is one call:
+
+    from search_as_code.adapters import register
+    register("mystore", MyStore)
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from ..errors import BackendNotFoundError
+from .base import VectorStore
+from .memory import MemoryStore
+
+# Lazy factories keep optional deps out of the base install.
+_LAZY: dict[str, Callable[..., VectorStore]] = {}
+
+
+def _load_qdrant(**opts: Any) -> VectorStore:
+    from .qdrant import QdrantStore
+
+    return QdrantStore(**opts)
+
+
+def _load_chroma(**opts: Any) -> VectorStore:
+    from .chroma import ChromaStore
+
+    return ChromaStore(**opts)
+
+
+def _load_pgvector(**opts: Any) -> VectorStore:
+    from .pgvector import PgVectorStore
+
+    return PgVectorStore(**opts)
+
+
+def _load_opensearch(**opts: Any) -> VectorStore:
+    from .opensearch import OpenSearchStore
+
+    return OpenSearchStore(**opts)
+
+
+def _load_faiss(**opts: Any) -> VectorStore:
+    from .faiss_store import FaissStore
+
+    return FaissStore(**opts)
+
+
+def _load_sqlite(**opts: Any) -> VectorStore:
+    from .sqlite_store import SqliteStore
+
+    return SqliteStore(**opts)
+
+
+def _load_nmslib(**opts: Any) -> VectorStore:
+    from .nmslib_store import NmslibStore
+
+    return NmslibStore(**opts)
+
+
+def _load_milvus(**opts: Any) -> VectorStore:
+    from .milvus_store import MilvusStore
+
+    return MilvusStore(**opts)
+
+
+_REGISTRY: dict[str, Callable[..., VectorStore]] = {
+    "memory": MemoryStore,
+    "qdrant": _load_qdrant,
+    "chroma": _load_chroma,
+    "pgvector": _load_pgvector,
+    "opensearch": _load_opensearch,
+    "faiss": _load_faiss,
+    "sqlite": _load_sqlite,
+    "nmslib": _load_nmslib,
+    "milvus": _load_milvus,
+}
+
+
+def register(name: str, factory: Callable[..., VectorStore]) -> None:
+    _REGISTRY[name] = factory
+
+
+def available() -> list[str]:
+    return sorted(_REGISTRY)
+
+
+def connect(backend: str = "memory", **opts: Any) -> VectorStore:
+    try:
+        factory = _REGISTRY[backend]
+    except KeyError:
+        raise BackendNotFoundError(
+            "unknown backend", backend=backend, available=available()
+        ) from None
+    return factory(**opts)

search_as_code/adapters/sqlite_store.py

@@ -0,0 +1,105 @@
+"""SQLite adapter — the "you don't even need a vector DB" reference.
+
+Vectors are stored as float32 BLOBs in an ordinary SQLite table; dense search is
+brute-force cosine in numpy. Persistent, zero-server, stdlib-only. Keyword/regex
+run over the stored text. Proves the primitive API works over a plain SQL store.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from typing import Any, Optional, Sequence
+
+import numpy as np
+
+from ..types import Capabilities, Document, Hit, ResultSet
+from .base import VectorStore
+from .memory import MemoryStore
+
+
+class SqliteStore(VectorStore):
+    backend = "sqlite"
+
+    def __init__(self, dim: int, path: str = ":memory:", **_: Any):
+        self.dim = int(dim)
+        self.db = sqlite3.connect(path)
+        self.db.execute(
+            "CREATE TABLE IF NOT EXISTS docs "
+            "(id TEXT PRIMARY KEY, text TEXT, meta TEXT, vec BLOB)"
+        )
+        self.db.commit()
+        self._mem = MemoryStore()  # keyword/regex + fast doc cache
+        self._mat: Optional[np.ndarray] = None
+        self._ids: list[str] = []
+        self._dirty = True
+
+    def capabilities(self) -> Capabilities:
+        return Capabilities(dense=True, keyword=True, hybrid=True, regex=True,
+                            server_side_embedding=False, native_rerank=False,
+                            metadata_filter=True)
+
+    def upsert(self, docs: Sequence[Document]) -> None:
+        import json
+        rows = []
+        for d in docs:
+            vec = None if d.vector is None else np.asarray(d.vector, dtype=np.float32).tobytes()
+            rows.append((d.id, d.text or "", json.dumps(d.metadata or {}), vec))
+        self.db.executemany("INSERT OR REPLACE INTO docs VALUES (?,?,?,?)", rows)
+        self.db.commit()
+        self._mem.upsert(docs)
+        self._dirty = True
+
+    def _rebuild(self) -> None:
+        self._ids, vecs = [], []
+        for did, blob in self.db.execute("SELECT id, vec FROM docs WHERE vec IS NOT NULL"):
+            self._ids.append(did)
+            vecs.append(np.frombuffer(blob, dtype=np.float32))
+        if vecs:
+            mat = np.vstack(vecs)
+            n = np.linalg.norm(mat, axis=1, keepdims=True)
+            n[n == 0] = 1.0
+            self._mat = mat / n
+        else:
+            self._mat = None
+        self._dirty = False
+
+    def query_vector(self, vector, top_k=10, flt=None) -> ResultSet:
+        if self._dirty:
+            self._rebuild()
+        if self._mat is None:
+            return ResultSet()
+        from ..filters import matches
+        q = np.asarray(vector, dtype=np.float32)
+        q = q / (np.linalg.norm(q) or 1.0)
+        sims = self._mat @ q
+        order = np.argsort(-sims)
+        hits = []
+        for i in order:
+            doc = self._mem._docs.get(self._ids[i])
+            if doc is None or (flt and not matches(doc.metadata, flt)):
+                continue
+            hits.append(Hit(id=self._ids[i], score=float(sims[i]), document=doc, store=self.backend))
+            if len(hits) >= top_k:
+                break
+        return ResultSet(hits)
+
+    def query_keyword(self, text, top_k=10, flt=None) -> ResultSet:
+        return self._mem.query_keyword(text, top_k=top_k, flt=flt)
+
+    def query_regex(self, pattern, top_k=10, flt=None) -> ResultSet:
+        return self._mem.query_regex(pattern, top_k=top_k, flt=flt)
+
+    def query_hybrid(self, vector, text, top_k=10, flt=None, alpha=0.5) -> ResultSet:
+        dense = self.query_vector(vector, top_k=top_k * 4, flt=flt)
+        kw = self.query_keyword(text, top_k=top_k * 4, flt=flt)
+        from ..primitives import fuse
+        return fuse([dense, kw], weights=[alpha, 1 - alpha]).top(top_k)
+
+    def get(self, ids: Sequence[str]) -> list[Document]:
+        return self._mem.get(ids)
+
+    def count(self) -> int:
+        return self.db.execute("SELECT COUNT(*) FROM docs").fetchone()[0]
+
+    def close(self) -> None:
+        self.db.close()

search_as_code/embeddings.py

@@ -0,0 +1,155 @@
+"""Embedding strategy is bring-your-own by default.
+
+Pass any callable ``list[str] -> list[list[float]]`` (or an object with an
+``embed`` method) wherever an embedder is accepted.  Optional thin wrappers for
+common providers are lazy-imported so the base install stays light.
+
+``HashEmbedder`` is a dependency-free, deterministic embedder used by the
+in-memory adapter, tests, and examples so the whole harness runs with no API
+key.  It is *not* semantically meaningful — swap in a real provider for quality.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import math
+from typing import Callable, Protocol, Sequence, runtime_checkable
+
+from .errors import ConfigurationError, InvalidEmbedderError, MissingDependencyError
+
+
+@runtime_checkable
+class Embedder(Protocol):
+    def embed(self, texts: Sequence[str]) -> list[list[float]]: ...
+
+
+def as_embedder(obj: "Embedder | Callable[[Sequence[str]], list[list[float]]]") -> Embedder:
+    """Coerce a plain callable into the :class:`Embedder` protocol."""
+    if isinstance(obj, Embedder):
+        return obj
+    if callable(obj):
+        return _CallableEmbedder(obj)
+    raise InvalidEmbedderError(
+        "embedder must be an Embedder or a callable(list[str]) -> vectors",
+        got=type(obj).__name__,
+    )
+
+
+class _CallableEmbedder:
+    def __init__(self, fn: Callable[[Sequence[str]], list[list[float]]]):
+        self._fn = fn
+
+    def embed(self, texts: Sequence[str]) -> list[list[float]]:
+        return self._fn(texts)
+
+
+class HashEmbedder:
+    """Deterministic hashing embedder — zero dependencies, no network.
+
+    Uses hashed token bucketing (a poor-man's bag-of-words) so that texts
+    sharing tokens land near each other.  Good enough to exercise the full
+    retrieval path in tests and demos.
+    """
+
+    def __init__(self, dim: int = 256):
+        self.dim = dim
+
+    def embed(self, texts: Sequence[str]) -> list[list[float]]:
+        return [self._one(t) for t in texts]
+
+    def _one(self, text: str) -> list[float]:
+        vec = [0.0] * self.dim
+        for tok in _tokenize(text):
+            h = int.from_bytes(hashlib.blake2b(tok.encode(), digest_size=8).digest(), "big")
+            idx = h % self.dim
+            sign = 1.0 if (h >> 8) & 1 else -1.0
+            vec[idx] += sign
+        norm = math.sqrt(sum(v * v for v in vec)) or 1.0
+        return [v / norm for v in vec]
+
+
+def _tokenize(text: str) -> list[str]:
+    return [t for t in "".join(c.lower() if c.isalnum() else " " for c in text).split() if t]
+
+
+def get_embedder(provider: str, **kwargs) -> Embedder:
+    """Factory for optional built-in providers (lazy-imported)."""
+    provider = provider.lower()
+    if provider in ("hash", "test"):
+        return HashEmbedder(**kwargs)
+    if provider == "openai":
+        return _OpenAIEmbedder(**kwargs)
+    if provider in ("transformers", "hf", "sentence-transformers"):
+        return _TransformersEmbedder(**kwargs)
+    raise ConfigurationError("unknown embedding provider", provider=provider)
+
+
+class _TransformersEmbedder:
+    """Robust loader for HF ``transformers`` embedding models — including custom GTE-v1.5 /
+    ``model_type="new"`` models whose meta-device init corrupts non-persistent buffers
+    (``position_ids``, rotary ``cos_cached``/``sin_cached``) and causes a GPU device-assert
+    or NaN outputs. Fixes: load with ``low_cpu_mem_usage=False``, disable the memory-efficient
+    ``unpad`` attention path, and re-materialize those buffers ON THE MODEL DEVICE.
+
+        emb = get_embedder("transformers", model="my/custom-gte", pooling="cls")
+        vecs = emb.embed(["a query"])
+    """
+
+    def __init__(self, model: str, device: str | None = None, pooling: str = "cls",
+                 max_length: int = 512, token: str | None = None, trust_remote_code: bool = True):
+        import torch
+        from transformers import AutoConfig, AutoModel, AutoTokenizer
+        self._torch = torch
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        self.pooling = pooling
+        self.max_length = max_length
+        conf = AutoConfig.from_pretrained(model, trust_remote_code=trust_remote_code, token=token)
+        for attr in ("unpad_inputs", "use_memory_efficient_attention"):
+            if hasattr(conf, attr):
+                setattr(conf, attr, False)
+        self.tok = AutoTokenizer.from_pretrained(model, token=token)
+        self.model = AutoModel.from_pretrained(
+            model, config=conf, trust_remote_code=trust_remote_code,
+            low_cpu_mem_usage=False, token=token).to(self.device).eval()
+        self._fix_meta_buffers(conf)
+
+    def _fix_meta_buffers(self, conf) -> None:
+        torch, dev = self._torch, self.device
+        maxp = getattr(conf, "max_position_embeddings", 512)
+        for m in self.model.modules():
+            if hasattr(m, "position_ids"):
+                m.register_buffer("position_ids", torch.arange(maxp, device=dev), persistent=False)
+            if hasattr(m, "cos_cached") and hasattr(m, "inv_freq"):
+                L = int(m.cos_cached.shape[0])
+                t = torch.arange(L, dtype=torch.float32, device=dev)
+                freqs = torch.outer(t, m.inv_freq.float().to(dev))
+                emb = torch.cat((freqs, freqs), dim=-1)
+                m.register_buffer("cos_cached", emb.cos(), persistent=False)
+                m.register_buffer("sin_cached", emb.sin(), persistent=False)
+
+    def embed(self, texts: Sequence[str]) -> list[list[float]]:
+        torch = self._torch
+        out = []
+        for text in texts:
+            enc = self.tok(text, return_tensors="pt", truncation=True, max_length=self.max_length)
+            enc = {k: v.to(self.device) for k, v in enc.items()}
+            with torch.no_grad():
+                h = self.model(**enc).last_hidden_state
+            v = h[:, 0] if self.pooling == "cls" else h.mean(dim=1)
+            v = torch.nn.functional.normalize(v, p=2, dim=-1)
+            out.append(v[0].detach().cpu().tolist())
+        return out
+
+
+class _OpenAIEmbedder:
+    def __init__(self, model: str = "text-embedding-3-small", **client_kwargs):
+        try:
+            from openai import OpenAI
+        except ImportError as e:  # pragma: no cover - optional dep
+            raise MissingDependencyError("openai", extra="search-as-code[providers]") from e
+        self._client = OpenAI(**client_kwargs)
+        self._model = model
+
+    def embed(self, texts: Sequence[str]) -> list[list[float]]:  # pragma: no cover - network
+        resp = self._client.embeddings.create(model=self._model, input=list(texts))
+        return [d.embedding for d in resp.data]

search_as_code/errors.py

@@ -0,0 +1,145 @@
+"""Typed exceptions with stable error codes.
+
+Every error the SDK raises is a :class:`SacError` carrying a stable string
+``.code`` (e.g. ``"E_INVALID_FILTER"``) for programmatic handling, logging, and
+metrics. Each subclass *also* inherits from the built-in exception that best
+matches its meaning (``ValueError`` / ``TypeError`` / ``RuntimeError`` /
+``ImportError``), so existing ``except ValueError:`` handlers — and code written
+before this hierarchy existed — keep working unchanged.
+
+    try:
+        sac.connect("nope")
+    except sac.BackendNotFoundError as e:
+        log.warning("bad backend", code=e.code, **e.context)
+    except ValueError:
+        ...   # still catches it (back-compat)
+
+Codes are stable identifiers; the human message may change, the code should not.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class SacError(Exception):
+    """Base class for every error raised by search-as-code.
+
+    Carries a stable ``code`` and an optional structured ``context`` dict so
+    callers can branch on the code and log the details without parsing strings.
+    """
+
+    code: str = "E_SAC"
+
+    def __init__(self, message: str = "", **context: Any):
+        self.context: dict[str, Any] = context
+        if context:
+            detail = ", ".join(f"{k}={v!r}" for k, v in context.items())
+            message = f"{message} ({detail})" if message else detail
+        self.message = message
+        super().__init__(message)
+
+    def __str__(self) -> str:  # keep the code visible in tracebacks/logs
+        base = super().__str__()
+        return f"[{self.code}] {base}" if base else f"[{self.code}]"
+
+
+# ---- configuration / wiring --------------------------------------------------
+class ConfigurationError(SacError, ValueError):
+    """The harness was set up incorrectly (bad backend, provider, options)."""
+
+    code = "E_CONFIG"
+
+
+class BackendNotFoundError(ConfigurationError):
+    """``connect(backend)`` was given an unknown backend name."""
+
+    code = "E_BACKEND_NOT_FOUND"
+
+
+class MissingDependencyError(SacError, ImportError):
+    """An optional dependency for a backend/provider is not installed."""
+
+    code = "E_MISSING_DEPENDENCY"
+
+    def __init__(self, package: str, extra: str | None = None, **context: Any):
+        hint = f"pip install '{extra}'" if extra else f"pip install {package}"
+        self.package = package
+        self.extra = extra
+        super().__init__(
+            f"optional dependency {package!r} is not installed; {hint}", **context
+        )
+
+
+# ---- bad arguments -----------------------------------------------------------
+class InvalidArgumentError(SacError, ValueError):
+    """A user-supplied argument is out of range or the wrong shape."""
+
+    code = "E_INVALID_ARGUMENT"
+
+
+class InvalidModeError(InvalidArgumentError):
+    """An unknown search ``mode`` was requested."""
+
+    code = "E_INVALID_MODE"
+
+
+class InvalidFilterError(InvalidArgumentError):
+    """A metadata filter used an unknown operator or malformed structure."""
+
+    code = "E_INVALID_FILTER"
+
+
+class DimensionMismatchError(InvalidArgumentError):
+    """A vector's dimensionality does not match the store/embedder's."""
+
+    code = "E_DIMENSION_MISMATCH"
+
+
+class InvalidEmbedderError(SacError, TypeError):
+    """``embedder`` is neither an :class:`Embedder` nor a callable."""
+
+    code = "E_INVALID_EMBEDDER"
+
+
+# ---- missing pluggable callables ---------------------------------------------
+class GeneratorRequiredError(SacError, RuntimeError):
+    """A query-side primitive needs an LLM ``generator`` but none was supplied."""
+
+    code = "E_GENERATOR_REQUIRED"
+
+
+class ExtractorRequiredError(SacError, RuntimeError):
+    """``extract()`` needs an ``extractor`` callable but none was supplied."""
+
+    code = "E_EXTRACTOR_REQUIRED"
+
+
+# ---- runtime / backend failures ----------------------------------------------
+class EmbeddingError(SacError, RuntimeError):
+    """The embedder failed or returned a malformed result."""
+
+    code = "E_EMBEDDING"
+
+
+class BackendError(SacError, RuntimeError):
+    """A backend call failed (after any retries) — network, timeout, or server."""
+
+    code = "E_BACKEND"
+
+
+__all__ = [
+    "SacError",
+    "ConfigurationError",
+    "BackendNotFoundError",
+    "MissingDependencyError",
+    "InvalidArgumentError",
+    "InvalidModeError",
+    "InvalidFilterError",
+    "DimensionMismatchError",
+    "InvalidEmbedderError",
+    "GeneratorRequiredError",
+    "ExtractorRequiredError",
+    "EmbeddingError",
+    "BackendError",
+]

search_as_code/explore/__init__.py

@@ -0,0 +1,31 @@
+"""``sac.explore`` — the corpus **exploration / onboarding phase**.
+
+Run once when SAC is installed against a corpus. It samples the data, profiles it
+(schema + content-type mix + LLM characterization), and — as later stages land —
+induces a domain ontology, generates synthetic queries, trains a primitive router,
+and mines templates/few-shots. Everything it learns is written to a versioned
+:class:`ProfilePack` that a ``Session`` loads at query time.
+
+    import search_as_code as sac
+    s = sac.Session("opensearch", index="docs", ...)
+    pack = sac.explore(s, out="docs_pack/")     # onboarding
+    print(pack.report())
+
+The pipeline is resumable (each stage writes its own artifact), drift-aware (re-runs
+when the corpus fingerprint changes), and validate-before-keep (a tuning is kept only
+if it beats baseline).
+"""
+
+from .engine import ExploreContext, Stage, corpus_fingerprint, default_pipeline, explore
+from .pack import ProfilePack
+from .report import write_csv_report
+
+__all__ = [
+    "explore",
+    "ProfilePack",
+    "Stage",
+    "ExploreContext",
+    "default_pipeline",
+    "corpus_fingerprint",
+    "write_csv_report",
+]