vrty 1.0.0__py3-none-any.whl

vrty/__init__.py

@@ -0,0 +1,16 @@
+"""VRTY v1.0 - deterministic LLM output quality scoring.
+
+Public surface:
+
+    >>> from vrty import score
+    >>> result = score("What is the capital of France?", "Paris is the capital.")
+    >>> result.composite
+    0.79...
+    >>> result.to_dict()["weights"]
+    {'relevance': 0.35, 'coherence': 0.2, 'completeness': 0.3, 'conciseness': 0.15}
+"""
+
+from vrty._version import __version__
+from vrty.composite import VrtyScore, score
+
+__all__ = ["__version__", "VrtyScore", "score"]

vrty/__main__.py

@@ -0,0 +1,8 @@
+"""Module entry point so ``python -m vrty`` invokes the CLI."""
+
+import sys
+
+from vrty.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

vrty/_version.py

@@ -0,0 +1,8 @@
+"""Single source of truth for the VRTY runtime version.
+
+Kept in a leaf module with no other imports so ``vrty/__init__.py`` can
+re-export it and other modules (``composite.py``, ``data_loader.py``) can
+import it without circular-import risk.
+"""
+
+__version__ = "1.0.0"

vrty/cli.py

@@ -0,0 +1,123 @@
+"""Command-line interface for VRTY v1.0.
+
+A single command that scores a (prompt, response) pair and prints the locked
+9-key result as JSON. Pure stdlib (argparse + json + pathlib); no third-party
+CLI library, no subcommands, no output-shape changes from the library API.
+
+Default output is one compact JSON line with ``sort_keys=True`` so the bytes
+are stable enough to diff or pipe into ``jq`` or another tool. ``--pretty``
+indents the JSON for human reading.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from vrty import __version__, score
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="vrty",
+        description=(
+            "VRTY v1.0 - deterministic LLM output quality scoring. "
+            "Returns a 0.0-1.0 composite plus per-dimension breakdown "
+            "(relevance, coherence, completeness, conciseness) for a "
+            "(prompt, response) pair. No LLM call; pure deterministic math."
+        ),
+        epilog=(
+            "Examples:\n"
+            "  vrty --prompt 'What is the capital of France?' "
+            "--response 'Paris is the capital of France.'\n"
+            "  vrty --prompt-file p.txt --response-file r.txt --pretty\n"
+            "  vrty --prompt 'hello' --response-file /dev/stdin < response.txt"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    p.add_argument(
+        "--version",
+        action="version",
+        version=f"vrty {__version__}",
+    )
+
+    prompt_group = p.add_mutually_exclusive_group(required=True)
+    prompt_group.add_argument(
+        "--prompt",
+        metavar="TEXT",
+        help="prompt text (literal string)",
+    )
+    prompt_group.add_argument(
+        "--prompt-file",
+        metavar="PATH",
+        help="read prompt text from this UTF-8 file (use /dev/stdin for stdin)",
+    )
+
+    response_group = p.add_mutually_exclusive_group(required=True)
+    response_group.add_argument(
+        "--response",
+        metavar="TEXT",
+        help="response text (literal string)",
+    )
+    response_group.add_argument(
+        "--response-file",
+        metavar="PATH",
+        help="read response text from this UTF-8 file (use /dev/stdin for stdin)",
+    )
+
+    p.add_argument(
+        "--pretty",
+        action="store_true",
+        help="indent JSON output for readability (default: one compact line)",
+    )
+    return p
+
+
+def _read_text_arg(literal: str | None, file_path: str | None) -> str:
+    """Resolve a literal-or-file pair to a single string. argparse already
+    guaranteed exactly one of the two is set via the mutually-exclusive group.
+    """
+    if literal is not None:
+        return literal
+    assert file_path is not None  # argparse contract
+    return Path(file_path).read_text(encoding="utf-8")
+
+
+def main(argv: list[str] | None = None) -> int:
+    """CLI entry point. Returns the exit code; does not call sys.exit itself.
+
+    Exit codes:
+        0 - success, score printed to stdout
+        1 - I/O error (e.g., --prompt-file does not exist or is unreadable)
+        2 - argparse error (e.g., missing required argument). argparse prints
+            its own usage message and calls sys.exit(2) before main() returns.
+    """
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    try:
+        prompt = _read_text_arg(args.prompt, args.prompt_file)
+        response = _read_text_arg(args.response, args.response_file)
+    except OSError as e:
+        print(f"vrty: {e}", file=sys.stderr)
+        return 1
+
+    result = score(prompt, response)
+    payload = result.to_dict()
+
+    if args.pretty:
+        output = json.dumps(payload, sort_keys=True, indent=2, ensure_ascii=False)
+    else:
+        output = json.dumps(
+            payload, sort_keys=True, separators=(",", ":"), ensure_ascii=False,
+        )
+
+    sys.stdout.write(output)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())

vrty/composite.py

@@ -0,0 +1,164 @@
+"""Composite VRTY score: weighted sum of the four pure dimension scores.
+
+The composite layer is the public entry point: ``score(prompt, response)``
+returns a frozen ``VrtyScore`` carrying the composite, the per-dimension
+breakdown, and the provenance fields (``vrty_version``, ``idf_sha256``,
+``weights``) that make any score traceable to the exact scoring logic that
+produced it.
+
+Weights are fixed v1.0 constants; they are not configurable. The IDF table
+and ``idf_oov`` are loaded from the bundled frozen file via
+``data_loader.load_idf()`` and cannot be supplied by the caller — this is
+how the v1.0 "version-locked" guarantee is enforced in code.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from types import MappingProxyType
+from typing import Mapping
+
+from vrty._version import __version__
+from vrty.data_loader import load_idf
+from vrty.explanations import build_explanations, empty_response_explanations
+from vrty.scoring import (
+    _tokenize,
+    coherence,
+    completeness,
+    conciseness,
+    relevance,
+)
+
+# Fixed weights for v1.0. Pinned constants — not configurable.
+# Configurability is explicitly out of scope per the v1.0 scope lock;
+# revisiting requires a v1.1 conversation. Weights sum to 1.0 so the
+# composite stays in [0, 1] without further normalization.
+WEIGHT_RELEVANCE: float = 0.35
+WEIGHT_COHERENCE: float = 0.20
+WEIGHT_COMPLETENESS: float = 0.30
+WEIGHT_CONCISENESS: float = 0.15
+
+_WEIGHTS: Mapping[str, float] = MappingProxyType({
+    "relevance": WEIGHT_RELEVANCE,
+    "coherence": WEIGHT_COHERENCE,
+    "completeness": WEIGHT_COMPLETENESS,
+    "conciseness": WEIGHT_CONCISENESS,
+})
+
+# Fail-fast at import time: the v1.0 invariant is that weights sum to 1.0.
+# Using exact equality is safe because the four numerators (35, 20, 30, 15)
+# sum to 100 and dividing by 100 is exact in IEEE-754 binary floating point.
+assert sum(_WEIGHTS.values()) == 1.0, (
+    f"VRTY weights must sum to 1.0; got {sum(_WEIGHTS.values())!r}"
+)
+
+
+@dataclass(frozen=True)
+class VrtyScore:
+    """Result of scoring a (prompt, response) pair.
+
+    All numeric fields are bounded to ``[0.0, 1.0]``. The dataclass is frozen
+    so a score object cannot be mutated after creation (a downstream consumer
+    cannot accidentally change a score it received).
+
+    ``vrty_version`` records the scoring-logic version. ``idf_sha256`` is
+    the SHA-256 of the bundled IDF data file used at scoring time; together
+    they make any single score reproducible.
+    """
+
+    composite: float
+    relevance: float
+    coherence: float
+    completeness: float
+    conciseness: float
+    explanations: Mapping[str, str]
+    vrty_version: str
+    idf_sha256: str
+    weights: Mapping[str, float] = field(default_factory=lambda: _WEIGHTS)
+
+    def to_dict(self) -> dict:
+        """Return a plain JSON-serializable dict (stable key ordering).
+
+        ``json.dumps(score.to_dict(), sort_keys=True)`` produces a byte-stable
+        serialization suitable for caching, hashing, or diffing scores.
+        """
+        return {
+            "composite": self.composite,
+            "relevance": self.relevance,
+            "coherence": self.coherence,
+            "completeness": self.completeness,
+            "conciseness": self.conciseness,
+            "explanations": dict(self.explanations),
+            "vrty_version": self.vrty_version,
+            "idf_sha256": self.idf_sha256,
+            "weights": dict(self.weights),
+        }
+
+
+def score(prompt: str, response: str) -> VrtyScore:
+    """Score a (prompt, response) pair across four dimensions and a composite.
+
+    Per the v1.0 input contract, a response with no tokens (empty string,
+    whitespace only, punctuation only, or non-ASCII only after NFKD strip)
+    returns 0.0 on every dimension and the composite. Other degenerate
+    inputs (empty prompt, single word, oversized) are handled by the
+    underlying scoring functions per their documented behavior.
+
+    The function takes no IDF or weight arguments. The IDF table and
+    ``idf_oov`` are pinned in the bundled frozen data file (integrity-checked
+    by SHA-256 at load); the weights are pinned module-level constants.
+    There is no API surface through which a caller can silently drift the
+    score.
+    """
+    snap = load_idf()
+
+    # Empty-response wrapper: enforce the input-contract 0.0 across the board
+    # before any per-dimension function runs. We detect "no tokens" rather
+    # than literal empty string so punctuation-only / non-ASCII-only inputs
+    # are treated as empty (consistent with the tokenizer's view).
+    if not _tokenize(response):
+        return VrtyScore(
+            composite=0.0,
+            relevance=0.0,
+            coherence=0.0,
+            completeness=0.0,
+            conciseness=0.0,
+            explanations=empty_response_explanations(),
+            vrty_version=__version__,
+            idf_sha256=snap.sha256,
+        )
+
+    r = relevance(prompt, response, idf=snap.idf, idf_oov=snap.idf_oov)
+    co = coherence(response, idf=snap.idf, idf_oov=snap.idf_oov)
+    cm = completeness(
+        prompt, response,
+        idf=snap.idf, idf_oov=snap.idf_oov, stopwords=snap.stopwords,
+    )
+    cn = conciseness(response, stopwords=snap.stopwords)
+
+    composite = (
+        WEIGHT_RELEVANCE * r
+        + WEIGHT_COHERENCE * co
+        + WEIGHT_COMPLETENESS * cm
+        + WEIGHT_CONCISENESS * cn
+    )
+    # Same one-ulp FP overshoot clamp as in _cosine. With non-negative
+    # components in [0, 1] and weights summing to 1.0 the composite is in
+    # [0, 1] mathematically; the clamp absorbs IEEE-754 rounding noise.
+    if composite > 1.0:
+        composite = 1.0
+    elif composite < 0.0:
+        composite = 0.0
+
+    return VrtyScore(
+        composite=composite,
+        relevance=r,
+        coherence=co,
+        completeness=cm,
+        conciseness=cn,
+        explanations=build_explanations(
+            relevance=r, coherence=co, completeness=cm, conciseness=cn,
+        ),
+        vrty_version=__version__,
+        idf_sha256=snap.sha256,
+    )

