modelspec-dev 0.1.0__py3-none-any.whl

decision/vocabulary.py

@@ -0,0 +1,433 @@
+"""The decision vocabulary: what a spec can name, as data (MODEL-153).
+
+The site build writes it to ``/api/decision/vocabulary.json`` beside the
+decision snapshot it describes, so a client (the decide page) never carries a
+list of facets or benchmarks of its own:
+
+* ``facets``: every registered facet except the parameterised families
+  (``evidence.benchmark`` and the like, whose members are the benchmarks
+  below), with its label, unit, subject, value type, the condition operators
+  that type admits, whether it can be an objective, and how much of the
+  snapshot's lineup knows it (``known`` of ``of``), with the values or the
+  range it takes there. A facet no lineup candidate knows is listed with
+  ``known: 0``; a client should not offer it.
+* ``benchmarks``: every benchmark with verified evidence in the snapshot, with
+  its name, unit, domains and directness, how many lineup models have a
+  verified row (``models``), how many have one not reported by their own lab
+  (``independent_models``), and the range of those values. A benchmark with
+  none is not listed.
+* ``domains``: every registered domain with a listed benchmark, its capability
+  estimate coverage, and its benchmarks ordered for the explicit drill-down.
+* ``models``: every lineup and archive model, by ID, with the ``display_name``
+  and lab (``lab``, ``lab_name``) its card gives. A name the card does not
+  give is ``null``; a client shows the ID, never a name made from the slug.
+* ``providers``: every registered provider's display name, by ID.
+* ``coverage``: what the lineup holds, so a client can say what an empty
+  answer was measured against without writing it per question. ``models`` is
+  the lineup size and ``verified`` how many of those have at least one verified
+  evidence row; ``as_of`` is the snapshot date. ``classes`` lists every
+  registered model class (zeros included) with the same two counts and, per
+  domain, how many of its models have verified evidence there. ``domains``
+  lists every registered domain with how many lineup models have verified
+  evidence on any benchmark tagged to it (``verified``) and on a direct one
+  (``direct``).
+
+Operators are the compact condition forms: ``=``, ``!=``, ``<``, ``<=``,
+``>``, ``>=``, ``between`` (``facet in [low, high]``), ``in`` and ``not in``
+(``facet in {a, b}``), and ``known`` (``known(facet)``).
+"""
+
+from __future__ import annotations
+
+import typing
+from collections import Counter
+from collections.abc import Iterable, Mapping
+from typing import Any
+
+from decision.computed import with_computed
+from decision.contract import (
+    CONTRACT_VERSION,
+    DEFAULT_TASK_TOKENS,
+    AllOf,
+    AnyOf,
+    Known,
+    NotOf,
+    TaskType,
+    parse_spec,
+)
+from decision.engine import decide
+from decision.filter import _INDEPENDENT as INDEPENDENT_MEASURERS
+from decision.templates import load_templates
+
+VOCABULARY_VERSION = 1
+MIN_FRONTIER_COVERAGE = 0.50
+
+_ORDERED = ("=", "!=", "<", "<=", ">", ">=", "between")
+OPERATORS: Mapping[str, tuple[str, ...]] = {
+    "number": (*_ORDERED, "known"),
+    "date": (*_ORDERED, "known"),
+    "enum": ("=", "!=", "in", "not in", "known"),
+    "boolean": ("=", "!=", "known"),
+    "set": ("in", "not in", "known"),
+}
+_LITERALS = ("unbounded", "not_offered")
+
+
+class FrontierCoverageError(ValueError):
+    """A domain's default basis would leave most directly measured models unranked."""
+
+
+def _lineup(snapshot: Any) -> list[str]:
+    return [cid for cid in snapshot.candidates() if snapshot.lifecycle(cid) != "retired"]
+
+
+def frontier_coverage(
+    snapshot: Any,
+    domain_id: str,
+    *,
+    benchmark: str | None = None,
+) -> dict[str, float | int]:
+    """Coverage of one ranking basis among lineup models with direct evidence.
+
+    With no ``benchmark``, the basis is the stored domain capability estimate.
+    Passing a benchmark measures the counterfactual single-benchmark basis used
+    by the page's explicit "Measured by" drill-down.
+    """
+    lineup = _lineup(snapshot)
+    by_model: dict[str, list[str]] = {}
+    for candidate in lineup:
+        by_model.setdefault(snapshot.model_of(candidate), []).append(candidate)
+    direct_benchmarks = {
+        benchmark_id
+        for benchmark_id, tags in snapshot.benchmark_domain_tags().items()
+        if (domain_id, "direct") in tags
+    }
+    direct = {
+        model_id
+        for model_id, candidates in by_model.items()
+        if any(
+            row.verified and row.benchmark_id in direct_benchmarks
+            for candidate in candidates
+            for row in snapshot.evidence_for_domain(candidate, domain_id)
+        )
+    }
+    if benchmark is None:
+        ranked = {
+            model_id
+            for model_id in direct
+            if any(
+                snapshot.capability_estimate(candidate, domain_id) is not None
+                for candidate in by_model[model_id]
+            )
+        }
+    else:
+        ranked = {
+            model_id
+            for model_id in direct
+            if any(
+                row.verified
+                for candidate in by_model[model_id]
+                for row in snapshot.evidence(candidate, benchmark)
+            )
+        }
+    ratio = len(ranked) / len(direct) if direct else 1.0
+    return {"ranked": len(ranked), "direct": len(direct), "ratio": ratio}
+
+
+def _estimate_models(snapshot: Any, domain_id: str) -> int:
+    """How many distinct lineup models have a stored estimate for ``domain_id``."""
+    models: set[str] = set()
+    for candidate in _lineup(snapshot):
+        if snapshot.capability_estimate(candidate, domain_id) is not None:
+            models.add(snapshot.model_of(candidate))
+    return len(models)
+
+
+def require_frontier_coverage(
+    snapshot: Any,
+    domain_id: str,
+    *,
+    benchmark: str | None = None,
+) -> dict[str, float | int]:
+    """Fail when a proposed default basis ranks less than half the frontier."""
+    coverage = frontier_coverage(snapshot, domain_id, benchmark=benchmark)
+    if coverage["direct"] and coverage["ratio"] < MIN_FRONTIER_COVERAGE:
+        basis = benchmark or f"{domain_id} capability estimate"
+        raise FrontierCoverageError(
+            f"{domain_id}: default basis {basis} ranks {coverage['ranked']} of "
+            f"{coverage['direct']} lineup models with direct evidence "
+            f"({coverage['ratio']:.1%}); minimum is {MIN_FRONTIER_COVERAGE:.0%}"
+        )
+    return coverage
+
+
+def _number(value: Any) -> float | None:
+    if isinstance(value, bool) or not isinstance(value, int | float):
+        return None
+    return value
+
+
+def _facet_row(facet: Any, snapshot: Any, subjects: Iterable[str], unit_definition: str | None,
+               ) -> dict[str, Any]:
+    kind = facet.value_type.kind
+    subjects = list(subjects)
+    values: list[Any] = []
+    for cid in subjects:
+        fact = snapshot.fact(cid, facet.id)
+        if fact.state == "known" and fact.value is not None:
+            values.append(fact.value)
+    row: dict[str, Any] = {
+        "id": facet.id,
+        "label": facet.label or facet.id,
+        "definition": facet.definition,
+        "subject": facet.subject,
+        "value_type": kind,
+        "unit": facet.unit,
+        "unit_definition": unit_definition,
+        "operators": list(OPERATORS[kind]),
+        "objective": kind == "number",
+        "risk": facet.risk,
+        "computed_by": facet.computed_by,
+        "known": len(values),
+        "of": len(subjects),
+    }
+    if kind == "number":
+        numbers = [n for n in map(_number, values) if n is not None]
+        row["range"] = {"min": min(numbers), "max": max(numbers)} if numbers else None
+    elif kind == "date":
+        dates = sorted(str(v) for v in values)
+        row["range"] = {"min": dates[0], "max": dates[-1]} if dates else None
+    if kind == "number":
+        literals = sorted({v for v in values if v in _LITERALS})
+        if literals:
+            row["literals"] = literals
+    elif kind in ("enum", "boolean", "set"):
+        counts: Counter[Any] = Counter()
+        for value in values:
+            counts.update(set(value) if isinstance(value, list) else {value})
+        row["values"] = [
+            {"value": v, "count": counts[v],
+             **({"label": label} if isinstance(v, str) and (label := facet.value_label(v))
+                else {})}
+            for v in sorted(counts, key=lambda v: (str(type(v)), str(v)))]
+    return row
+
+
+def _benchmark_rows(snapshot: Any, lineup: list[str], pages: Mapping[str, Mapping[str, Any]],
+                    ) -> list[dict[str, Any]]:
+    tags = snapshot.benchmark_domain_tags()
+    rows = []
+    for benchmark in snapshot.benchmark_ids():
+        models: set[str] = set()
+        independent: set[str] = set()
+        units: Counter[str] = Counter()
+        scores: list[float] = []
+        for cid in lineup:
+            found = [e for e in snapshot.evidence(cid, benchmark) if e.verified]
+            if found:
+                models.add(snapshot.model_of(cid))
+                units.update(e.unit for e in found if e.unit)
+                scores.extend(e.value for e in found)
+            if any(e.measured_by in INDEPENDENT_MEASURERS for e in found):
+                independent.add(snapshot.model_of(cid))
+        if not models:
+            continue
+        page = pages.get(benchmark) or {}
+        metric = page.get("metric") or {}
+        unit = sorted(units.items(), key=lambda item: (-item[1], item[0]))[0][0] if units else None
+        rows.append({
+            "id": benchmark,
+            "name": str(page.get("name") or benchmark),
+            "unit": unit,
+            "higher_is_better": metric.get("direction", "higher_is_better") != "lower_is_better",
+            "models": len(models),
+            "independent_models": len(independent),
+            "range": {"min": min(scores), "max": max(scores)},
+            "domains": [{"id": d, "directness": k} for d, k in tags.get(benchmark, ())],
+        })
+    return rows
+
+
+def _model_rows(snapshot: Any, cards: Mapping[str, Mapping[str, Any]],
+                ) -> dict[str, dict[str, Any]]:
+    rows = {}
+    for mid in sorted({snapshot.model_of(cid) for cid in snapshot.candidates()}):
+        card = cards.get(mid) or {}
+        rows[mid] = {
+            "display_name": card.get("display_name") or None,
+            "lab": card.get("provider") or mid.split("/", 1)[0],
+            "lab_name": card.get("provider_display") or None,
+        }
+    return rows
+
+
+def _coverage(snapshot: Any, lineup: list[str], registry: Any) -> dict[str, Any]:
+    tags = snapshot.benchmark_domain_tags()
+    class_of: dict[str, Any] = {}
+    for cid in lineup:
+        if snapshot.kind(cid) == "model":
+            class_of[snapshot.model_of(cid)] = snapshot.fact(cid, "model.class").value
+    verified: dict[str, set[str]] = {}  # model -> benchmarks with a verified row
+    for cid in lineup:
+        for benchmark in snapshot.benchmark_ids():
+            if any(e.verified for e in snapshot.evidence(cid, benchmark)):
+                verified.setdefault(snapshot.model_of(cid), set()).add(benchmark)
+
+    def in_domain(mid: str, domain: str, *, direct: bool = False) -> bool:
+        return any(d == domain and (not direct or k == "direct")
+                   for b in verified.get(mid, ()) for d, k in tags.get(b, ()))
+
+    domains = registry.domains()
+    classes = []
+    for class_id in sorted(registry.allowed_values(registry.facet("model.class")) or ()):
+        members = [mid for mid, cls in class_of.items() if cls == class_id]
+        per_domain = [{"id": d.id, "verified": n} for d in domains
+                      if (n := sum(in_domain(mid, d.id) for mid in members))]
+        classes.append({
+            "id": class_id,
+            "models": len(members),
+            "verified": sum(mid in verified for mid in members),
+            "domains": sorted(per_domain, key=lambda row: (-row["verified"], row["id"])),
+        })
+    return {
+        "as_of": snapshot.as_of.isoformat() if snapshot.as_of else None,
+        "models": len(class_of),
+        "verified": sum(mid in verified for mid in class_of),
+        "classes": classes,
+        "domains": [{
+            "id": d.id,
+            "name": d.name,
+            "verified": sum(in_domain(mid, d.id) for mid in class_of),
+            "direct": sum(in_domain(mid, d.id, direct=True) for mid in class_of),
+        } for d in domains],
+    }
+
+
+def _condition_facet(condition: Any) -> str | None:
+    if isinstance(condition, (AnyOf, AllOf)):
+        children = condition.any if isinstance(condition, AnyOf) else condition.all
+        facets = {_condition_facet(child) for child in children}
+        return facets.pop() if len(facets) == 1 else None
+    if isinstance(condition, NotOf):
+        return _condition_facet(condition.not_)
+    return condition.known if isinstance(condition, Known) else condition.facet
+
+
+def _unavailable_reason(
+    decision: Any, funnel: Iterable[Any], template_id: str, registry: Any
+) -> str:
+    """Describe the decision stage that left a template without an answer."""
+    for step in funnel:
+        if step.after or step.may_qualify:
+            continue
+        facet_id = _condition_facet(step._condition)
+        facet = registry.facet(facet_id) if facet_id else None
+        subject = facet.subject if facet else "candidate"
+        label = facet.label if facet and facet.label else step.condition
+        if template_id == "eu-data" and facet_id == "offering.region":
+            label = "Inference region in the EU"
+        before = step.offerings_before if subject == "offering" else step.models_before
+        noun = subject if before == 1 else f"{subject}s"
+        return f"No {subject} passes: {label} — 0 of {before} {noun}"
+    if decision.relax_to:
+        change = decision.relax_to[0]
+        return f"No feasible result; relax {change.condition} to {change.relaxed}."
+    if decision.relax:
+        return f"No feasible result; relax {decision.relax[0]}."
+    return "No feasible result."
+
+
+def _template_rows(snapshot: Any, registry: Any) -> list[dict[str, Any]]:
+    """Templates plus answerability proven by the real decision engine."""
+    rows = []
+    for template in load_templates(registry=registry):
+        spec = parse_spec(template["spec"] | {"explain": "none"}, facets=registry.facet)
+        trace = []
+        decision = decide(spec, snapshot, facets=registry.facet, _filter_trace=trace.append)
+        available = bool(decision.results or decision.may_qualify)
+        rows.append(template | {
+            "available": available,
+            "unavailable_reason": None if available else _unavailable_reason(
+                decision, trace[0].funnel, template["id"], registry
+            ),
+        })
+    return rows
+
+
+def build_vocabulary(snapshot: Any, *, pages: Mapping[str, Mapping[str, Any]] | None = None,
+                     registry: Any = None, cards: Mapping[str, Mapping[str, Any]] | None = None,
+                     enforce_frontier_coverage: bool = False,
+                     ) -> dict[str, Any]:
+    """The vocabulary of ``snapshot``. ``pages`` maps benchmark IDs to their page
+    front matter (for names and metric direction); ``cards`` maps model IDs to
+    their card front matter (for display and lab names); ``registry`` defaults
+    to the repository's own. Load ``snapshot`` with its archive to name
+    archived models too."""
+    if registry is None:
+        from decision.registry import default
+
+        registry = default()
+    view = with_computed(snapshot, DEFAULT_TASK_TOKENS)
+    lineup = _lineup(view)
+    by_kind = {kind: [cid for cid in lineup if view.kind(cid) == kind]
+               for kind in ("model", "offering")}
+    facets = []
+    for facet in registry.facets():
+        if facet.parameter is not None:
+            continue
+        unit = registry.unit(facet.unit).definition if facet.unit else None
+        facets.append(_facet_row(facet, view, by_kind[facet.subject], unit))
+    benchmarks = _benchmark_rows(view, lineup, pages or {})
+    covered = {row["id"]: row for row in benchmarks}
+    domains = []
+    for domain in registry.domains():
+        members = [b for b in covered.values()
+                   if any(tag["id"] == domain.id for tag in b["domains"])]
+        if not members:
+            continue
+
+        estimate_coverage = (
+            require_frontier_coverage(snapshot, domain.id)
+            if enforce_frontier_coverage
+            else frontier_coverage(snapshot, domain.id)
+        )
+
+        # The registry preference leads the explicit drill-down only when it
+        # has verified lineup evidence. The domain estimate remains default.
+        default = (domain.default_benchmark
+                   if any(b["id"] == domain.default_benchmark and b["models"] > 0
+                          for b in members) else None)
+
+        def order(row: Mapping[str, Any], domain_id: str = domain.id,
+                  default: str | None = default) -> tuple[Any, ...]:
+            direct = any(t == {"id": domain_id, "directness": "direct"} for t in row["domains"])
+            return (row["id"] != default, not direct, -row["models"], row["id"])
+
+        domains.append({
+            "id": domain.id,
+            "name": domain.name,
+            "proxy_only": domain.proxy_only,
+            "default_basis": "capability_estimate",
+            "estimate_models": _estimate_models(snapshot, domain.id),
+            "direct_models": estimate_coverage["direct"],
+            # Kept only to preselect the explicit benchmark drill-down. It is
+            # never the domain's default ranking basis.
+            "default_benchmark": default,
+            "benchmarks": [row["id"] for row in sorted(members, key=order)],
+        })
+    coverage = _coverage(view, lineup, registry)
+    return {
+        "vocabulary_version": VOCABULARY_VERSION,
+        "contract_version": CONTRACT_VERSION,
+        "snapshot": snapshot.snapshot_id,
+        "default_task_tokens": {"input": DEFAULT_TASK_TOKENS.input,
+                                "output": DEFAULT_TASK_TOKENS.output},
+        "task_types": list(typing.get_args(TaskType)),
+        "facets": facets,
+        "benchmarks": benchmarks,
+        "domains": domains,
+        "models": _model_rows(snapshot, cards or {}),
+        "providers": {p.id: p.name for p in registry.providers()},
+        "coverage": coverage,
+        "templates": _template_rows(snapshot, registry),
+    }

