weight-audit 0.1.0__tar.gz

weight_audit-0.1.0/LICENSE

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

weight_audit-0.1.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: weight-audit
+Version: 0.1.0
+Summary: License compliance scanner for open-weight AI models (Llama, Gemma, Qwen, DeepSeek, and more)
+Author: HiroCheck
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# weight-audit
+
+Scan the open-weight AI models a project depends on (Llama, Gemma, Qwen,
+DeepSeek, and others) for license compliance risk before a scale-cap or
+acceptable-use restriction turns into a legal problem for a commercial
+product.
+
+## Why
+
+Open-weight models are not all "open source." The Llama Community
+License caps free commercial use at 700M monthly active users. Gemma,
+Qwen, and DeepSeek carry acceptable-use policies. CC-BY-NC weights
+forbid commercial use outright. Roughly 70% of models on Hugging Face
+ship with no license metadata at all. Enterprise SCA platforms
+(Endor Labs, Sonatype, Black Duck) now gate on this for large
+customers -- this tool does the same check for the developers and
+small AI startups those platforms don't sell to.
+
+## Install
+
+```
+pip install weight-audit
+```
+
+## Usage
+
+```
+weight-audit scan .                        # scan a directory (manifest + source detection)
+weight-audit scan . --policy policy.json    # use a custom policy
+weight-audit scan . --json                  # machine-readable output for CI
+weight-audit scan . --online                # also query the HF Hub API for models not in the offline DB
+weight-audit bom . --output ml-bom.json     # generate a CycloneDX ML-BOM
+```
+
+Exit code is `1` if any model violates the policy, `0` otherwise --
+safe to drop into CI:
+
+```
+- run: weight-audit scan .
+```
+
+### Detecting models
+
+weight-audit looks for models in two places:
+
+1. A `weight-audit-models.txt` manifest in the scanned directory --
+   one Hugging Face model id per line, with an optional declared
+   license as a second column:
+   ```
+   meta-llama/Llama-3-8B-Instruct
+   some-org/attributed-model,cc-by-4.0
+   ```
+2. A best-effort scan of `.py` source for
+   `AutoModel.from_pretrained("org/model")` and `model_id = "org/model"`
+   patterns. This is a convenience for a first scan -- for reliable CI
+   gating, use a manifest.
+
+### Policy
+
+By default, anything at `strong-restriction` or above is a violation,
+and models with no license metadata at all (`unknown`) are treated as
+violations too. Override with a JSON file:
+
+```json
+{
+  "fail_at_or_above": "weak-restriction",
+  "treat_unknown_as_violation": false
+}
+```
+
+## How it classifies
+
+Licenses are bucketed into four tiers: `permissive` < `weak-restriction`
+< `strong-restriction` < `unknown`. 27 named model families (Llama,
+Gemma, Qwen, DeepSeek, BLOOM, StarCoder, Baichuan, ChatGLM, Yi, Grok,
+FLUX, and others) are matched against a hand-curated offline database
+recording their *actual* restriction -- not just the license name --
+so a scale cap or acceptable-use policy shows up as a concrete
+obligation, not just a label. See `weight_audit/license_db.py` for the
+exact rules and `weight_audit/classify.py` for the resolution order.
+
+A broader SPDX/common-identifier fallback table (Apache-2.0, MIT,
+CC-BY variants, OpenRAIL variants, and named Llama/Gemma license
+strings) covers models outside the named-family list when a license
+string is available, either from a manifest's `declared_license`
+column or from `--online`.
+
+### Online mode
+
+`--online` queries the Hugging Face Hub API for models that aren't in
+the offline database and don't have a declared license in the
+manifest. It never overrides a license already recorded in the
+manifest, and any network failure (timeout, 404, malformed response)
+degrades to `unknown` rather than crashing the scan -- the offline
+database remains the reliable default; `--online` only fills gaps.
+
+## Limitations
+
+The offline database is a hand-curated table of well-known model
+families, not a registry mirror. Models outside the known families and
+without a declared license (from a manifest or `--online`) are flagged
+`unknown`. This is deliberate: "unknown" surfaces the real state of the
+ecosystem (~70% of Hugging Face models carry no license) rather than
+silently passing them.
+
+## License
+
+MIT
+
+## Support
+
+If this project is useful to you, you can support development here:
+<https://buy.stripe.com/PLACEHOLDER>

