docdistance 1.0.15__py3-none-any.whl

docdistance/__init__.py

@@ -0,0 +1,38 @@
+from importlib.metadata import PackageNotFoundError, version
+
+from docdistance import config  # noqa: F401  (sets up logging + paths on import)
+from docdistance.distance import (
+    DistanceResult,
+    SourceConditionedResult,
+    closeness,
+    compute_distance,
+    compute_source_conditioned,
+    rwmd,
+    smd,
+    wcd,
+)
+from docdistance.pipeline import (
+    DocDistance,
+    document_distance,
+    source_conditioned_distance,
+)
+
+try:
+    __version__ = version("docdistance")
+except PackageNotFoundError:  # running from source, not installed
+    __version__ = "0.0.0"
+
+__all__ = [
+    "DocDistance",
+    "DistanceResult",
+    "SourceConditionedResult",
+    "document_distance",
+    "source_conditioned_distance",
+    "compute_distance",
+    "compute_source_conditioned",
+    "smd",
+    "wcd",
+    "rwmd",
+    "closeness",
+    "__version__",
+]

docdistance/cli.py

@@ -0,0 +1,229 @@
+"""docdistance command-line interface.
+
+Three subcommands - ``install`` (the only one that downloads models), ``distance`` (symmetric SMD)
+and ``distance-wrt-source`` (source-conditioned). Human output is rich and coloured on a capable
+terminal; ``--json`` emits machine-readable JSON and ``--result-only`` emits the bare result.
+Logs go to stderr (loguru, ``--verbose`` for DEBUG), so stdout carries only the result.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+import json
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+import typer
+
+from docdistance.config import configure_logging
+from docdistance.distance import DEFAULT_THRESHOLD
+
+app = typer.Typer(
+    rich_markup_mode="rich",
+    no_args_is_help=True,
+    add_completion=False,
+    help="[bold]docdistance[/bold] - semantic distance between documents via Statement Mover's Distance "
+    "(optimal transport over mmBERT statement embeddings).",
+)
+
+_out = Console()  # stdout, for the result
+_err = Console(stderr=True)  # stderr, for errors
+
+
+class Backend(str, Enum):
+    openvino = "openvino"
+    torch = "torch"
+
+
+class InstallBackend(str, Enum):
+    openvino = "openvino"
+    torch = "torch"
+    both = "both"
+
+
+def _version_cb(value: bool):
+    if value:
+        from docdistance import __version__
+
+        typer.echo(f"docdistance {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False, "--version", callback=_version_cb, is_eager=True, help="show version and exit"
+    ),
+):
+    """Semantic document distance grounded in optimal-transport theory."""
+
+
+def _run(fn):
+    """Call ``fn`` and turn a missing-model error into a clean message + exit code 1."""
+    from docdistance.encoders import ModelsNotInstalled
+
+    try:
+        return fn()
+    except ModelsNotInstalled as exc:
+        _err.print(f"[bold red]error:[/bold red] {exc}")
+        raise typer.Exit(1)
+
+
+def _emit_distance(r, json_out: bool, result_only: bool) -> None:
+    if result_only:
+        typer.echo(str(r.smd))
+        return
+    if json_out:
+        typer.echo(json.dumps(r.to_dict(), indent=2))
+        return
+    color = "green" if r.verdict == "similar" else "red"
+    grid = Table.grid(padding=(0, 2))
+    grid.add_column(style="bold cyan")
+    grid.add_column()
+    grid.add_row("SMD (distance)", f"{r.smd:.4f}")
+    grid.add_row("closeness", f"{r.closeness * 100:.1f}%")
+    grid.add_row(
+        "verdict", f"[{color}]{r.verdict}[/{color}]  (threshold {r.threshold:.2f} closeness)"
+    )
+    grid.add_row("bounds", f"WCD {r.wcd:.4f}  ≤  RWMD {r.rwmd:.4f}  ≤  SMD {r.smd:.4f}")
+    grid.add_row("statements", f"{r.n_statements_a} vs {r.n_statements_b}")
+    grid.add_row("anisotropy", "on" if r.anisotropy else "off")
+    _out.print(
+        Panel(grid, title="[bold]Document distance[/bold]", border_style=color, expand=False)
+    )
+
+
+def _emit_wrt_source(r, json_out: bool, result_only: bool) -> None:
+    if result_only:
+        typer.echo(f"{r.d_sel},{r.residual_a},{r.residual_b}")
+        return
+    if json_out:
+        typer.echo(json.dumps(r.to_dict(), indent=2))
+        return
+    grid = Table.grid(padding=(0, 2))
+    grid.add_column(style="bold cyan")
+    grid.add_column()
+    grid.add_row("D_sel (selection divergence)", f"{r.d_sel:.4f}")
+    grid.add_row("A → source", f"{r.residual_a:.4f}  (closeness {r.closeness_a * 100:.1f}%)")
+    grid.add_row("B → source", f"{r.residual_b:.4f}  (closeness {r.closeness_b * 100:.1f}%)")
+    grid.add_row(
+        "statements", f"A {r.n_statements_a} / B {r.n_statements_b} / S {r.n_statements_source}"
+    )
+    _out.print(
+        Panel(
+            grid,
+            title="[bold]Source-conditioned distance d(A,B|S)[/bold]",
+            border_style="cyan",
+            expand=False,
+        )
+    )
+    _out.print(
+        "[dim]residual = geometric distance to the source; the reranker + NLI grounding grade and "
+        "numeric verifier are deferred to E02[/dim]"
+    )
+
+
+@app.command(
+    epilog="[bold]Examples[/bold]\n\n"
+    "  docdistance distance report_v1.md report_v2.md\n"
+    '  docdistance distance "first text" "second text" --backend torch\n'
+    "  docdistance distance a.md b.md --json\n"
+    "  docdistance distance a.md b.md --result-only"
+)
+def distance(
+    a: str = typer.Argument(..., help="first document - a file path or raw text"),
+    b: str = typer.Argument(..., help="second document - a file path or raw text"),
+    backend: Backend = typer.Option(
+        Backend.openvino, "--backend", help="statement encoder backend"
+    ),
+    anisotropy: bool = typer.Option(
+        False,
+        "--anisotropy/--no-anisotropy",
+        help="all-but-the-top anisotropy removal - needs a corpus, off by default for a pair",
+    ),
+    threshold: float = typer.Option(
+        DEFAULT_THRESHOLD,
+        "--threshold",
+        help="closeness cutoff for the similar / not-similar verdict",
+    ),
+    json_out: bool = typer.Option(False, "--json", help="machine-readable JSON to stdout"),
+    result_only: bool = typer.Option(
+        False, "--result-only", help="bare SMD scalar to stdout, no clutter"
+    ),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="DEBUG logging to stderr"),
+):
+    """Symmetric distance between two documents - the exact Statement Mover's Distance."""
+    configure_logging(verbose)
+    from docdistance.pipeline import document_distance
+
+    result = _run(
+        lambda: document_distance(
+            a, b, backend=backend.value, anisotropy=anisotropy, threshold=threshold
+        )
+    )
+    _emit_distance(result, json_out, result_only)
+
+
+@app.command(
+    name="distance-wrt-source",
+    epilog="[bold]Examples[/bold]\n\n"
+    "  docdistance distance-wrt-source summary_a.md summary_b.md --source article.md\n"
+    "  docdistance distance-wrt-source a.md b.md -s s.md --json\n"
+    "  docdistance distance-wrt-source a.md b.md -s s.md --result-only   [dim]# D_sel,res_a,res_b[/dim]",
+)
+def distance_wrt_source(
+    a: str = typer.Argument(..., help="first document - a file path or raw text"),
+    b: str = typer.Argument(..., help="second document - a file path or raw text"),
+    source: str = typer.Option(..., "--source", "-s", help="the common source document"),
+    backend: Backend = typer.Option(
+        Backend.openvino, "--backend", help="statement encoder backend"
+    ),
+    anisotropy: bool = typer.Option(
+        False,
+        "--anisotropy/--no-anisotropy",
+        help="anisotropy removal - needs a corpus, off by default",
+    ),
+    json_out: bool = typer.Option(False, "--json", help="machine-readable JSON to stdout"),
+    result_only: bool = typer.Option(
+        False, "--result-only", help="bare comma-separated D_sel,residual_a,residual_b to stdout"
+    ),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="DEBUG logging to stderr"),
+):
+    """Source-conditioned distance d(A, B | S) - selection divergence plus each document's distance to S."""
+    configure_logging(verbose)
+    from docdistance.pipeline import source_conditioned_distance
+
+    result = _run(
+        lambda: source_conditioned_distance(
+            a, b, source, backend=backend.value, anisotropy=anisotropy
+        )
+    )
+    _emit_wrt_source(result, json_out, result_only)
+
+
+@app.command(
+    epilog="[bold]Examples[/bold]\n\n"
+    "  docdistance install               [dim]# both backends[/dim]\n"
+    "  docdistance install --backend openvino",
+)
+def install(
+    backend: InstallBackend = typer.Option(
+        InstallBackend.both, "--backend", help="which encoder weights to fetch"
+    ),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="DEBUG logging to stderr"),
+):
+    """Download and cache the models - the only command that fetches from the Hub (TQDM progress bars)."""
+    configure_logging(verbose)
+    from docdistance.encoders import ModelsNotInstalled, download_models
+
+    try:
+        backends = download_models(backend.value)
+    except ModelsNotInstalled as exc:
+        _err.print(f"[bold red]error:[/bold red] {exc}")
+        raise typer.Exit(1)
+    _out.print(f"[green]models ready:[/green] {', '.join(backends)}")
+
+
+if __name__ == "__main__":
+    app()