modelspec_dev-0.1.0.dist-info/METADATA

@@ -0,0 +1,101 @@
+Metadata-Version: 2.5
+Name: modelspec-dev
+Version: 0.1.0
+Summary: A sourced model decision engine with an offline command-line interface
+Project-URL: Homepage, https://modelspec.dev
+Project-URL: Repository, https://github.com/turbobeest/modelspec
+Project-URL: Documentation, https://github.com/turbobeest/modelspec/tree/main/docs
+License-Expression: MIT
+License-File: LICENSE
+License-File: LICENSE-DATA
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Requires-Dist: click>=8.0
+Requires-Dist: falkordb>=1.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest-xdist==3.8.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: researcher
+Requires-Dist: anthropic>=0.39; extra == 'researcher'
+Requires-Dist: beautifulsoup4>=4.12; extra == 'researcher'
+Requires-Dist: celery>=5.4; extra == 'researcher'
+Description-Content-Type: text/markdown
+
+<p align="center">
+<img width="2816" height="797" alt="modelspec" src="https://github.com/user-attachments/assets/1e344d67-605d-4577-8ea4-84148d5ae3d5" />
+</p>
+
+ModelSpec catalogs AI models as YAML+Markdown cards, exports them to versioned JSON on Cloudflare Pages ([modelspec.dev](https://modelspec.dev)), and ranks from that export — in the browser, or offline from a local snapshot. **No database is on the serving path.**
+
+- Site: [modelspec.dev](https://modelspec.dev) · [graph](https://modelspec.dev/graph/) · [downselect](https://modelspec.dev/downselect/)
+- CLI contract: [`docs/cli-contract.md`](docs/cli-contract.md)
+- Current state: [`docs/handoff/current.md`](docs/handoff/current.md)
+- Agent entry: [`AGENTS.md`](AGENTS.md)
+
+## Quick start
+
+```bash
+pipx install modelspec-dev
+modelspec snapshot fetch
+modelspec offline rank coding --json
+```
+
+`snapshot fetch` is the only networked command. After that, rank and fit read the cache.
+
+The supported interface is [`docs/cli-contract.md`](docs/cli-contract.md):
+
+```
+modelspec snapshot fetch [--origin URL]
+modelspec snapshot status [--json]
+modelspec offline rank <use-case> [...]
+modelspec offline fit [<hardware-id>]
+```
+
+Graph commands (`stats`, `search`, `info`, `compare`, `rank`, `hardware`, …) need a local FalkorDB and are outside this contract.
+
+## Serving path
+
+```
+models/*.md ──▶ pipeline/build.py ──▶ static JSON on Cloudflare Pages
+                                      (modelspec.dev /api/*.json)
+                                            │
+CLI `snapshot fetch` ───────────────────────┘
+Wizard / 3D graph read the same JSON in the browser.
+```
+
+FalkorDB is optional local graph exploration only. It is not required to rank, fit, or render the sites.
+
+## Contribute
+
+Read [`CONTRIBUTING.md`](CONTRIBUTING.md). Sign off commits (`git commit -s`) to certify the [`DCO`](DCO) — not a copyright assignment. Every fact carries a source and the date it was read; unknown means an empty field.
+
+Cards live in `models/{provider}/{model-slug}.md`. Edit and open a PR.
+
+## License
+
+Two licences, because the code and the corpus want different things.
+
+| Part | Licence |
+| --- | --- |
+| Code (everything outside the data directories) | MIT |
+| Data (`models/`, `benchmarks/`, `hardware/`, `hosts/`) | CC BY-SA 4.0 |
+
+The corpus is share-alike: build on it, including commercially, but if you redistribute it or a derivative, credit ModelSpec and publish yours under the same terms. The code is permissive so the CLI can go anywhere. Full text in [`LICENSE`](LICENSE) and [`LICENSE-DATA`](LICENSE-DATA).
+
+Every card and page records the sources it draws on and the date each was read. Those sources keep their own licences.

modelspec_dev-0.1.0.dist-info/RECORD

@@ -0,0 +1,63 @@
+cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cli/modelspec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cli/modelspec/cli.py,sha256=oOflhvfSGJqFgTfSw06zA0QNiSje4LuwKMRt4r6D9uE,70636
+cli/modelspec/decide_cmd.py,sha256=1eCDlagaLpylCkzKU11ykvr10Z3R6hqPeLgfIDk1vxE,13732
+cli/modelspec/offline.py,sha256=VD9GA9oCtbOqcnjtmeicVukUl-EsO3y4rxHSPA47uM8,28566
+cli/modelspec/snapshot.py,sha256=GihusgRdcO8V99VoRn0BQ6LFKSH5rnygTMnc_5wr4Ag,29522
+cli/modelspec/snapshot_build_cmd.py,sha256=g6J3q9knDUl_w3yKJeQiCS_Cyqo5uGpN_9ci74d-I_g,2217
+cli/modelspec/verify_cmd.py,sha256=wNs5uLi_pymxUdsvvr9DtbACBNLCElj5QIXe2YymxAI,5038
+cli/modelspec/vocab_cmd.py,sha256=Kpttxbb19S8qqyU6bzp44XK8pOYryfcabNPiTYcP_As,8376
+cli/modelspec/vocabulary_cache.py,sha256=RCvQCgyL2sGX_bgx9e-rFSFTtePa8Cxa6gfcvQI1ufM,1915
+cli/modelspec/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+decision/__init__.py,sha256=iJ3qiMH-cOBNGmcmICoS6iIy48RqdfzST_AFLk8fG_s,588
+decision/capability.py,sha256=Tm8qNH_ELQIQnJ9uhNAIsSfqVHRn5CEDwqAPscpU8Gg,35652
+decision/computed.py,sha256=uaH2aGuNGyR5dlfa52pYemxvCHYB-JEihBoLpWhOamk,4949
+decision/contract.py,sha256=lxJSRhU7Niq3TGw3wkwPkRgs0iG1esQfAxocarS5cP4,59327
+decision/engine.py,sha256=4DMnEMi4ehjDGMG5LsfQr5nBEmcDaxUVrXs-WAQwd4w,8806
+decision/excluded.py,sha256=xAAqMJqtcQIzeRmIA4R3yEiCEM5Q2gnpqUmIeF_7Z1Q,1150
+decision/explain.py,sha256=iFg4KTlk0hsQsnoyhiXjFdJA2Btgr-BdFS7vGiHlprE,38488
+decision/filter.py,sha256=X4OpQCNyhcg7Ig_qeT-Yt53oXMTDB0-iNTCCX-TnfjM,29489
+decision/model.py,sha256=XpsThjL_RdVW1csb8SH3x2SMN1QdIFi5fdToCg7PWIQ,15402
+decision/normalise.py,sha256=1mVi-Lnlz_dNHK6oDhTuwo2-TFQAhPZ-NqIWE0i7BA4,19718
+decision/optimise.py,sha256=3ZM8SyukjuxV5t6F0OexJYvQhMzD0kGF1sTDlVO2CrA,13951
+decision/registry.py,sha256=h5zw1Fo0aoAYfjLyfUrf3o-xXhidH0GxRcFqadtRze0,29853
+decision/relax.py,sha256=6XAT2NoNLfprOc-azrF3wFa7y1p4v-hejVILJQmEnUQ,5083
+decision/resolve.py,sha256=lP8ntthcc-K8NDiN0zOwSnNLTAlHq7EyuboHjr-h5h4,3517
+decision/schema.py,sha256=YIwpI2XRONuKXgM2a4Nc1C_xr34xh0rKOFoBhAPkbqs,458
+decision/snapshot.py,sha256=UkWTWl0N_3NtaPA-TFUczZIIkRuGN-ftZkTPnK7Fwyk,64458
+decision/sources.py,sha256=06xa6D8fueo2ogN1X5Du1MpRMFoU8B4kpdAHQHZzRj4,19968
+decision/templates.py,sha256=_RkwwcDMuIcxxQMgcfz_AtRMD9tyGyVEFFnoNvpssso,5579
+decision/verify.py,sha256=jgDvPOmjWCYGu2gGKhx4GDDsEn1zDjrpd6hwL2HDW84,75755
+decision/vocabulary.py,sha256=CdWNJsOXrupLsvHwdh0U72F-PilodcpX7ujbzx-DNvI,18345
+schema/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schema/applicability.py,sha256=u5qN7J-F7_7_6N6yvrQa_77OJX_aY4VMHoLNamG-e2I,6975
+schema/benchmark.py,sha256=YygwlAWqZEj_0jUdD3tsN27QbHVjzpuyklckXEg4pmU,6325
+schema/benchmark_eligibility.py,sha256=LAlygCfd3ylct9gpIKcBbLDWB2QAVLtZ2cniwGsAgjM,11133
+schema/card.py,sha256=4FcmtgaIySAhWSsCfEM5OGxcGSSvKBI-glGPR9iqmpo,60754
+schema/enrichment.py,sha256=VHs7Y9sNYbsWGFqX7iWc5oXXY7ilppiLSoUe2m7x_DU,7069
+schema/enums.py,sha256=oX-WlDam0I4BwD7ctZH_dR-awmVE3tRzjNJyAx4G3LE,9737
+schema/graph.py,sha256=98lU9EApPWRKVurkUU37pAFO3QH96nEaTZhziiwo6II,17845
+schema/suppliers.py,sha256=bbfOtdKcdFLZwVZUIb5kYlURBMds5cJ6bO58i8yAxpM,2925
+api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+api/class_fit.py,sha256=twI-vLxbbkZ697IQPTpAH4_CghlF2E1aj9aLTSHwjh8,13875
+api/classes.py,sha256=efNNRED2ZgtZDbt38kT_jZs5mR6DBkcodzpgOzp1bg0,24218
+api/ranking/__init__.py,sha256=bD3q9uxJWbAxNI6fSEYvBQ6uGndQFt1WsNi5qIWIRAc,419
+api/ranking/engine.py,sha256=vQRa5dHkSi_KvafpCrcvUU6N0nFugcTKM1ku15_goG8,82466
+pipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pipeline/class_export.py,sha256=iIHn4D-PtpYSeqI0GPgwfNuE5eFgpgk36y3wf4RiZNo,7325
+pipeline/hardware.py,sha256=O2sksjNnE5ez-S842tqmKLc1q0fw8vdHNeQNwr0sbHs,18588
+pipeline/hosts.py,sha256=J6d59sn7KhnNW0EyIZk26QUgdhbyOOH6O-cCItPI2U4,10031
+pipeline/load.py,sha256=9bEydvLBE8gk-dbDVU3hiQDVrm0uR4R6ZWXOEMbaQ0k,7688
+pipeline/ranking.py,sha256=K2LrEhkbGyDwTnt8SwPWaG8YU7Z2H2QkIzcm13wKoQc,25460
+registry/domains.yaml,sha256=hQR5T7hiqW488h_tOM8yYn9XFuTVvUkM54fy24ZuyPM,5681
+registry/facets.yaml,sha256=qrcWi0kG1ovBZf_cuNih0dnPdGcs2Ess57OKHjlubNc,37111
+registry/harnesses.yaml,sha256=SzytLMcjgnhtegvtKTzAU3qmht4sXkdncVoI4CvzAnc,2948
+registry/providers.yaml,sha256=SDLjIe715tPGJ_4CKny7FiRbqJwyEDlF5xfz7phFFzM,12738
+registry/sources.yaml,sha256=yzIKRCsyGkmlA_rTN_I5lj7OWZP-IgczEWRehzoxk3A,97010
+registry/templates.yaml,sha256=UF3tfh1TjvbN6CCGP2tNLrIuKD25bOpTbExPjJVjP9s,7540
+modelspec_dev-0.1.0.dist-info/METADATA,sha256=SJ9OAOeZv-H-WR4QS_toogSHPpHQSKJRZC16gzP_KC0,4299
+modelspec_dev-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+modelspec_dev-0.1.0.dist-info/entry_points.txt,sha256=kKMBL87pdMHVJqEsdmL5Karwat8m_NMSc_ExOBofbQo,52
+modelspec_dev-0.1.0.dist-info/licenses/LICENSE,sha256=iCsHytGn2QG7WHx8Z-r3ZIYz5dUL9xatml1XOV4QiMs,2149
+modelspec_dev-0.1.0.dist-info/licenses/LICENSE-DATA,sha256=KKlSnH0LtNxR9L9cEWo9Fu8kegUvdZFGZ2jd9WP9HPU,20138
+modelspec_dev-0.1.0.dist-info/RECORD,,

modelspec_dev-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

modelspec_dev-0.1.0.dist-info/entry_points.txt

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

modelspec_dev-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,43 @@
+ModelSpec is licensed in two parts.
+
+  Code    — everything except the data directories below — MIT, as set out in
+            full beneath this notice.
+
+  Data    — the curated corpora in `models/`, `benchmarks/`, `hardware/` and
+            `hosts/` — Creative Commons Attribution-ShareAlike 4.0
+            International (CC BY-SA 4.0), set out in full in LICENSE-DATA.
+
+The data is share-alike so that anyone who builds on the corpus and
+redistributes it publishes their improvements under the same terms. The code is
+permissive so the CLI can be embedded anywhere. Individual cards and pages
+record the source and licence of the third-party material they draw on; those
+terms govern that material and are not altered by this file.
+
+Decided by the operator on 2026-09-08. The data directories were extended to
+`hardware/` and `hosts/` on 2026-09-16 (MODEL-11); those records are curated data
+on the same terms as the other corpora, and the earlier text covered them only by
+omission.
+
+-----------------------------------------------------------------------
+
+MIT License
+
+Copyright (c) 2026 ModelSpec Contributors
+
+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.