weight_audit-0.1.0/README.md

@@ -0,0 +1,113 @@
+# weight-audit
+
+Scan the open-weight AI models a project depends on (Llama, Gemma, Qwen,
+DeepSeek, and others) for license compliance risk before a scale-cap or
+acceptable-use restriction turns into a legal problem for a commercial
+product.
+
+## Why
+
+Open-weight models are not all "open source." The Llama Community
+License caps free commercial use at 700M monthly active users. Gemma,
+Qwen, and DeepSeek carry acceptable-use policies. CC-BY-NC weights
+forbid commercial use outright. Roughly 70% of models on Hugging Face
+ship with no license metadata at all. Enterprise SCA platforms
+(Endor Labs, Sonatype, Black Duck) now gate on this for large
+customers -- this tool does the same check for the developers and
+small AI startups those platforms don't sell to.
+
+## Install
+
+```
+pip install weight-audit
+```
+
+## Usage
+
+```
+weight-audit scan .                        # scan a directory (manifest + source detection)
+weight-audit scan . --policy policy.json    # use a custom policy
+weight-audit scan . --json                  # machine-readable output for CI
+weight-audit scan . --online                # also query the HF Hub API for models not in the offline DB
+weight-audit bom . --output ml-bom.json     # generate a CycloneDX ML-BOM
+```
+
+Exit code is `1` if any model violates the policy, `0` otherwise --
+safe to drop into CI:
+
+```
+- run: weight-audit scan .
+```
+
+### Detecting models
+
+weight-audit looks for models in two places:
+
+1. A `weight-audit-models.txt` manifest in the scanned directory --
+   one Hugging Face model id per line, with an optional declared
+   license as a second column:
+   ```
+   meta-llama/Llama-3-8B-Instruct
+   some-org/attributed-model,cc-by-4.0
+   ```
+2. A best-effort scan of `.py` source for
+   `AutoModel.from_pretrained("org/model")` and `model_id = "org/model"`
+   patterns. This is a convenience for a first scan -- for reliable CI
+   gating, use a manifest.
+
+### Policy
+
+By default, anything at `strong-restriction` or above is a violation,
+and models with no license metadata at all (`unknown`) are treated as
+violations too. Override with a JSON file:
+
+```json
+{
+  "fail_at_or_above": "weak-restriction",
+  "treat_unknown_as_violation": false
+}
+```
+
+## How it classifies
+
+Licenses are bucketed into four tiers: `permissive` < `weak-restriction`
+< `strong-restriction` < `unknown`. 27 named model families (Llama,
+Gemma, Qwen, DeepSeek, BLOOM, StarCoder, Baichuan, ChatGLM, Yi, Grok,
+FLUX, and others) are matched against a hand-curated offline database
+recording their *actual* restriction -- not just the license name --
+so a scale cap or acceptable-use policy shows up as a concrete
+obligation, not just a label. See `weight_audit/license_db.py` for the
+exact rules and `weight_audit/classify.py` for the resolution order.
+
+A broader SPDX/common-identifier fallback table (Apache-2.0, MIT,
+CC-BY variants, OpenRAIL variants, and named Llama/Gemma license
+strings) covers models outside the named-family list when a license
+string is available, either from a manifest's `declared_license`
+column or from `--online`.
+
+### Online mode
+
+`--online` queries the Hugging Face Hub API for models that aren't in
+the offline database and don't have a declared license in the
+manifest. It never overrides a license already recorded in the
+manifest, and any network failure (timeout, 404, malformed response)
+degrades to `unknown` rather than crashing the scan -- the offline
+database remains the reliable default; `--online` only fills gaps.
+
+## Limitations
+
+The offline database is a hand-curated table of well-known model
+families, not a registry mirror. Models outside the known families and
+without a declared license (from a manifest or `--online`) are flagged
+`unknown`. This is deliberate: "unknown" surfaces the real state of the
+ecosystem (~70% of Hugging Face models carry no license) rather than
+silently passing them.
+
+## License
+
+MIT
+
+## Support
+
+If this project is useful to you, you can support development here:
+<https://buy.stripe.com/PLACEHOLDER>