vrty/data_loader.py

@@ -0,0 +1,107 @@
+"""Load and integrity-check the bundled frozen IDF data file.
+
+The IDF file ships at ``vrty/data/idf.json.gz``. Its SHA-256 is pinned in
+``IDF_DATA_SHA256`` below. On first load, the bytes are checksummed; a
+mismatch raises ``VrtyDataError``. This guarantees the runtime score
+provenance: the only way to change scores is to ship a new IDF file with a
+new pinned digest, which is then reflected in ``vrty_version``.
+
+The loaded snapshot is cached in module state; subsequent calls return the
+same object. The snapshot is a frozen ``dataclass`` so callers cannot
+accidentally mutate the IDF dict at runtime.
+"""
+
+from __future__ import annotations
+
+import gzip
+import hashlib
+import json
+from dataclasses import dataclass
+from importlib.resources import files
+from types import MappingProxyType
+from typing import Mapping
+
+# SHA-256 of the gzipped bytes of ``vrty/data/idf.json.gz`` as built by
+# ``tools/build_idf.py`` from the pinned corpus. Updating the corpus or the
+# build script requires updating this constant in the same commit.
+IDF_DATA_SHA256: str = "0e475bcaa5524d1e26cbb166bb5c138e37f87e1e47b75e6506c6460a94259fd2"
+
+IDF_DATA_RESOURCE: str = "idf.json.gz"
+
+
+class VrtyDataError(RuntimeError):
+    """Raised when the bundled IDF data file fails its integrity check."""
+
+
+@dataclass(frozen=True)
+class IDFSnapshot:
+    """Immutable view over the frozen IDF data file.
+
+    ``idf`` is exposed as a ``MappingProxyType`` so callers cannot mutate the
+    cached dict. ``stopwords`` is a ``frozenset`` for O(1) membership and
+    immutability. All fields are populated from the bundled file and are
+    invariant for the lifetime of the process.
+    """
+
+    schema_version: int
+    vrty_version: str
+    doc_count: int
+    vocab_size: int
+    idf_oov: float
+    idf: Mapping[str, float]
+    stopwords: frozenset[str]
+    sha256: str
+
+    def __post_init__(self) -> None:
+        # Sanity: snapshot fields must agree with the bundle they came from.
+        if len(self.idf) != self.vocab_size:
+            raise VrtyDataError(
+                f"vocab_size mismatch: header says {self.vocab_size}, "
+                f"idf dict has {len(self.idf)}"
+            )
+
+
+_cached: IDFSnapshot | None = None
+
+
+def load_idf() -> IDFSnapshot:
+    """Return the cached frozen IDF snapshot.
+
+    On the first call, reads the bundled gzipped JSON via
+    ``importlib.resources``, verifies its SHA-256 against ``IDF_DATA_SHA256``,
+    parses it, and freezes the result. On subsequent calls, returns the
+    cached snapshot.
+
+    Raises ``VrtyDataError`` if the bundled file's digest does not match.
+    """
+    global _cached
+    if _cached is not None:
+        return _cached
+
+    resource = files("vrty.data").joinpath(IDF_DATA_RESOURCE)
+    raw = resource.read_bytes()
+
+    actual = hashlib.sha256(raw).hexdigest()
+    if actual != IDF_DATA_SHA256:
+        raise VrtyDataError(
+            f"IDF data file integrity check failed.\n"
+            f"  expected SHA-256: {IDF_DATA_SHA256}\n"
+            f"  actual SHA-256:   {actual}\n"
+            f"The bundled {IDF_DATA_RESOURCE} has been modified after build. "
+            f"Rebuild via tools/build_idf.py and update IDF_DATA_SHA256."
+        )
+
+    payload = json.loads(gzip.decompress(raw).decode("ascii"))
+
+    snapshot = IDFSnapshot(
+        schema_version=payload["schema_version"],
+        vrty_version=payload["vrty_version"],
+        doc_count=payload["doc_count"],
+        vocab_size=payload["vocab_size"],
+        idf_oov=float(payload["idf_oov"]),
+        idf=MappingProxyType(dict(payload["idf"])),
+        stopwords=frozenset(payload["stopwords"]),
+        sha256=actual,
+    )
+    _cached = snapshot
+    return snapshot