docdistance/config.py

@@ -0,0 +1,66 @@
+from pathlib import Path
+import sys
+
+from dotenv import load_dotenv
+from loguru import logger
+
+########### SETUP ###############
+
+# set up logger - INFO by default (DEBUG only via the CLI --verbose flag), sink to stderr so
+# stdout stays clean for --json / --result-only output
+logger.remove()
+logger.add(sys.stderr, colorize=True, level="INFO")
+
+# If tqdm is installed, configure loguru with tqdm.write
+# https://github.com/Delgan/loguru/issues/135
+try:
+    from tqdm import tqdm
+
+    logger.remove()
+    logger.add(lambda msg: tqdm.write(msg, end="", file=sys.stderr), colorize=True, level="INFO")
+except ModuleNotFoundError:
+    pass
+
+########## VARIABLES ############
+
+# Load environment variables from .env file if it exists
+load_dotenv()
+
+# paths
+PROJ_ROOT = Path(__file__).resolve().parents[2]
+DATA_DIR = PROJ_ROOT / "data"
+RAW_DATA_DIR = DATA_DIR / "raw"
+INTERIM_DATA_DIR = DATA_DIR / "interim"
+PROCESSED_DATA_DIR = DATA_DIR / "processed"
+EXTERNAL_DATA_DIR = DATA_DIR / "external"
+MODELS_DIR = PROJ_ROOT / "models"
+REPORTS_DIR = PROJ_ROOT / "reports"
+FIGURES_DIR = REPORTS_DIR / "figures"
+
+# log current root dir (debug so it never pollutes machine-readable stdout)
+logger.debug(f"PROJ_ROOT path is: {PROJ_ROOT}")
+
+########## MODELS ###############
+
+# segmenter (wtpsplit SaT) and the mmBERT statement encoders, by backend
+SAT_MODEL = "sat-3l-sm"
+MMBERT_TORCH_MODEL = "jhu-clsp/mmBERT-base"
+MMBERT_OPENVINO_LOCAL = MODELS_DIR / "02-mmbert-openvino-int8"
+MMBERT_OPENVINO_HF = "stellars/mmBERT-base-openvino-int8"
+
+
+def configure_logging(verbose: bool = False) -> None:
+    """Re-point loguru at stderr at INFO, or DEBUG when ``verbose`` - the CLI calls this first.
+
+    stderr keeps stdout reserved for the result so ``--json`` and ``--result-only`` stay machine-parseable.
+    """
+    level = "DEBUG" if verbose else "INFO"
+    logger.remove()
+    try:
+        from tqdm import tqdm
+
+        logger.add(
+            lambda msg: tqdm.write(msg, end="", file=sys.stderr), colorize=True, level=level
+        )
+    except ModuleNotFoundError:
+        logger.add(sys.stderr, colorize=True, level=level)