weight_audit-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "weight-audit"
+version = "0.1.0"
+description = "License compliance scanner for open-weight AI models (Llama, Gemma, Qwen, DeepSeek, and more)"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [{name = "HiroCheck"}]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+]
+
+[project.scripts]
+weight-audit = "weight_audit.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["weight_audit*"]

weight_audit-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

weight_audit-0.1.0/tests/test_accuracy.py

@@ -0,0 +1,79 @@
+"""Accuracy harness: known-violating and known-clean fixtures.
+
+Mirrors license-radar's tests/test_parsers.py + accuracy pattern and
+gha-audit's tests/test_accuracy.py: every fixture directory is a
+manifest scan, and we assert the policy verdict is correct given the
+*default* policy (fail_at_or_above=strong-restriction,
+treat_unknown_as_violation=True).
+
+Recall = violating fixtures correctly flagged / total violating fixtures
+FP rate = clean fixtures incorrectly flagged / total clean fixtures
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from weight_audit.classify import classify
+from weight_audit.policy import evaluate, load_policy
+from weight_audit.scanner import scan
+
+FIXTURES_DIR = Path(__file__).parent / "fixtures"
+
+VIOLATING_FIXTURES = [
+    "violating-llama",
+    "violating-gemma",
+    "violating-qwen",
+    "violating-deepseek",
+    "violating-stability",
+    "violating-unknown",
+    "violating-cc-by-nc",
+    "source-detect-violating",
+    "violating-bloom",
+    "violating-starcoder",
+    "violating-baichuan",
+]
+
+CLEAN_FIXTURES = [
+    "safe-mistral",
+    "safe-phi",
+    "safe-falcon",
+    "safe-cc-by",
+    "safe-mixed",
+    "source-detect-safe",
+    "safe-mpt",
+    "safe-olmo",
+]
+
+
+def _scan_fixture(name: str) -> bool:
+    """Return True if the fixture's policy evaluation flags a violation."""
+    refs = scan(FIXTURES_DIR / name)
+    assert refs, f"fixture {name} produced no model references -- fixture is broken"
+    verdicts = [classify(r.model_id, r.declared_license) for r in refs]
+    policy = load_policy(None)
+    results = evaluate(verdicts, policy)
+    return any(r.violates for r in results)
+
+
+@pytest.mark.parametrize("name", VIOLATING_FIXTURES)
+def test_violating_fixtures_are_flagged(name: str) -> None:
+    assert _scan_fixture(name) is True, f"{name} should violate the default policy but did not"
+
+
+@pytest.mark.parametrize("name", CLEAN_FIXTURES)
+def test_clean_fixtures_are_not_flagged(name: str) -> None:
+    assert _scan_fixture(name) is False, f"{name} should NOT violate the default policy but did"
+
+
+def test_accuracy_summary(capsys) -> None:
+    """Not a real assertion -- prints recall / FP rate for visibility,
+    matching license-radar and gha-audit's accuracy reporting."""
+    tp = sum(1 for name in VIOLATING_FIXTURES if _scan_fixture(name))
+    fp = sum(1 for name in CLEAN_FIXTURES if _scan_fixture(name))
+    recall = tp / len(VIOLATING_FIXTURES)
+    fp_rate = fp / len(CLEAN_FIXTURES)
+    print(f"\nRecall: {recall:.1%} ({tp}/{len(VIOLATING_FIXTURES)})")
+    print(f"False-positive rate: {fp_rate:.1%} ({fp}/{len(CLEAN_FIXTURES)})")