vrty/explanations.py

@@ -0,0 +1,101 @@
+"""Templated one-line per-dimension explanations.
+
+Fixed string templates with one interpolated float value per template. No
+prose generation, no LLM call, no branching beyond the documented threshold
+bands. Each dimension has three score-band templates (low / medium / high)
+plus one empty-response template selected only when the input-contract
+wrapper has zeroed every dimension.
+
+Thresholds and templates are pinned v1.0 constants. Changing the template
+text or the band cutoffs is a public API change.
+"""
+
+from __future__ import annotations
+
+from types import MappingProxyType
+from typing import Mapping
+
+# Score-band cutoffs. Deliberate v1.0 choice: below 0.40 a dimension signals
+# a clear deficiency; at-or-above 0.70 it signals a clear strength; the
+# middle is "partial / mixed". Boundaries are inclusive on the low end of
+# each higher band: 0.40 -> medium, 0.70 -> high.
+THRESHOLD_LOW: float = 0.40
+THRESHOLD_HIGH: float = 0.70
+
+# Sixteen fixed templates: 4 dimensions x (3 score bands + 1 empty-response
+# band). Every template is one line, plain English, two-decimal interpolation.
+_TEMPLATES: Mapping[str, Mapping[str, str]] = MappingProxyType({
+    "relevance": MappingProxyType({
+        "low":    "Relevance: {value:.2f} - response shares few terms with the prompt.",
+        "medium": "Relevance: {value:.2f} - response shares some terms with the prompt.",
+        "high":   "Relevance: {value:.2f} - response strongly overlaps with the prompt's key terms.",
+        "empty":  "Relevance: 0.00 - response contained no scorable tokens.",
+    }),
+    "coherence": MappingProxyType({
+        "low":    "Coherence: {value:.2f} - adjacent sentences share little content.",
+        "medium": "Coherence: {value:.2f} - sentence-to-sentence flow is moderate.",
+        "high":   "Coherence: {value:.2f} - adjacent sentences carry consistent topic.",
+        "empty":  "Coherence: 0.00 - response contained no scorable tokens.",
+    }),
+    "completeness": MappingProxyType({
+        "low":    "Completeness: {value:.2f} - few of the prompt's key terms appear in the response.",
+        "medium": "Completeness: {value:.2f} - some of the prompt's key terms are covered.",
+        "high":   "Completeness: {value:.2f} - most of the prompt's key terms appear in the response.",
+        "empty":  "Completeness: 0.00 - response contained no scorable tokens.",
+    }),
+    "conciseness": MappingProxyType({
+        "low":    "Conciseness: {value:.2f} - response is padded with repetition or filler.",
+        "medium": "Conciseness: {value:.2f} - response has moderate information density.",
+        "high":   "Conciseness: {value:.2f} - response is information-dense with little padding.",
+        "empty":  "Conciseness: 0.00 - response contained no scorable tokens.",
+    }),
+})
+
+DIMENSIONS: tuple[str, ...] = ("relevance", "coherence", "completeness", "conciseness")
+
+
+def _band(value: float) -> str:
+    """Map a dimension score in [0, 1] to one of three score bands."""
+    if value < THRESHOLD_LOW:
+        return "low"
+    if value < THRESHOLD_HIGH:
+        return "medium"
+    return "high"
+
+
+def build_explanations(
+    *,
+    relevance: float,
+    coherence: float,
+    completeness: float,
+    conciseness: float,
+) -> Mapping[str, str]:
+    """Return a frozen mapping of dimension name -> templated explanation.
+
+    Dimensions are inserted in canonical order
+    (relevance, coherence, completeness, conciseness) so iteration order is
+    stable across processes (Python dict preserves insertion order).
+    """
+    values = {
+        "relevance": relevance,
+        "coherence": coherence,
+        "completeness": completeness,
+        "conciseness": conciseness,
+    }
+    out: dict[str, str] = {}
+    for dim in DIMENSIONS:
+        v = values[dim]
+        template = _TEMPLATES[dim][_band(v)]
+        out[dim] = template.format(value=v)
+    return MappingProxyType(out)
+
+
+def empty_response_explanations() -> Mapping[str, str]:
+    """Return the fixed empty-response explanation set.
+
+    Used by the composite layer's empty-response wrapper instead of feeding
+    four zeros through the band logic — the "no scorable tokens" phrasing is
+    accurate and avoids saying "adjacent sentences share little content"
+    when there are no sentences at all.
+    """
+    return MappingProxyType({dim: _TEMPLATES[dim]["empty"] for dim in DIMENSIONS})