docdistance/dataset.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+
+from loguru import logger
+from tqdm import tqdm
+import typer
+
+from docdistance.config import PROCESSED_DATA_DIR, RAW_DATA_DIR
+
+app = typer.Typer()
+
+
+@app.command()
+def main(
+    # ---- REPLACE DEFAULT PATHS AS APPROPRIATE ----
+    input_path: Path = RAW_DATA_DIR / "dataset.csv",
+    output_path: Path = PROCESSED_DATA_DIR / "dataset.csv",
+    # ----------------------------------------------
+):
+    # ---- REPLACE THIS WITH YOUR OWN CODE ----
+    logger.info("Processing dataset...")
+    for i in tqdm(range(10), total=10):
+        if i == 5:
+            logger.info("Something happened for iteration 5.")
+    logger.success("Processing dataset complete.")
+    # -----------------------------------------
+
+
+if __name__ == "__main__":
+    app()

docdistance/distance.py

@@ -0,0 +1,231 @@
+"""Pure-numpy optimal-transport core for document distance.
+
+No heavy ML dependencies - only numpy and POT (``ot``). Segmentation and embedding live in
+``encoders.py``; this module operates on statement-embedding arrays: L2-normalized float32 of
+shape ``[n_statements, dim]``. Every function here is deterministic and CPU-only, which is why
+the unit tests can exercise it without loading a single model.
+
+The distance is the exact Statement Mover's Distance (SMD) - optimal transport between two
+statement clouds with the metric ground cost ``sqrt(2 - 2cos)`` (Euclidean on L2-normalized
+vectors). ``wcd`` and ``rwmd`` are the cheap lower bounds (``WCD <= RWMD <= SMD``). The
+source-conditioned helpers re-base the transport onto a common source ``S``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+
+import numpy as np
+import ot
+
+# orthogonal statement clouds -> closeness 0; cos >= 0 for these embeddings so distance lands in [0, sqrt(2)]
+SMD_MAX = float(np.sqrt(2.0))
+
+# closeness cutoff for the similar / not-similar verdict; heuristic, calibrate per corpus
+# (measured boundary on the ibm-ai-adoption fixtures: min gold 72.7% vs max adversarial 72.2%)
+DEFAULT_THRESHOLD = 0.725
+
+
+def cost_matrix(X: np.ndarray, Y: np.ndarray) -> np.ndarray:
+    """Ground cost ``sqrt(2 - 2cos)`` = Euclidean distance on L2-normalized rows (a metric)."""
+    return ot.dist(X, Y, metric="euclidean")
+
+
+def _uniform(n: int) -> np.ndarray:
+    return np.full(n, 1.0 / n)
+
+
+def _ab(X: np.ndarray, Y: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    return _uniform(len(X)), _uniform(len(Y))
+
+
+def smd(X: np.ndarray, Y: np.ndarray) -> float:
+    """The distance: exact Statement Mover's Distance via the network-simplex LP."""
+    return float(ot.emd2(*_ab(X, Y), cost_matrix(X, Y)))
+
+
+def wcd(X: np.ndarray, Y: np.ndarray) -> float:
+    """Lower bound: distance between the mean-pooled statement clouds (whole-doc cosine)."""
+    return float(np.linalg.norm(X.mean(0) - Y.mean(0)))
+
+
+def rwmd(X: np.ndarray, Y: np.ndarray) -> float:
+    """Lower bound: one-sided relaxation (greedy nearest-statement alignment)."""
+    a, b = _ab(X, Y)
+    C = cost_matrix(X, Y)
+    return float(max((a * C.min(1)).sum(), (b * C.min(0)).sum()))
+
+
+def closeness(d: float) -> float:
+    """Map a distance to a 0-1 similarity: 1 = identical clouds, 0 = orthogonal."""
+    return max(0.0, 1.0 - d / SMD_MAX)
+
+
+def verdict(close: float, threshold: float = DEFAULT_THRESHOLD) -> str:
+    return "similar" if close >= threshold else "not similar"
+
+
+def all_but_the_top(emb: dict[str, np.ndarray], k: int = 1) -> dict[str, np.ndarray]:
+    """All-but-the-top anisotropy removal (Mu & Viswanath, ICLR 2018).
+
+    Subtract the pooled mean and project out the top-``k`` principal components (via SVD of the
+    mean-centered matrix), then re-L2-normalize. De-bunches the anisotropic mmBERT cosines and
+    widens the distance dynamic range while preserving statement ordering. Operates over the
+    pooled statements of all documents in ``emb`` so the common direction is shared.
+    """
+    keys = list(emb)
+    pool = np.concatenate([emb[key] for key in keys], 0)
+    centered = pool - pool.mean(0)
+    _, _, Vt = np.linalg.svd(centered, full_matrices=False)
+    comps = Vt[:k]
+    fixed = centered - centered @ comps.T @ comps
+    fixed = fixed / (np.linalg.norm(fixed, axis=1, keepdims=True) + 1e-9)
+    out: dict[str, np.ndarray] = {}
+    off = 0
+    for key in keys:
+        m = len(emb[key])
+        out[key] = fixed[off : off + m].astype(np.float32)
+        off += m
+    return out
+
+
+# --- source-conditioned core (metric parts only; reranker/NLI grounding deferred to E02) ---
+
+
+COVERAGE_TEMPERATURE = 0.1
+
+
+def coverage_profile(
+    X: np.ndarray, S: np.ndarray, temperature: float = COVERAGE_TEMPERATURE
+) -> np.ndarray:
+    """How document ``X``'s statements distribute over the source statements ``S``; a distribution, sums to 1.
+
+    Each statement softly assigns to source statements by ``softmax(-cost / temperature)`` and the
+    profile is the mean assignment over ``X``. A balanced-OT column marginal is forced uniform (the
+    transport constraint), so it carries no per-document signal; this soft nearest-source histogram
+    varies by document and captures which source content each one covers.
+    """
+    C = cost_matrix(X, S)
+    A = np.exp(
+        -(C - C.min(1, keepdims=True)) / temperature
+    )  # subtract row-min for numerical stability
+    A = A / A.sum(1, keepdims=True)
+    return A.mean(0)
+
+
+def selection_divergence(cov_a: np.ndarray, cov_b: np.ndarray, S: np.ndarray) -> float:
+    """D_sel: metric OT between two coverage profiles over the shared source statements.
+
+    Ground cost is ``sqrt(2 - 2cos)`` on the source-statement embeddings, so D_sel stays a metric -
+    the guarantee conditioning on a fixed ``S`` buys back. Captures same source, different picks.
+    """
+    return float(ot.emd2(np.asarray(cov_a), np.asarray(cov_b), cost_matrix(S, S)))
+
+
+def ungrounded_residual(X: np.ndarray, S: np.ndarray) -> float:
+    """Per-document grounding proxy: the transport cost SMD(X, S) (distance of X to the source).
+
+    A coarse, metric stand-in for the grounding residual - higher means the document drifts
+    further from any source statement. The reranker + NLI grade that separates contradiction from
+    omission is deferred to E02; this is the geometric distance-to-source only.
+    """
+    return smd(X, S)
+
+
+@dataclass
+class DistanceResult:
+    """Symmetric distance result. ``smd`` is the distance; ``wcd``/``rwmd`` bound it below."""
+
+    smd: float
+    wcd: float
+    rwmd: float
+    closeness: float
+    threshold: float
+    verdict: str
+    anisotropy: bool
+    n_statements_a: int
+    n_statements_b: int
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass
+class SourceConditionedResult:
+    """Source-conditioned result: selection divergence plus each document's distance to the source."""
+
+    d_sel: float
+    residual_a: float
+    residual_b: float
+    closeness_a: float
+    closeness_b: float
+    n_statements_a: int
+    n_statements_b: int
+    n_statements_source: int
+    coverage_a: list[float]
+    coverage_b: list[float]
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+def compute_distance(
+    emb_a: np.ndarray,
+    emb_b: np.ndarray,
+    *,
+    anisotropy: bool = False,
+    threshold: float = DEFAULT_THRESHOLD,
+) -> DistanceResult:
+    """Assemble a :class:`DistanceResult` from two statement-embedding arrays.
+
+    ``anisotropy`` is off by default: all-but-the-top estimates the shared direction from a corpus,
+    so over a single document pair it strips genuine shared meaning and distorts the scale. The
+    validated nb04 verdict uses raw embeddings; enable anisotropy only over a pooled corpus.
+    """
+    n_a, n_b = len(emb_a), len(emb_b)
+    if anisotropy:
+        fixed = all_but_the_top({"a": emb_a, "b": emb_b}, k=1)
+        emb_a, emb_b = fixed["a"], fixed["b"]
+    d = smd(emb_a, emb_b)
+    close = closeness(d)
+    return DistanceResult(
+        smd=d,
+        wcd=wcd(emb_a, emb_b),
+        rwmd=rwmd(emb_a, emb_b),
+        closeness=close,
+        threshold=threshold,
+        verdict=verdict(close, threshold),
+        anisotropy=anisotropy,
+        n_statements_a=n_a,
+        n_statements_b=n_b,
+    )
+
+
+def compute_source_conditioned(
+    emb_a: np.ndarray,
+    emb_b: np.ndarray,
+    emb_source: np.ndarray,
+    *,
+    anisotropy: bool = False,
+) -> SourceConditionedResult:
+    """Assemble a :class:`SourceConditionedResult` from A, B and source statement embeddings."""
+    n_a, n_b, n_s = len(emb_a), len(emb_b), len(emb_source)
+    if anisotropy:
+        fixed = all_but_the_top({"a": emb_a, "b": emb_b, "s": emb_source}, k=1)
+        emb_a, emb_b, emb_source = fixed["a"], fixed["b"], fixed["s"]
+    cov_a = coverage_profile(emb_a, emb_source)
+    cov_b = coverage_profile(emb_b, emb_source)
+    res_a = ungrounded_residual(emb_a, emb_source)
+    res_b = ungrounded_residual(emb_b, emb_source)
+    return SourceConditionedResult(
+        d_sel=selection_divergence(cov_a, cov_b, emb_source),
+        residual_a=res_a,
+        residual_b=res_b,
+        closeness_a=closeness(res_a),
+        closeness_b=closeness(res_b),
+        n_statements_a=n_a,
+        n_statements_b=n_b,
+        n_statements_source=n_s,
+        coverage_a=cov_a.tolist(),
+        coverage_b=cov_b.tolist(),
+    )