weight_audit-0.1.0/tests/test_classify.py

@@ -0,0 +1,76 @@
+from weight_audit.classify import Tier, classify
+
+
+def test_llama_is_strong_restriction():
+    v = classify("meta-llama/Llama-3-8B-Instruct")
+    assert v.tier == Tier.STRONG_RESTRICTION
+    assert "700M" in v.obligation
+
+
+def test_mistral_is_permissive():
+    v = classify("mistralai/Mistral-7B-v0.1")
+    assert v.tier == Tier.PERMISSIVE
+
+
+def test_unknown_model_is_unknown_tier():
+    v = classify("some-rando/never-heard-of-it")
+    assert v.tier == Tier.UNKNOWN
+
+
+def test_declared_cc_by_nc_overrides_to_strong_restriction():
+    v = classify("some-org/whatever-model", declared_license="CC-BY-NC-4.0")
+    assert v.tier == Tier.STRONG_RESTRICTION
+
+
+def test_declared_cc_by_is_weak_restriction():
+    v = classify("some-org/whatever-model", declared_license="cc-by-4.0")
+    assert v.tier == Tier.WEAK_RESTRICTION
+
+
+# --- expanded family coverage (added alongside --online support) ---
+
+def test_bloom_is_strong_restriction():
+    v = classify("bigscience/bloom-7b1")
+    assert v.tier == Tier.STRONG_RESTRICTION
+
+
+def test_starcoder_is_strong_restriction():
+    v = classify("bigcode/starcoder2-15b")
+    assert v.tier == Tier.STRONG_RESTRICTION
+
+
+def test_mpt_is_permissive():
+    v = classify("mosaicml/mpt-7b")
+    assert v.tier == Tier.PERMISSIVE
+
+
+def test_olmo_is_permissive():
+    v = classify("allenai/olmo-7b")
+    assert v.tier == Tier.PERMISSIVE
+
+
+def test_baichuan_is_strong_restriction():
+    v = classify("baichuan-inc/baichuan2-13b")
+    assert v.tier == Tier.STRONG_RESTRICTION
+
+
+def test_yi_is_strong_restriction():
+    v = classify("01-ai/yi-34b")
+    assert v.tier == Tier.STRONG_RESTRICTION
+
+
+def test_flux_schnell_is_permissive_but_dev_is_restricted():
+    schnell = classify("black-forest-labs/flux.1-schnell")
+    dev = classify("black-forest-labs/flux.1-dev")
+    assert schnell.tier == Tier.PERMISSIVE
+    assert dev.tier == Tier.STRONG_RESTRICTION
+
+
+def test_declared_llama3_1_string_is_strong_restriction():
+    v = classify("some-mirror/repackaged-model", declared_license="llama3.1")
+    assert v.tier == Tier.STRONG_RESTRICTION
+
+
+def test_declared_cc_by_sa_is_weak_restriction():
+    v = classify("some-org/whatever-model", declared_license="cc-by-sa-4.0")
+    assert v.tier == Tier.WEAK_RESTRICTION

weight_audit-0.1.0/tests/test_cli_online.py