vrty/scoring.py

@@ -0,0 +1,220 @@
+"""Pure deterministic scoring functions for VRTY v1.0.
+
+Each function takes the required data (IDF table, stopwords) as arguments and
+performs no I/O. There is no module-level mutable state. All set/dict iteration
+is sorted before reduction so floating-point accumulation order is identical
+regardless of ``PYTHONHASHSEED``.
+
+Token cap, OOV smoothing, and the empty/degenerate behavior of every function
+are fixed by the v1.0 input contract; see the README "Known properties and
+limitations" section for the deliberate-choice rationales.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+import unicodedata
+from collections.abc import Iterable, Mapping
+from typing import Final
+
+MAX_TOKENS: Final[int] = 2048
+
+_TOKEN_RE: Final[re.Pattern[str]] = re.compile(r"[a-z]+")
+_SENT_SPLIT_RE: Final[re.Pattern[str]] = re.compile(r"(?<=[.!?])\s+")
+
+
+def _tokenize(text: str) -> list[str]:
+    """Lowercase ASCII tokens.
+
+    Non-ASCII input is NFKD-normalized then stripped to ASCII, so accented
+    Latin characters fold to their base letters and characters outside the
+    Latin script are dropped. This is documented as a v1.0 caveat: quality
+    outside English is not claimed.
+    """
+    folded = (
+        unicodedata.normalize("NFKD", text)
+        .encode("ascii", "ignore")
+        .decode("ascii")
+        .lower()
+    )
+    return _TOKEN_RE.findall(folded)
+
+
+def _tokens_capped(text: str) -> list[str]:
+    """Tokenize and truncate at the v1.0 fixed token cap."""
+    toks = _tokenize(text)
+    if len(toks) > MAX_TOKENS:
+        toks = toks[:MAX_TOKENS]
+    return toks
+
+
+def _split_sentences_capped(text: str) -> list[list[str]]:
+    """Split into sentences and tokenize each, accumulating until the token cap.
+
+    A sentence that would push the running total over ``MAX_TOKENS`` is dropped
+    whole rather than included partially, so sentence boundaries remain exact.
+    """
+    raw = _SENT_SPLIT_RE.split(text)
+    out: list[list[str]] = []
+    total = 0
+    for sent in raw:
+        if not sent.strip():
+            continue
+        toks = _tokenize(sent)
+        if not toks:
+            continue
+        if total + len(toks) > MAX_TOKENS:
+            break
+        out.append(toks)
+        total += len(toks)
+    return out
+
+
+def _tfidf_vector(
+    tokens: Iterable[str],
+    idf: Mapping[str, float],
+    idf_oov: float,
+) -> dict[str, float]:
+    """Build a TF*IDF weighted vector as a ``{token: weight}`` dict.
+
+    OOV tokens (not found in ``idf``) receive the ``idf_oov`` weight. The
+    bundled data file pins ``idf_oov`` at the maximum IDF observed in the
+    corpus — a deliberate choice that treats unseen tokens as maximally
+    informative, matching standard add-one (Laplace) IDF smoothing.
+    """
+    tf: dict[str, int] = {}
+    for t in tokens:
+        tf[t] = tf.get(t, 0) + 1
+    return {t: c * idf.get(t, idf_oov) for t, c in tf.items()}
+
+
+def _cosine(a: Mapping[str, float], b: Mapping[str, float]) -> float:
+    """Cosine similarity of two non-negative weight dicts.
+
+    Uses the zero-vector convention ``cos(0, .) := 0`` to avoid a 0/0 NaN
+    when either side has no weighted tokens (Manning & Schuetze, FSNLP, 6.4).
+    Keys are sorted before every reduction so the floating-point accumulation
+    order is identical across processes regardless of hash randomization.
+    The final value is clamped to ``[0.0, 1.0]`` to absorb the IEEE-754
+    rounding artifact that lets identical vectors produce a dot-over-norm
+    ratio of 1.0 + 1 ulp; this is the same clamp ``sklearn`` applies in
+    ``cosine_similarity`` for the same reason.
+    """
+    a_keys = sorted(a)
+    b_keys = sorted(b)
+    norm_a_sq = sum(a[k] * a[k] for k in a_keys)
+    norm_b_sq = sum(b[k] * b[k] for k in b_keys)
+    if norm_a_sq == 0.0 or norm_b_sq == 0.0:
+        return 0.0
+    norm_a = math.sqrt(norm_a_sq)
+    norm_b = math.sqrt(norm_b_sq)
+    if len(a_keys) <= len(b_keys):
+        shared = sorted(k for k in a_keys if k in b)
+    else:
+        shared = sorted(k for k in b_keys if k in a)
+    dot = sum(a[k] * b[k] for k in shared)
+    cos = dot / (norm_a * norm_b)
+    if cos > 1.0:
+        return 1.0
+    if cos < 0.0:
+        return 0.0
+    return cos
+
+
+def relevance(
+    prompt: str,
+    response: str,
+    *,
+    idf: Mapping[str, float],
+    idf_oov: float,
+) -> float:
+    """TF*IDF weighted cosine similarity between prompt and response.
+
+    Returns 0.0 when either side has no tokens (zero-vector convention).
+    Output is bounded to [0.0, 1.0] because all TF and IDF weights are
+    non-negative, so the cosine reduces to Cauchy-Schwarz on the positive
+    orthant.
+    """
+    p_toks = _tokens_capped(prompt)
+    r_toks = _tokens_capped(response)
+    v_p = _tfidf_vector(p_toks, idf, idf_oov)
+    v_r = _tfidf_vector(r_toks, idf, idf_oov)
+    return _cosine(v_p, v_r)
+
+
+def coherence(
+    response: str,
+    *,
+    idf: Mapping[str, float],
+    idf_oov: float,
+) -> float:
+    """Mean cosine similarity of adjacent-sentence TF*IDF vectors.
+
+    Deliberate choice (v1.0): a response with fewer than two sentences
+    returns 1.0, because there is no adjacent pair that can disagree;
+    penalizing short responses on coherence would double-count what
+    ``completeness`` already measures via prompt-term coverage.
+
+    Output is bounded to [0.0, 1.0] because each pairwise cosine is in
+    [0, 1] and the arithmetic mean of values in [0, 1] is in [0, 1].
+    """
+    sents = _split_sentences_capped(response)
+    n = len(sents)
+    if n < 2:
+        return 1.0
+    vectors = [_tfidf_vector(s, idf, idf_oov) for s in sents]
+    pair_sims = [_cosine(vectors[i], vectors[i + 1]) for i in range(n - 1)]
+    return sum(pair_sims) / (n - 1)
+
+
+def completeness(
+    prompt: str,
+    response: str,
+    *,
+    idf: Mapping[str, float],
+    idf_oov: float,
+    stopwords: frozenset[str],
+) -> float:
+    """IDF-weighted fraction of prompt content terms that appear in the response.
+
+    Returns 0.0 when the prompt has no content terms (empty prompt or
+    all-stopwords prompt) since the natural ratio is 0/0; this matches the
+    input-contract requirement that an empty prompt yields 0.0.
+
+    Output is bounded to [0.0, 1.0] because ``covered`` is a subset sum of
+    the same non-negative weights that form ``total``.
+    """
+    p_toks = _tokens_capped(prompt)
+    r_toks = _tokens_capped(response)
+    key_terms = sorted({t for t in p_toks if t not in stopwords})
+    if not key_terms:
+        return 0.0
+    weights = [idf.get(t, idf_oov) for t in key_terms]
+    total = sum(weights)
+    if total == 0.0:
+        return 0.0
+    r_set = set(r_toks)
+    covered = sum(w for t, w in zip(key_terms, weights) if t in r_set)
+    return covered / total
+
+
+def conciseness(
+    response: str,
+    *,
+    stopwords: frozenset[str],
+) -> float:
+    """Content-word type-token ratio: |unique non-stopword tokens| / |all tokens|.
+
+    Penalizes padding (repetition and stopword-heavy filler) by lowering the
+    ratio; rewards information density by raising it.
+
+    Output is bounded to [0.0, 1.0] because the unique-content-token count
+    is at most the total token count.
+    """
+    toks = _tokens_capped(response)
+    total = len(toks)
+    if total == 0:
+        return 0.0
+    unique_content = {t for t in toks if t not in stopwords}
+    return len(unique_content) / total

vrty-1.0.0.dist-info/METADATA

@@ -0,0 +1,383 @@
+Metadata-Version: 2.4
+Name: vrty
+Version: 1.0.0
+Summary: Deterministic LLM-output quality scoring in milliseconds. No AI judge in the loop.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/sundeyp/vrty
+Project-URL: Repository, https://github.com/sundeyp/vrty
+Project-URL: Issues, https://github.com/sundeyp/vrty/issues
+Keywords: llm,evaluation,scoring,tf-idf,deterministic
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: <3.12,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest==8.3.3; extra == "dev"
+Dynamic: license-file
+
+# VRTY
+
+[![CI](https://github.com/sundeyp/vrty/actions/workflows/vrty.yml/badge.svg)](https://github.com/sundeyp/vrty/actions/workflows/vrty.yml)
+[![PyPI](https://img.shields.io/pypi/v/vrty.svg)](https://pypi.org/project/vrty/)
+[![Python 3.11](https://img.shields.io/badge/python-3.11.9-blue.svg)](https://www.python.org/downloads/release/python-3119/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Runtime deps: 0](https://img.shields.io/badge/runtime%20deps-0-brightgreen.svg)](pyproject.toml)
+
+**The deterministic, zero-dependency LLM evaluator. Sub-millisecond, no API key, byte-identical across runs.**
+
+*A stdlib alternative to ROUGE for no-reference scoring, and a sanity layer
+in front of GPT-as-judge when reproducibility matters.*
+
+VRTY scores a `(prompt, response)` pair on four standard, auditable
+dimensions and returns a single composite plus a per-dimension breakdown.
+Every formula is a textbook formula you can verify against a reference in
+five minutes. There is no LLM call anywhere in the scoring path.
+
+> **What VRTY does not do.** VRTY measures *surface text properties* —
+> vocabulary overlap, sentence flow, term coverage, information density.
+> **It does not check whether the answer is true.** A confident wrong answer
+> that echoes the prompt's vocabulary will score *higher* than a correct
+> one-word answer (see [Known properties and limitations](#known-properties-and-limitations):
+> `"London is the capital of France."` scores 0.879; `"Paris."` scores 0.350).
+> Use VRTY to catch malformed, off-topic, or padded output; pair it with a
+> fact-check or human review when correctness matters.
+
+```python
+from vrty import score
+result = score("What is the capital of France?", "Paris is the capital of France.")
+print(result.composite)               # 0.8653358523094898
+print(result.explanations["relevance"])  # Relevance: 0.83 - response strongly overlaps with the prompt's key terms.
+```
+
+That is the entire 60-second example. Four lines, runs as-is, returns a
+score. No configuration, no API key.
+
+> **About that 0.865.** That number is what *factoid* prompts look like —
+> short prompt, short answer, heavy vocabulary overlap. Open-ended prompts
+> (customer support, instruction-following, prose drafts) typically score
+> **0.20 – 0.40** because the response is *expected* not to echo prompt
+> vocabulary. VRTY is calibrated *relative to a fixed prompt*, not as an
+> absolute quality threshold. See [Calibration bands](#calibration-bands)
+> below before setting CI gates.
+
+---
+
+## Install
+
+```sh
+pip install vrty
+```
+
+Or from source:
+
+```sh
+git clone https://github.com/sundeyp/vrty
+cd vrty
+pip install -e .
+```
+
+Determinism is guaranteed only on the pinned interpreter (Python 3.11.9)
+and pinned dependency set. The scoring path has **zero third-party runtime
+dependencies** — everything is Python stdlib. See [Determinism](#determinism)
+below.
+
+---
+
+## The four dimensions
+
+| Dimension | Formula | What it measures |
+|---|---|---|
+| **Relevance** | TF·IDF weighted cosine similarity between prompt and response | How much the response's content overlaps the prompt's content |
+| **Coherence** | Mean cosine similarity of adjacent-sentence TF·IDF vectors | How much each sentence shares with the next (topical flow) |
+| **Completeness** | IDF-weighted fraction of prompt content terms that appear in the response | How many of the prompt's key terms are addressed |
+| **Conciseness** | `|unique content tokens| / |total tokens|` (content-word type–token ratio) | Information density vs padding |
+
+Each dimension returns a value in `[0.0, 1.0]`. The composite is a fixed,
+version-locked weighted sum:
+
+```
+composite = 0.35 * relevance
+          + 0.20 * coherence
+          + 0.30 * completeness
+          + 0.15 * conciseness
+```
+
+The weights are pinned constants, not configurable. Configurability is
+explicitly post-v1.0.
+
+---
+
+## What you get back
+
+`score()` returns a frozen `VrtyScore` object with a 9-key `to_dict()`:
+
+```python
+{
+  "composite":       0.8653358523094898,
+  "relevance":       0.8295310065985426,
+  "coherence":       1.0,
+  "completeness":    1.0,
+  "conciseness":     0.5,
+  "explanations": {
+    "relevance":    "Relevance: 0.83 - response strongly overlaps with the prompt's key terms.",
+    "coherence":    "Coherence: 1.00 - adjacent sentences carry consistent topic.",
+    "completeness": "Completeness: 1.00 - most of the prompt's key terms appear in the response.",
+    "conciseness":  "Conciseness: 0.50 - response has moderate information density."
+  },
+  "vrty_version": "1.0.0",
+  "idf_sha256":      "0e475bcaa5524d1e26cbb166bb5c138e37f87e1e47b75e6506c6460a94259fd2",
+  "weights":         {"relevance": 0.35, "coherence": 0.20, "completeness": 0.30, "conciseness": 0.15}
+}
+```
+
+`vrty_version` and `idf_sha256` make every score reproducible — together
+they pin the scoring logic and the exact IDF data used.
+
+---
+
+## CLI
+
+```sh
+vrty --prompt "What is the capital of France?" \
+        --response "Paris is the capital of France."
+```
+
+Equivalent stdlib invocation:
+
+```sh
+python -m vrty --prompt "..." --response "..."
+```
+
+Accepts `--prompt-file PATH` / `--response-file PATH` for long inputs;
+`/dev/stdin` works as a file path. `--pretty` indents the JSON.
+Exit codes: `0` success, `1` I/O error, `2` argparse error.
+
+---
+
+## Benchmarks
+
+VRTY is not an embedding-based scorer; if you need semantic similarity that
+survives paraphrase, use **BERTScore** or **MoverScore**. VRTY is not n-gram
+precision against a reference; if you have reference answers, use **BLEU**
+or **ROUGE**. VRTY's niche is *no-reference, no-model, deterministic*
+scoring — the gap ROUGE leaves when you don't have a gold reference, and
+the gap GPT-as-judge leaves when you need reproducibility.
+
+Reproducibility, cost, and latency vs ROUGE and LLM-as-judge. VRTY and
+ROUGE were measured on the same machine with the same 1000 synthetic
+(prompt, response) pairs per response-size bucket; reproduce via
+`python tools/benchmark.py`. LLM-as-judge cost and latency are intentionally
+not measured here — they depend on model choice and provider pricing, both
+of which drift; fill them in for your own model before relying on the
+comparison.
+
+|                        | VRTY | ROUGE (rouge-score 0.1.2) | LLM-as-judge |
+|------------------------|------|---------------------------|--------------|
+| **Reproducibility**    | Byte-identical across processes (pinned Python 3.11.9, asserted in CI on three subprocesses with adversarial `PYTHONHASHSEED` values) | Deterministic for a fixed tokenizer | Non-deterministic; varies with temperature, sampling, model version |
+| **Cost per score**     | $0 (no API call) | $0 (local) | $ per call × tokens; measure with your chosen model |
+| **Latency p99 — 100 tokens**  | **0.16 ms** | 1.66 ms | typically 500–2000 ms (network + inference) |
+| **Latency p99 — 500 tokens**  | **0.52 ms** | 6.66 ms | typically 500–2000 ms |
+| **Latency p99 — 2000 tokens** | **2.94 ms** | 25.96 ms | typically 1000–5000 ms |
+| **Network required**   | No | No | Yes |
+| **Reference hardware** | AMD Ryzen 7 8745HS, 16 cores, 27 GiB RAM, Ubuntu 24.04, Python 3.11.9 | (same) | (varies by provider) |
+
+**Latency claim (v1.0)**: `< 3 ms p99 for responses under 2000 tokens on
+AMD Ryzen 7 8745HS`. Reproduce: `python tools/benchmark.py` from a clean
+venv with `vrty` and `rouge-score==0.1.2` installed.
+
+VRTY is roughly **9–10× faster than ROUGE** at every input size in this
+table because the scoring path is pure stdlib with no regex-based stemmer
+and no sentence-pair grid construction.
+
+---
+
+## Calibration bands
+
+Expected composite ranges by prompt type, observed across realistic input.
+Use these to set CI gates and user-facing displays — do not assume a single
+threshold works across prompt types.
+
+| Prompt type | Typical composite | Use the score as |
+|---|---|---|
+| Factoid Q&A where the answer echoes prompt vocabulary (`"capital of France?"` → `"Paris is the capital of France."`) | 0.70 – 0.90 | Absolute threshold viable |
+| Customer-support / instruction-following | 0.20 – 0.40 | Relative delta from a baseline answer on the *same* prompt |
+| Open-ended prose (email drafts, summaries) | 0.15 – 0.35 | Relative delta only |
+| Repetition / padding spam with OOV technical terms | can score 0.60+ | Catch by pairing with a length / repetition sanity check |
+
+**Practical rule.** Compute a baseline composite on a known-good response
+to your prompt, then gate on `score >= baseline * k` for some
+`k ∈ [0.7, 0.9]`. Do not gate on `composite > 0.8` as an absolute — that
+will fire false-negative on obviously-fine open-ended responses.
+
+---
+
+## Determinism
+
+Identical input returns byte-identical output. This guarantee holds under
+the following conditions, all of which are documented and enforced:
+
+- **Pinned interpreter**: Python 3.11.9 (CPython, official build or
+  python-build-standalone). The CI matrix runs on this version. Other 3.x
+  versions are likely to produce identical output but are not asserted.
+- **Pinned IDF data**: `vrty/data/idf.json.gz` ships with the package
+  and is SHA-256-verified at import. A modified data file fails fast with
+  `VrtyDataError` before any score is computed.
+- **Zero third-party runtime dependencies**: the scoring path uses only
+  CPython stdlib (`re`, `math`, `collections`, `json`, `gzip`,
+  `hashlib`, `importlib.resources`, `unicodedata`). No `numpy`, no
+  `scikit-learn`, no BLAS-backed FP variance.
+- **Sort-before-reduction**: every set and dict is sorted before any
+  floating-point accumulation, so dict-iteration order under
+  `PYTHONHASHSEED` randomization cannot change the result.
+
+The test suite asserts byte-identity on `json.dumps(result.to_dict(),
+sort_keys=True)` across three fresh OS subprocesses with `PYTHONHASHSEED`
+set to `0`, `12345`, and the CPython default (`random`).
+
+---
+
+## Self-host
+
+A one-command Docker self-host is shipped alongside the library. See the
+[Dockerfile](Dockerfile) for the pinned image and the
+[GitHub Actions snippet](.github/workflows/vrty.yml) for CI/CD
+integration.
+
+```sh
+docker build -t vrty:1.0.0 .
+docker run --rm vrty:1.0.0 \
+  --prompt "What is the capital of France?" \
+  --response "Paris is the capital of France."
+```
+
+---
+
+## Known properties and limitations
+
+**Read this section before integrating VRTY into anything load-bearing.**
+Seven honest limitations of the v1.0 design.
+
+### 1. VRTY scores surface properties, not factual correctness
+
+The four dimensions measure **term overlap, sentence flow, key-term
+coverage, and information density**. They do *not* verify that the response
+is factually true. A correct answer that does not echo prompt vocabulary
+scores low on relevance and completeness; a confident wrong answer that
+echoes prompt vocabulary scores high.
+
+Worked example, prompt = `"What is the capital of France?"`:
+
+| Response                                  | Correct? | Composite | Relevance | Completeness | Conciseness |
+|-------------------------------------------|----------|-----------|-----------|--------------|-------------|
+| `"Paris is the capital of France."`       | yes      | 0.865     | 0.830     | 1.000        | 0.500       |
+| `"London is the capital of France."`      | **no**   | 0.879     | 0.867     | 1.000        | 0.500       |
+| `"Paris."`                                | yes      | 0.350     | 0.000     | 0.000        | 1.000       |
+| `"London."`                               | **no**   | 0.350     | 0.000     | 0.000        | 1.000       |
+| `"Banana."`                               | **no**   | 0.350     | 0.000     | 0.000        | 1.000       |
+
+The verbose incorrect answer scores *higher* than the verbose correct one
+(slight IDF asymmetry between `"london"` and `"paris"` in the bundled
+corpus); the three terse responses — one correct, two wrong — receive
+identical 0.350 scores. **VRTY cannot distinguish them; an external
+fact-check must.** Use VRTY to detect malformed, off-topic, or padded
+outputs; use a separate fact-check or human review to verify truth.
+
+### 2. Conciseness and completeness intentionally pull against each other
+
+A response that covers every prompt term tends to be longer (lower
+conciseness); a terse response tends to omit prompt terms (lower
+completeness). This tension is correct behavior, not a bug. Always read
+the per-dimension breakdown — a single composite hides the trade-off.
+
+### 3. Single-sentence coherence returns 1.0 by deliberate choice
+
+When the response is one sentence (or zero — see the empty-response
+wrapper), there is no adjacent-sentence pair that can disagree, so
+coherence is set to 1.0. This is a deliberate v1.0 convention: penalizing
+short responses on coherence would double-count what completeness already
+measures via prompt-term coverage.
+
+### 4. OOV tokens receive maximum IDF weight by deliberate choice
+
+Tokens not present in the bundled IDF corpus are assigned `idf_oov =
+log(N+1) + 1`, the value the smoothed IDF formula assigns to a token that
+appears in zero documents. This treats unseen words as maximally
+informative — the standard add-one (Laplace) smoothing choice — so
+technical jargon and proper nouns are not silently dropped to zero weight.
+
+### 5. Conciseness is a type–token ratio, which is mildly length-sensitive
+
+The conciseness measure (`|unique content tokens| / |total tokens|`) tends
+to decline for longer responses because the vocabulary saturates while the
+length keeps growing. This is a known property of the type–token ratio
+(Hess et al. 1986). Two responses of very different lengths are not
+directly comparable on conciseness alone; interpret the conciseness score
+together with the other dimensions and the response length.
+
+### 6. Repetition can score high when prompt terms are out-of-corpus
+
+Because OOV tokens receive maximum IDF weight (limitation 4 above) and
+conciseness is a type–token ratio (limitation 5), a response that *repeats*
+OOV technical terms (e.g. `"multi-head multi-head attention attention
+attention transformer transformer transformer."` against a transformer-
+architecture prompt) can score *higher* than a substantive paragraph on the
+same prompt. Mitigation: combine the VRTY composite with a basic length /
+repetition sanity check, or treat the composite as one signal among
+several. This is a known property of TF·IDF-family scorers, not unique to
+VRTY.
+
+### 7. The bundled IDF corpus is 19th-century English literature
+
+IDF weights are computed from ten US-public-domain Project Gutenberg books
+(Austen, Melville, Shelley, Doyle, Stoker, Carroll, Wilde, Dickens, Wells,
+Thoreau) — about 5,400 200-token pseudo-documents, 32,000-word vocabulary.
+Modern technical vocabulary like `"API"`, `"endpoint"`, `"deploy"`,
+`"kubernetes"`, `"async"` is not in the corpus and falls into the OOV
+bucket, where it receives the maximum IDF weight (see limitation 4).
+
+This generally *helps* technical text (rare jargon is correctly treated as
+informative) but can cause uneven weighting when one technical term is
+in-corpus by coincidence and a similar one is not. **A domain-matched IDF
+corpus is explicitly post-v1.0**; v1.0 disclaims this rather than fixes it.
+Non-English text scores as-is with no special handling and is similarly
+disclaimed.
+
+---
+
+## Input contract
+
+Behavior on degenerate inputs is part of the v1.0 spec, not an afterthought:
+
+| Input                                | Behavior                                                       |
+|--------------------------------------|----------------------------------------------------------------|
+| Empty response                       | Every dimension and the composite return `0.0`; explanations say "response contained no scorable tokens." |
+| Empty prompt                         | Relevance and completeness return `0.0`; coherence and conciseness depend only on the response and score normally |
+| Inputs above 2,048 tokens            | Truncated at 2,048 tokens (the `MAX_TOKENS` constant) before scoring; truncation is deterministic |
+| Non-English text                     | NFKD-normalized then ASCII-stripped; accented Latin folds to base letters; non-Latin scripts (CJK, Cyrillic, Arabic, ...) drop entirely. Quality outside English is not claimed |
+| Response identical to prompt         | Scored normally; no special case |
+| Single word                          | Scored normally; no special case |
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+---
+
+## Versioning
+
+`vrty_version` is included with every score so any historical score is
+traceable to the exact scoring logic that produced it. The bundled IDF
+data file's SHA-256 (`idf_sha256`) is also returned with every score so
+two scores from different builds can be compared at the data-pinning
+level, not just the code level. Bumping either invalidates byte-equality
+guarantees and requires a version bump.
+
+A score from `vrty_version="1.0.0"` will be reproducible on any future
+machine that installs `vrty==1.0.0` on Python 3.11.9.

vrty-1.0.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+vrty/__init__.py,sha256=FuO6yoQu5IJlc52VTLvsRttDXf_1fUD0CjhIQfqfQ_g,481
+vrty/__main__.py,sha256=rjEjw22ZO5ZfIEbogmMPgccN-9VT4jUvslVGWSfNung,152
+vrty/_version.py,sha256=iedBM6zdqUuotYZ25tysjwduWBcIlTWp315wwuTyX48,270
+vrty/cli.py,sha256=RPtlpjnBqzqCGY61tOxMDxV9wSFjqFscivxET2tAjsY,4004
+vrty/composite.py,sha256=3kphBJHQSD2A5lBfTtIsWJr_Z_peJQ9SGLTs1fCOtO0,6056
+vrty/data_loader.py,sha256=btIKFpt-m1ZU6J-Th4g4I2cN-mNye175ANG-YXFDW3c,3677
+vrty/explanations.py,sha256=HV4GiKT5Ai0VBz-huzC082D8VA59WXjKoqGtjymCcdo,4368
+vrty/scoring.py,sha256=jXvrVHlP7eDMUiKrpxRwJC5R4CUz1Ek_st0RJKtl5I0,7310
+vrty/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vrty/data/idf.json.gz,sha256=DkdbyqVSTR4my7Fmu1wTjjf4fh5Ht15lBsZGCpQln9I,156772
+vrty-1.0.0.dist-info/licenses/LICENSE,sha256=b5p2_hBoBQO3yov45_wNuciWEOWm3KER1ZeMVQUi_1Q,1070
+vrty-1.0.0.dist-info/METADATA,sha256=KNWP-jfjsTyUnObYf8yJuLCwsLDadPZW-yvc5FtZ_EY,17924
+vrty-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+vrty-1.0.0.dist-info/entry_points.txt,sha256=pZ1sNJwW3NlNPzuhoZlPpy2yzfclj_oJU941t7EFlaA,39
+vrty-1.0.0.dist-info/top_level.txt,sha256=YnCtW1sB6RTMnnvz_AVLu6OFv01PCx1i2oEVMPIntsI,5
+vrty-1.0.0.dist-info/RECORD,,

vrty-1.0.0.dist-info/WHEEL

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

vrty-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+vrty = vrty.cli:main

vrty-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sundeyp Singh
+
+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.

vrty-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+vrty