docdistance/encoders.py

@@ -0,0 +1,229 @@
+"""Model-backed segmentation and embedding.
+
+The heavy dependencies (torch, transformers, openvino, wtpsplit, huggingface_hub) are imported
+lazily inside the functions, so the pure-numpy :mod:`docdistance.distance` core stays
+importable - and unit-testable - without them.
+
+Inference never downloads. The constructors set ``HF_HUB_OFFLINE=1``; a model missing from the
+cache raises :class:`ModelsNotInstalled` pointing at ``docdistance install``. Downloading happens
+only in :func:`download_models`, which the ``install`` CLI command calls (TQDM progress bars come
+from huggingface_hub).
+"""
+
+from __future__ import annotations
+
+import contextlib
+import io
+import os
+from pathlib import Path
+
+from loguru import logger
+import numpy as np
+
+from docdistance import config
+
+# keep transformers quiet before it is ever imported - it otherwise prints a model LOAD REPORT
+# and advisory warnings (e.g. dropped LM-head keys) that leak past stderr redirection
+os.environ.setdefault("TRANSFORMERS_VERBOSITY", "error")
+os.environ.setdefault("TRANSFORMERS_NO_ADVISORY_WARNINGS", "1")
+
+EMBED_BATCH = 64
+MAX_TOKENS = 128
+
+_INSTALL_HINT = "model not found in cache - run:  docdistance install"
+_EXTRA_HINT = "model dependencies missing - reinstall:  pip install --force-reinstall docdistance"
+
+
+class ModelsNotInstalled(RuntimeError):
+    """A required model is missing from the cache - run ``docdistance install``."""
+
+
+def _require_models_extra() -> None:
+    try:
+        import transformers
+        import wtpsplit  # noqa: F401
+    except ModuleNotFoundError as exc:
+        raise ModelsNotInstalled(_EXTRA_HINT) from exc
+    # belt-and-suspenders alongside the env vars: silence the LOAD REPORT / modeling logger
+    import logging as _logging
+
+    transformers.logging.set_verbosity_error()
+    _logging.getLogger("transformers.modeling_utils").setLevel(_logging.ERROR)
+
+
+def _set_hf_token() -> None:
+    """Map the project's vault token (HF_AUTH_TOKEN, loaded from .env by config) to HF_TOKEN."""
+    if os.environ.get("HF_AUTH_TOKEN") and not os.environ.get("HF_TOKEN"):
+        os.environ["HF_TOKEN"] = os.environ["HF_AUTH_TOKEN"]
+    os.environ.setdefault("HF_HUB_DISABLE_TELEMETRY", "1")
+    os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+
+class Segmenter:
+    """SAT statement segmenter (wtpsplit ``sat-3l-sm``), CPU."""
+
+    def __init__(self, offline: bool = True):
+        _require_models_extra()
+        _set_hf_token()
+        if offline:
+            os.environ.setdefault("HF_HUB_OFFLINE", "1")
+        with contextlib.redirect_stderr(io.StringIO()):
+            from wtpsplit import SaT
+
+            try:
+                self._sat = SaT(config.SAT_MODEL)
+            except Exception as exc:  # missing weights under offline mode
+                raise ModelsNotInstalled(_INSTALL_HINT) from exc
+        logger.debug("loaded SAT segmenter '{}'", config.SAT_MODEL)
+
+    def split(self, text: str) -> list[str]:
+        with contextlib.redirect_stderr(io.StringIO()):
+            return [s.strip() for s in self._sat.split(text) if s.strip()]
+
+
+class OpenVINOEncoder:
+    """mmBERT INT8 OpenVINO encoder (CPU). Mean-pooled, L2-normalized statement embeddings."""
+
+    name = "openvino"
+
+    def __init__(self, offline: bool = True):
+        _require_models_extra()
+        _set_hf_token()
+        import openvino as ov
+        from transformers import AutoTokenizer
+
+        src = config.MMBERT_OPENVINO_LOCAL
+        if not (src / "openvino_model.xml").exists():
+            if offline:
+                os.environ.setdefault("HF_HUB_OFFLINE", "1")
+            from huggingface_hub import snapshot_download
+
+            try:
+                src = Path(snapshot_download(config.MMBERT_OPENVINO_HF))
+            except Exception as exc:
+                raise ModelsNotInstalled(_INSTALL_HINT) from exc
+        core = ov.Core()
+        model = core.read_model(str(src / "openvino_model.xml"))
+        # 2nd input name is dropped to '74' (attention_mask) during conversion - feed positionally
+        self._innames = [i.get_any_name() for i in model.inputs]
+        self._cm = core.compile_model(model, "CPU", {"PERFORMANCE_HINT": "LATENCY"})
+        self._tok = AutoTokenizer.from_pretrained(str(src))
+        logger.debug("loaded OpenVINO INT8 encoder from {}", src)
+
+    def encode(self, sents: list[str]) -> np.ndarray:
+        out = []
+        for i in range(0, len(sents), EMBED_BATCH):
+            batch = sents[i : i + EMBED_BATCH]
+            enc = self._tok(
+                batch, padding=True, truncation=True, max_length=MAX_TOKENS, return_tensors="np"
+            )
+            feeds = {self._innames[0]: enc["input_ids"], self._innames[1]: enc["attention_mask"]}
+            hidden = self._cm(feeds)[self._cm.output(0)]
+            mask = enc["attention_mask"][..., None].astype("float32")
+            pooled = (hidden * mask).sum(1) / np.clip(mask.sum(1), 1, None)
+            out.append(
+                (pooled / (np.linalg.norm(pooled, axis=1, keepdims=True) + 1e-9)).astype(
+                    np.float32
+                )
+            )
+        return np.concatenate(out, 0)
+
+
+class TorchEncoder:
+    """mmBERT PyTorch encoder (GPU bf16 if available, else CPU fp32)."""
+
+    name = "torch"
+
+    def __init__(self, offline: bool = True, device: str | None = None):
+        _require_models_extra()
+        _set_hf_token()
+        if offline:
+            os.environ.setdefault("HF_HUB_OFFLINE", "1")
+        import torch
+        from transformers import AutoConfig, AutoModel, AutoTokenizer
+
+        self._torch = torch
+        self._dev = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        with contextlib.redirect_stderr(io.StringIO()):
+            conf = AutoConfig.from_pretrained(config.MMBERT_TORCH_MODEL)
+            conf.reference_compile = False  # avoid the ModernBERT first-forward torch.compile hang
+            try:
+                self._tok = AutoTokenizer.from_pretrained(config.MMBERT_TORCH_MODEL)
+                enc = AutoModel.from_pretrained(
+                    config.MMBERT_TORCH_MODEL, config=conf, attn_implementation="eager"
+                )
+            except Exception as exc:
+                raise ModelsNotInstalled(_INSTALL_HINT) from exc
+        dtype = torch.bfloat16 if self._dev == "cuda" else torch.float32
+        self._enc = enc.to(self._dev).to(dtype).eval()
+        logger.debug("loaded Torch encoder '{}' on {}", config.MMBERT_TORCH_MODEL, self._dev)
+
+    def encode(self, sents: list[str]) -> np.ndarray:
+        torch = self._torch
+        out = []
+        with torch.no_grad():
+            for i in range(0, len(sents), EMBED_BATCH):
+                batch = sents[i : i + EMBED_BATCH]
+                enc = self._tok(
+                    batch,
+                    padding=True,
+                    truncation=True,
+                    max_length=MAX_TOKENS,
+                    return_tensors="pt",
+                ).to(self._dev)
+                hidden = self._enc(**enc).last_hidden_state.float()
+                mask = enc["attention_mask"].unsqueeze(-1).float()
+                pooled = (hidden * mask).sum(1) / mask.sum(1).clamp(min=1)
+                pooled = torch.nn.functional.normalize(pooled, dim=1)
+                out.append(pooled.cpu().numpy().astype(np.float32))
+        return np.concatenate(out, 0)
+
+
+def load_encoder(backend: str = "openvino", offline: bool = True):
+    """Factory: return an encoder for ``backend`` in {openvino, torch}."""
+    if backend == "openvino":
+        return OpenVINOEncoder(offline=offline)
+    if backend == "torch":
+        return TorchEncoder(offline=offline)
+    raise ValueError(f"unknown backend {backend!r}; choose 'openvino' or 'torch'")
+
+
+def download_models(backend: str = "openvino") -> list[str]:
+    """Download and cache the models for ``backend`` in {openvino, torch, both}.
+
+    The only function that fetches from the Hub. huggingface_hub renders TQDM download bars.
+    """
+    _require_models_extra()
+    _set_hf_token()
+    os.environ.pop("HF_HUB_OFFLINE", None)  # force online for the install step
+
+    logger.info("downloading SAT segmenter '{}'", config.SAT_MODEL)
+    with contextlib.redirect_stderr(io.StringIO()):
+        from wtpsplit import SaT
+
+        SaT(config.SAT_MODEL)
+
+    backends = ["openvino", "torch"] if backend == "both" else [backend]
+    if "openvino" in backends:
+        if (config.MMBERT_OPENVINO_LOCAL / "openvino_model.xml").exists():
+            logger.info(
+                "openvino INT8 encoder already present at {}", config.MMBERT_OPENVINO_LOCAL
+            )
+        else:
+            logger.info("downloading '{}'", config.MMBERT_OPENVINO_HF)
+            from huggingface_hub import snapshot_download
+
+            snapshot_download(config.MMBERT_OPENVINO_HF)
+    if "torch" in backends:
+        logger.info("downloading '{}'", config.MMBERT_TORCH_MODEL)
+        from transformers import AutoConfig, AutoModel, AutoTokenizer
+
+        conf = AutoConfig.from_pretrained(config.MMBERT_TORCH_MODEL)
+        conf.reference_compile = False
+        AutoTokenizer.from_pretrained(config.MMBERT_TORCH_MODEL)
+        AutoModel.from_pretrained(
+            config.MMBERT_TORCH_MODEL, config=conf, attn_implementation="eager"
+        )
+
+    logger.success("models ready for backend(s): {}", ", ".join(backends))
+    return backends