@@ -0,0 +1,53 @@
+from pathlib import Path
+
+import weight_audit.cli as cli_module
+from weight_audit.cli import main
+
+
+def test_online_flag_resolves_unknown_model_via_mocked_hf(tmp_path: Path, monkeypatch, capsys):
+    # A manifest referencing a model with NO declared_license column,
+    # and NOT in the offline family table -- would be "unknown" offline.
+    manifest = tmp_path / "weight-audit-models.txt"
+    manifest.write_text("some-org/not-in-offline-db\n", encoding="utf-8")
+
+    def fake_fetch(model_id, fetch=None):
+        assert model_id == "some-org/not-in-offline-db"
+        return "cc-by-nc-4.0"
+
+    monkeypatch.setattr(cli_module, "fetch_declared_license", fake_fetch)
+
+    exit_code = main(["scan", str(tmp_path), "--online", "--json"])
+    out = capsys.readouterr().out
+    assert exit_code == 1  # cc-by-nc-4.0 -> strong-restriction -> violates default policy
+    assert "cc-by-nc-4.0" in out
+    assert "strong-restriction" in out
+
+
+def test_without_online_flag_unknown_model_stays_unknown(tmp_path: Path, monkeypatch, capsys):
+    manifest = tmp_path / "weight-audit-models.txt"
+    manifest.write_text("some-org/not-in-offline-db\n", encoding="utf-8")
+
+    def fail_if_called(model_id, fetch=None):
+        raise AssertionError("fetch_declared_license should not be called without --online")
+
+    monkeypatch.setattr(cli_module, "fetch_declared_license", fail_if_called)
+
+    exit_code = main(["scan", str(tmp_path), "--json"])
+    out = capsys.readouterr().out
+    assert exit_code == 1  # unknown -> violates by default (treat_unknown_as_violation)
+    assert "\"tier\": \"unknown\"" in out
+
+
+def test_manifest_declared_license_is_not_overwritten_by_online(tmp_path: Path, monkeypatch, capsys):
+    manifest = tmp_path / "weight-audit-models.txt"
+    manifest.write_text("some-org/has-declared-license,apache-2.0\n", encoding="utf-8")
+
+    def fail_if_called(model_id, fetch=None):
+        raise AssertionError("should not call the network when manifest already has a declared_license")
+
+    monkeypatch.setattr(cli_module, "fetch_declared_license", fail_if_called)
+
+    exit_code = main(["scan", str(tmp_path), "--online", "--json"])
+    out = capsys.readouterr().out
+    assert exit_code == 0
+    assert "apache-2.0" in out

weight_audit-0.1.0/tests/test_hf_client.py

@@ -0,0 +1,62 @@
+import json
+
+import pytest
+
+from weight_audit.hf_client import fetch_declared_license
+import urllib.error
+
+
+def _fake_fetch_cardData(url: str) -> bytes:
+    return json.dumps({"cardData": {"license": "apache-2.0"}}).encode()
+
+
+def _fake_fetch_top_level_license(url: str) -> bytes:
+    return json.dumps({"license": "mit"}).encode()
+
+
+def _fake_fetch_tag_only(url: str) -> bytes:
+    return json.dumps({"tags": ["pytorch", "license:cc-by-4.0", "text-generation"]}).encode()
+
+
+def _fake_fetch_no_license(url: str) -> bytes:
+    return json.dumps({"tags": ["pytorch"]}).encode()
+
+
+def _fake_fetch_malformed(url: str) -> bytes:
+    return b"not json{{{"
+
+
+def _fake_fetch_404(url: str) -> bytes:
+    raise urllib.error.HTTPError(url, 404, "Not Found", hdrs=None, fp=None)  # type: ignore[arg-type]
+
+
+def _fake_fetch_network_error(url: str) -> bytes:
+    raise urllib.error.URLError("connection refused")
+
+
+def test_reads_cardData_license():
+    assert fetch_declared_license("org/model", fetch=_fake_fetch_cardData) == "apache-2.0"
+
+
+def test_reads_top_level_license():
+    assert fetch_declared_license("org/model", fetch=_fake_fetch_top_level_license) == "mit"
+
+
+def test_reads_license_tag():
+    assert fetch_declared_license("org/model", fetch=_fake_fetch_tag_only) == "cc-by-4.0"
+
+
+def test_returns_none_when_no_license_present():
+    assert fetch_declared_license("org/model", fetch=_fake_fetch_no_license) is None
+
+
+def test_returns_none_on_malformed_response():
+    assert fetch_declared_license("org/model", fetch=_fake_fetch_malformed) is None
+
+
+def test_returns_none_on_404():
+    assert fetch_declared_license("org/model", fetch=_fake_fetch_404) is None
+
+
+def test_returns_none_on_network_error():
+    assert fetch_declared_license("org/model", fetch=_fake_fetch_network_error) is None