docdistance/features.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+
+from loguru import logger
+from tqdm import tqdm
+import typer
+
+from docdistance.config import PROCESSED_DATA_DIR
+
+app = typer.Typer()
+
+
+@app.command()
+def main(
+    # ---- REPLACE DEFAULT PATHS AS APPROPRIATE ----
+    input_path: Path = PROCESSED_DATA_DIR / "dataset.csv",
+    output_path: Path = PROCESSED_DATA_DIR / "features.csv",
+    # -----------------------------------------
+):
+    # ---- REPLACE THIS WITH YOUR OWN CODE ----
+    logger.info("Generating features from dataset...")
+    for i in tqdm(range(10), total=10):
+        if i == 5:
+            logger.info("Something happened for iteration 5.")
+    logger.success("Features generation complete.")
+    # -----------------------------------------
+
+
+if __name__ == "__main__":
+    app()

docdistance/modeling/predict.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+
+from loguru import logger
+from tqdm import tqdm
+import typer
+
+from docdistance.config import MODELS_DIR, PROCESSED_DATA_DIR
+
+app = typer.Typer()
+
+
+@app.command()
+def main(
+    # ---- REPLACE DEFAULT PATHS AS APPROPRIATE ----
+    features_path: Path = PROCESSED_DATA_DIR / "test_features.csv",
+    model_path: Path = MODELS_DIR / "model.pkl",
+    predictions_path: Path = PROCESSED_DATA_DIR / "test_predictions.csv",
+    # -----------------------------------------
+):
+    # ---- REPLACE THIS WITH YOUR OWN CODE ----
+    logger.info("Performing inference for model...")
+    for i in tqdm(range(10), total=10):
+        if i == 5:
+            logger.info("Something happened for iteration 5.")
+    logger.success("Inference complete.")
+    # -----------------------------------------
+
+
+if __name__ == "__main__":
+    app()

docdistance/modeling/train.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+
+from loguru import logger
+from tqdm import tqdm
+import typer
+
+from docdistance.config import MODELS_DIR, PROCESSED_DATA_DIR
+
+app = typer.Typer()
+
+
+@app.command()
+def main(
+    # ---- REPLACE DEFAULT PATHS AS APPROPRIATE ----
+    features_path: Path = PROCESSED_DATA_DIR / "features.csv",
+    labels_path: Path = PROCESSED_DATA_DIR / "labels.csv",
+    model_path: Path = MODELS_DIR / "model.pkl",
+    # -----------------------------------------
+):
+    # ---- REPLACE THIS WITH YOUR OWN CODE ----
+    logger.info("Training some model...")
+    for i in tqdm(range(10), total=10):
+        if i == 5:
+            logger.info("Something happened for iteration 5.")
+    logger.success("Modeling training complete.")
+    # -----------------------------------------
+
+
+if __name__ == "__main__":
+    app()

docdistance/pipeline.py

@@ -0,0 +1,115 @@
+"""High-level document-distance API.
+
+Two entry styles:
+
+- :class:`DocDistance` - load the models once, score many pairs (the pipeline-integration entry)
+- :func:`document_distance` / :func:`source_conditioned_distance` - one-shot convenience that loads
+  and scores in a single call
+
+Inputs are raw text or a path to a text/markdown file (auto-detected). A leading markdown ``# `` title
+line is stripped from files so the document title does not count as a statement.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+
+from docdistance import distance as _core
+from docdistance.distance import (
+    DEFAULT_THRESHOLD,
+    DistanceResult,
+    SourceConditionedResult,
+)
+from docdistance.encoders import Segmenter, load_encoder
+
+
+def _load_body(path: Path) -> str:
+    lines = path.read_text().splitlines()
+    return "\n".join(ln for ln in lines if not ln.startswith("# ")).strip()
+
+
+def _read(doc: str | Path) -> str:
+    """Resolve a document argument: an existing file path is read, anything else is treated as text."""
+    if isinstance(doc, Path):
+        return _load_body(doc)
+    if isinstance(doc, str):
+        try:
+            p = Path(doc)
+            if p.exists() and p.is_file():
+                return _load_body(p)
+        except OSError:
+            pass
+        return doc.strip()
+    raise TypeError(f"document must be str or Path, got {type(doc).__name__}")
+
+
+class DocDistance:
+    """Reusable pipeline - construct once (models load here), then call :meth:`distance` per pair."""
+
+    def __init__(self, backend: str = "openvino", offline: bool = True):
+        self.backend = backend
+        self.segmenter = Segmenter(offline=offline)
+        self.encoder = load_encoder(backend, offline=offline)
+
+    def embed(self, doc: str | Path) -> np.ndarray:
+        """Segment then embed a document into L2-normalized statement vectors ``[n, dim]``."""
+        statements = self.segmenter.split(_read(doc))
+        if not statements:
+            raise ValueError("document produced no statements")
+        return self.encoder.encode(statements)
+
+    def distance(
+        self,
+        a: str | Path,
+        b: str | Path,
+        *,
+        anisotropy: bool = False,
+        threshold: float = DEFAULT_THRESHOLD,
+    ) -> DistanceResult:
+        return _core.compute_distance(
+            self.embed(a), self.embed(b), anisotropy=anisotropy, threshold=threshold
+        )
+
+    def distance_wrt_source(
+        self,
+        a: str | Path,
+        b: str | Path,
+        source: str | Path,
+        *,
+        anisotropy: bool = False,
+    ) -> SourceConditionedResult:
+        return _core.compute_source_conditioned(
+            self.embed(a), self.embed(b), self.embed(source), anisotropy=anisotropy
+        )
+
+
+def document_distance(
+    a: str | Path,
+    b: str | Path,
+    *,
+    backend: str = "openvino",
+    anisotropy: bool = False,
+    threshold: float = DEFAULT_THRESHOLD,
+    offline: bool = True,
+) -> DistanceResult:
+    """Symmetric Statement Mover's Distance between documents ``a`` and ``b`` (loads models, then scores)."""
+    return DocDistance(backend=backend, offline=offline).distance(
+        a, b, anisotropy=anisotropy, threshold=threshold
+    )
+
+
+def source_conditioned_distance(
+    a: str | Path,
+    b: str | Path,
+    source: str | Path,
+    *,
+    backend: str = "openvino",
+    anisotropy: bool = False,
+    offline: bool = True,
+) -> SourceConditionedResult:
+    """Source-conditioned distance d(A, B | S): selection divergence + each document's distance to S."""
+    return DocDistance(backend=backend, offline=offline).distance_wrt_source(
+        a, b, source, anisotropy=anisotropy
+    )