weight_audit-0.1.0/weight_audit/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

weight_audit-0.1.0/weight_audit/classify.py

@@ -0,0 +1,92 @@
+"""License classification for open-weight AI models.
+
+Mirrors license-radar's classify.py pattern: normalize to a known
+identifier, bucket into a severity tier, and record the *actual*
+restriction (not just the license name) so policy checks can act on it.
+
+The data (named model families, declared-license lookup table) lives
+in license_db.py so the ruleset can grow independently of this
+control-flow logic.
+
+Tiers (least to most restrictive), matching license-radar's naming
+convention so users of both tools share a mental model:
+
+    permissive         -- no meaningful restriction on commercial use
+    weak-restriction    -- attribution / redistribution conditions only
+    strong-restriction  -- usage caps, acceptable-use policies, or
+                           non-commercial-only terms
+    unknown             -- no license metadata found at all
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .license_db import DECLARED_LICENSE_TIERS, KNOWN_FAMILIES, NON_COMMERCIAL_MARKERS
+from .tiers import Tier
+
+__all__ = ["Tier", "LicenseVerdict", "classify"]
+
+
+@dataclass(frozen=True)
+class LicenseVerdict:
+    model_id: str
+    license_id: str
+    tier: Tier
+    obligation: str  # human-readable summary of the actual restriction
+
+
+def classify(model_id: str, declared_license: str | None = None) -> LicenseVerdict:
+    """Classify a model id (+ optional declared license string from
+    the registry's metadata, e.g. from a manifest or --online lookup)
+    into a tier and a concrete obligation.
+
+    Resolution order:
+    1. Non-commercial marker in the declared license (unambiguous,
+       declared consistently across unrelated orgs).
+    2. Named model family (org/model prefix match) -- the highest-value
+       path, since it records the *actual* restriction, not just a label.
+    3. Declared license against the SPDX/common-identifier fallback table.
+    4. Unknown.
+    """
+    normalized = model_id.strip().lower()
+
+    if declared_license:
+        lic = declared_license.strip().lower()
+        if any(marker in lic for marker in NON_COMMERCIAL_MARKERS):
+            return LicenseVerdict(
+                model_id=model_id,
+                license_id=declared_license,
+                tier=Tier.STRONG_RESTRICTION,
+                obligation="Non-commercial-only license (CC-BY-NC family); "
+                "commercial deployment is not permitted under these terms.",
+            )
+
+    for prefix, license_id, tier, obligation in KNOWN_FAMILIES:
+        if prefix in normalized:
+            return LicenseVerdict(
+                model_id=model_id,
+                license_id=license_id,
+                tier=tier,
+                obligation=obligation,
+            )
+
+    if declared_license:
+        lic = declared_license.strip().lower()
+        if lic in DECLARED_LICENSE_TIERS:
+            tier, obligation = DECLARED_LICENSE_TIERS[lic]
+            return LicenseVerdict(
+                model_id=model_id,
+                license_id=declared_license,
+                tier=tier,
+                obligation=obligation,
+            )
+
+    return LicenseVerdict(
+        model_id=model_id,
+        license_id=declared_license or "unknown",
+        tier=Tier.UNKNOWN,
+        obligation="No license metadata found. Treat as highest risk until "
+        "manually verified -- roughly 70% of Hugging Face models ship "
+        "with no license at all.",
+    )