docdistance/plots.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+
+from loguru import logger
+from tqdm import tqdm
+import typer
+
+from docdistance.config import FIGURES_DIR, PROCESSED_DATA_DIR
+
+app = typer.Typer()
+
+
+@app.command()
+def main(
+    # ---- REPLACE DEFAULT PATHS AS APPROPRIATE ----
+    input_path: Path = PROCESSED_DATA_DIR / "dataset.csv",
+    output_path: Path = FIGURES_DIR / "plot.png",
+    # -----------------------------------------
+):
+    # ---- REPLACE THIS WITH YOUR OWN CODE ----
+    logger.info("Generating plot from data...")
+    for i in tqdm(range(10), total=10):
+        if i == 5:
+            logger.info("Something happened for iteration 5.")
+    logger.success("Plot generation complete.")
+    # -----------------------------------------
+
+
+if __name__ == "__main__":
+    app()

docdistance-1.0.15.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: docdistance
+Version: 1.0.15
+Summary: Project that uses theory of From Word Embeddings To Document Distances / Optimal Transport to give meaningful distance from one document to another, useful if building agentic projects that convert or extract information from one document to another using frontier models but without the ability to calculate KL divergence from logits
+Author: Stellars Henson <konrad.jelen+github@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/stellarshenson/docdistance
+Project-URL: Repository, https://github.com/stellarshenson/docdistance
+Project-URL: Issues, https://github.com/stellarshenson/docdistance/issues
+Keywords: optimal-transport,word-movers-distance,statement-movers-distance,document-similarity,document-distance,embeddings,mmbert,nlp
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Requires-Python: ~=3.13.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: loguru
+Requires-Dist: tqdm
+Requires-Dist: typer
+Requires-Dist: rich
+Requires-Dist: python-dotenv
+Requires-Dist: numpy
+Requires-Dist: pot
+Requires-Dist: transformers
+Requires-Dist: wtpsplit
+Requires-Dist: openvino
+Requires-Dist: torch
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: ipykernel; extra == "dev"
+Requires-Dist: ipython; extra == "dev"
+Requires-Dist: nbdime; extra == "dev"
+Requires-Dist: pip; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: matplotlib; extra == "dev"
+Requires-Dist: seaborn; extra == "dev"
+Dynamic: license-file
+
+# docdistance
+
+Semantic distance between two documents via Statement Mover's Distance - optimal transport over mmBERT statement embeddings, after Kusner et al. 2015 (*From Word Embeddings To Document Distances*). A thin frontend to the library; the SOTA docs carry the mechanics, benchmarks, and validation.
+
+- **Input** - two documents, raw text or a file path
+- **Output** - an SMD distance, a 0..1 closeness, a verdict, and the statement alignment
+- **Use** - agentic document conversion and extraction pipelines, where token logits are unavailable and KL divergence cannot be computed
+- **Unit** - statement-level and position-invariant, with an interpretable transport plan
+
+## Theory
+
+A document distance grounded in embeddings and optimal transport, not surface overlap.
+
+- **WMD** - Word Mover's Distance (Kusner et al. 2015) casts document similarity as optimal transport between embedded tokens
+- **SMD** - this project lifts it to statements: segment, embed, transport between the two statement clouds
+- **Beyond cosine** - whole-document cosine collapses when the same claims sit in a different place or order; statement-level transport is position-invariant
+- **Metric** - the ground cost `√(2 − 2cos)` on L2-normalized embeddings is a metric, so the document distance is one too
+- **Logit-free** - an embedding-grounded alternative where token probabilities (KL divergence) are unavailable, as in frontier-model pipelines
+
+## Method
+
+Three stages; the transport plan is the interpretable by-product.
+
+1. **Segment** - split each document into atomic statements with the SAT (Segment Any Text) segmenter
+2. **Embed** - encode each statement with the mmBERT contextual encoder (mean-pooled, L2-normalized)
+3. **Compare** - optimal transport between the two statement clouds (Statement Mover's Distance), optionally unbalanced so added or missing statements are scored, not force-matched
+
+- **Closeness** - `1 − SMD/√2`, on a 0..1 scale
+- **Source-conditioned** - a variant `d(A, B | S)` re-bases the transport onto a shared source `S` and reads off a selection axis and a grounding axis
+
+## Usage
+
+The library is the product; install once, then call it.
+
+```python
+from docdistance import document_distance
+
+result = document_distance("report_v1.md", "report_v2.md")
+print(result.closeness)  # 0..1 similarity, 1 - SMD/sqrt(2)
+print(result.verdict)    # "similar" | "not similar"
+```
+
+```bash
+make install                                   # environment, package, Jupyter kernel
+docdistance install                            # download + cache the models (once)
+docdistance distance a.md b.md                 # rich, coloured verdict
+docdistance distance a.md b.md --json          # machine-readable JSON
+```
+
+- **Offline after install** - distance calls run fully offline once the models are cached
+- **Backend** - `--backend openvino|torch`, default `openvino` (CPU INT8)
+- **Full API and flags** - `docdistance --help` and the SOTA docs
+
+## Documentation
+
+The SOTA documents explain how it works in detail; this README only introduces it.
+
+- `docs/wmd-docdistance-solution-sota.md` - source-free distance: design, mechanism, performance, validation
+- `docs/wmd-wrt-source-docdistance-solution.md` - source-conditioned distance `d(A,B|S)`
+- `docs/mmbert-quantization-solution.md` - the INT8 / FP8 statement encoder
+- `references/papers/from-word-embeddings-to-document-distances.md` - WMD paper digest (Kusner et al. 2015)
+
+> **Note**: Scaffolded with the [copier-data-science](https://github.com/stellarshenson/copier-data-science) template.

docdistance-1.0.15.dist-info/RECORD

@@ -0,0 +1,18 @@
+docdistance/__init__.py,sha256=7JPs0Q9AwNqWMFm8wcnrTWiP0SNnpAX2p0tA1NjT5gY,852
+docdistance/cli.py,sha256=_bKjQf2gV-RpqJZ7d1RfwoUcZA18hk9bLvmCGcZz4Yg,8222
+docdistance/config.py,sha256=5GZ7NYDn24Kg6ZBczNYlGiuyla_4_sOJ5zhuVx-6ZD4,2106
+docdistance/dataset.py,sha256=huS5XJ_ydmV6rbtokI62GEgwQviUbe1HWHX5Hyutjmw,771
+docdistance/distance.py,sha256=xklp-zY_uGa6EbTV1WYBVfs2XGx1Piy8eugf4eGO1h4,8415
+docdistance/encoders.py,sha256=LND3YWJFRUP7XwN2N1npNrvfao25FzxtbpyFVXjQO_4,9315
+docdistance/features.py,sha256=UU2MNtJ5gjcDm9j2QzQAQxFV6NAwnGKQIslUUreyKLU,774
+docdistance/pipeline.py,sha256=lZisWFpzJqKUWYp80gSz05G8ZHjH1-JvKFd3WdX0SDs,3681
+docdistance/plots.py,sha256=70V_HtIyDSlmoP5hW8Ub3tlm1Vi0X5wSeDZPINxzBJ4,765
+docdistance/modeling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+docdistance/modeling/predict.py,sha256=3B61xaFKG7GRXvwe3xhX5YmJa_M8P3iPWH3uGGcch5w,845
+docdistance/modeling/train.py,sha256=OH6okBYDaUG8tLmEoyBTBHqZmJUvdVp22_hnIdNY0Bo,822
+docdistance-1.0.15.dist-info/licenses/LICENSE,sha256=AtXSSglTQoyugtRKTcRY-XeGVUG83jnSek9Q3iM8rb8,1116
+docdistance-1.0.15.dist-info/METADATA,sha256=uUxUlIpBThv-S6T6p5W3IvrKBNJpmwoAOcp-ZNIH23I,5561
+docdistance-1.0.15.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+docdistance-1.0.15.dist-info/entry_points.txt,sha256=O3HurDhddDvy5pgGPEgac-y-FgDsBHkDPN7IIuJEKJ8,52
+docdistance-1.0.15.dist-info/top_level.txt,sha256=BJP9ozRKdJaw9aUUmkAtLbrb-3QRc4oXgkSaZMGyJG8,12
+docdistance-1.0.15.dist-info/RECORD,,

docdistance-1.0.15.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

docdistance-1.0.15.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+docdistance = docdistance.cli:app

docdistance-1.0.15.dist-info/licenses/LICENSE

@@ -0,0 +1,10 @@
+
+The MIT License (MIT)
+Copyright (c) 2026, Stellars Henson <konrad.jelen+github@gmail.com>
+
+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.
+

docdistance-1.0.15.dist-info/top_level.txt

@@ -0,0 +1 @@
+docdistance