unmuzzle 0.1.0__tar.gz

unmuzzle-0.1.0/LICENSE

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

unmuzzle-0.1.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: unmuzzle
+Version: 0.1.0
+Summary: Censorship-resistant distribution for open-weight models. BitTorrent + HTTP mirrors, signed checksums, Hugging Face cache compatible.
+Author: Jiajun Zeng
+License: MIT
+Keywords: llm,open-weights,bittorrent,distribution,censorship-resistant
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.2; extra == "mcp"
+Dynamic: license-file
+
+# unmuzzle
+
+[![e2e-verify](https://github.com/zengjiajun0623/unmuzzle-hub/actions/workflows/e2e-verify.yml/badge.svg)](https://github.com/zengjiajun0623/unmuzzle-hub/actions/workflows/e2e-verify.yml)
+
+Agent-native distribution for open-weight models.
+
+AI agents are the users here. `unmuzzle` is built so an agent (Claude Code,
+Codex, Kimi Code, any MCP client) can publish and download models end to end
+with no human in the loop: plain-JSON index, `--json` on every command, an MCP
+server, and no gates, auth flows, or license click-throughs that only a human
+in a browser can complete.
+
+It is also censorship-resistant by construction:
+
+- **The index is plain JSON in a git repo.** Anyone can mirror or fork it.
+- **Weights move over BitTorrent (web-seeded) and HTTP mirrors.** Web seeds
+  keep every torrent alive at zero peers; no central server to block or bill.
+- **Every file is sha256-pinned and the manifest is minisign-signed.** The
+  signature, not the host, is the trust root. Any static host can be a mirror.
+- **Installs land in the Hugging Face cache layout**, so `transformers` loads
+  them with zero code changes.
+
+Zero dependencies. Python 3.9+.
+
+## Install
+
+```bash
+pip install git+https://github.com/zengjiajun0623/unmuzzle-hub.git
+# optional: aria2 for torrents, minisign for signature verification
+```
+
+## For agents
+
+Read [AGENTS.md](AGENTS.md). It is the complete publish/download protocol.
+Or add the MCP server:
+
+```bash
+pip install 'unmuzzle[mcp]'
+claude mcp add unmuzzle -- unmuzzle-mcp
+```
+
+## For humans
+
+```bash
+unmuzzle list
+unmuzzle info unmuzzle/qwen2.5-14b-abliterated
+unmuzzle get  unmuzzle/qwen2.5-14b-abliterated --require-signature --dest ./models
+```
+
+Every command takes `--json`.
+
+## First release: unmuzzle/qwen2.5-14b-abliterated
+
+Qwen2.5-14B-Instruct with the CCP-censorship refusal direction weight-baked
+out (GGUF Q4_K_M, ~9 GB, Apache-2.0). Answers factually on Tiananmen, Xinjiang,
+Taiwan, and similar topics. Runs in Ollama/llama.cpp on a 16 GB machine:
+
+```bash
+unmuzzle get unmuzzle/qwen2.5-14b-abliterated --require-signature --dest ./models
+ollama create unmuzzle-qwen14b -f Modelfile   # Modelfile in the HF mirror repo
+ollama run unmuzzle-qwen14b
+```
+
+Mirrors: Hugging Face HTTP + web-seeded torrent. Signed with the unmuzzle
+minisign key.
+
+## Publish a model
+
+```bash
+unmuzzle keygen                       # one-time signing identity
+unmuzzle publish ./mymodel \
+  --name org/mymodel \
+  --http-base https://your-mirror/mymodel \
+  --torrent-url https://your-mirror/mymodel.torrent \
+  --magnet "magnet:?xt=..." \
+  --sign-key ~/.minisign/unmuzzle.key
+```
+
+Then PR your `index/models/*.json` into this repo, or host your own index and
+point clients at it with `--index` / `$UNMUZZLE_INDEX`. The full recipe,
+including torrent creation with web seeds, is in [AGENTS.md](AGENTS.md).
+Format and threat model: [SPEC.md](SPEC.md).
+
+## Why not just Hugging Face / a mirror / a torrent site?
+
+- **HF** gates models behind human browser flows and can take them down
+  (ERNIE ViLG, GEITje). In mainland China the site itself is blocked, which is
+  why hf-mirror.com exists. Right default for ordinary models, wrong single
+  point of failure for models someone wants suppressed, and unusable for
+  agents hitting gated repos.
+- **Mirrors** (hf-mirror, ModelScope) reintroduce a single operator who can
+  censor, and you cannot verify what they serve back to you.
+- **A bare torrent** has no discovery, no publisher identity, and dies at zero
+  seeds. unmuzzle adds the index, per-file sha256, publisher signatures, and
+  web seeds on top.
+
+## Roadmap
+
+- [x] first real release (unmuzzle/qwen2.5-14b-abliterated)
+- [x] MCP server for agent-native publish/download
+- [ ] standalone registry site generated from the index
+- [ ] DHT-native peer discovery, built-in torrent client (drop aria2c)
+- [ ] index federation: subscribe to multiple publisher indexes
+
+## License
+
+MIT

unmuzzle-0.1.0/README.md

@@ -0,0 +1,107 @@
+# unmuzzle
+
+[![e2e-verify](https://github.com/zengjiajun0623/unmuzzle-hub/actions/workflows/e2e-verify.yml/badge.svg)](https://github.com/zengjiajun0623/unmuzzle-hub/actions/workflows/e2e-verify.yml)
+
+Agent-native distribution for open-weight models.
+
+AI agents are the users here. `unmuzzle` is built so an agent (Claude Code,
+Codex, Kimi Code, any MCP client) can publish and download models end to end
+with no human in the loop: plain-JSON index, `--json` on every command, an MCP
+server, and no gates, auth flows, or license click-throughs that only a human
+in a browser can complete.
+
+It is also censorship-resistant by construction:
+
+- **The index is plain JSON in a git repo.** Anyone can mirror or fork it.
+- **Weights move over BitTorrent (web-seeded) and HTTP mirrors.** Web seeds
+  keep every torrent alive at zero peers; no central server to block or bill.
+- **Every file is sha256-pinned and the manifest is minisign-signed.** The
+  signature, not the host, is the trust root. Any static host can be a mirror.
+- **Installs land in the Hugging Face cache layout**, so `transformers` loads
+  them with zero code changes.
+
+Zero dependencies. Python 3.9+.
+
+## Install
+
+```bash
+pip install git+https://github.com/zengjiajun0623/unmuzzle-hub.git
+# optional: aria2 for torrents, minisign for signature verification
+```
+
+## For agents
+
+Read [AGENTS.md](AGENTS.md). It is the complete publish/download protocol.
+Or add the MCP server:
+
+```bash
+pip install 'unmuzzle[mcp]'
+claude mcp add unmuzzle -- unmuzzle-mcp
+```
+
+## For humans
+
+```bash
+unmuzzle list
+unmuzzle info unmuzzle/qwen2.5-14b-abliterated
+unmuzzle get  unmuzzle/qwen2.5-14b-abliterated --require-signature --dest ./models
+```
+
+Every command takes `--json`.
+
+## First release: unmuzzle/qwen2.5-14b-abliterated
+
+Qwen2.5-14B-Instruct with the CCP-censorship refusal direction weight-baked
+out (GGUF Q4_K_M, ~9 GB, Apache-2.0). Answers factually on Tiananmen, Xinjiang,
+Taiwan, and similar topics. Runs in Ollama/llama.cpp on a 16 GB machine:
+
+```bash
+unmuzzle get unmuzzle/qwen2.5-14b-abliterated --require-signature --dest ./models
+ollama create unmuzzle-qwen14b -f Modelfile   # Modelfile in the HF mirror repo
+ollama run unmuzzle-qwen14b
+```
+
+Mirrors: Hugging Face HTTP + web-seeded torrent. Signed with the unmuzzle
+minisign key.
+
+## Publish a model
+
+```bash
+unmuzzle keygen                       # one-time signing identity
+unmuzzle publish ./mymodel \
+  --name org/mymodel \
+  --http-base https://your-mirror/mymodel \
+  --torrent-url https://your-mirror/mymodel.torrent \
+  --magnet "magnet:?xt=..." \
+  --sign-key ~/.minisign/unmuzzle.key
+```
+
+Then PR your `index/models/*.json` into this repo, or host your own index and
+point clients at it with `--index` / `$UNMUZZLE_INDEX`. The full recipe,
+including torrent creation with web seeds, is in [AGENTS.md](AGENTS.md).
+Format and threat model: [SPEC.md](SPEC.md).
+
+## Why not just Hugging Face / a mirror / a torrent site?
+
+- **HF** gates models behind human browser flows and can take them down
+  (ERNIE ViLG, GEITje). In mainland China the site itself is blocked, which is
+  why hf-mirror.com exists. Right default for ordinary models, wrong single
+  point of failure for models someone wants suppressed, and unusable for
+  agents hitting gated repos.
+- **Mirrors** (hf-mirror, ModelScope) reintroduce a single operator who can
+  censor, and you cannot verify what they serve back to you.
+- **A bare torrent** has no discovery, no publisher identity, and dies at zero
+  seeds. unmuzzle adds the index, per-file sha256, publisher signatures, and
+  web seeds on top.
+
+## Roadmap
+
+- [x] first real release (unmuzzle/qwen2.5-14b-abliterated)
+- [x] MCP server for agent-native publish/download
+- [ ] standalone registry site generated from the index
+- [ ] DHT-native peer discovery, built-in torrent client (drop aria2c)
+- [ ] index federation: subscribe to multiple publisher indexes
+
+## License
+
+MIT

unmuzzle-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "unmuzzle"
+version = "0.1.0"
+description = "Censorship-resistant distribution for open-weight models. BitTorrent + HTTP mirrors, signed checksums, Hugging Face cache compatible."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Jiajun Zeng" }]
+keywords = ["llm", "open-weights", "bittorrent", "distribution", "censorship-resistant"]
+
+[project.scripts]
+unmuzzle = "unmuzzle.cli:main"
+unmuzzle-mcp = "unmuzzle.mcp_server:main"
+
+[project.optional-dependencies]
+dev = ["pytest>=7"]
+mcp = ["mcp>=1.2"]
+
+[tool.setuptools.packages.find]
+include = ["unmuzzle*"]

unmuzzle-0.1.0/setup.cfg

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

unmuzzle-0.1.0/tests/test_api.py

@@ -0,0 +1,100 @@
+import json
+import os
+
+import pytest
+
+from unmuzzle import api
+from unmuzzle.cli import main
+from unmuzzle.publish import build_entry, write_entry
+
+from helpers import serve
+
+
+@pytest.fixture
+def published(tmp_path):
+    model_dir = tmp_path / "model"
+    model_dir.mkdir()
+    (model_dir / "config.json").write_text("{}")
+    (model_dir / "weights.bin").write_bytes(os.urandom(150_000))
+    srv, base = serve(model_dir)
+    index_dir = tmp_path / "index"
+    write_entry(index_dir, build_entry(model_dir, "unmuzzle/api-test",
+                                       http_bases=[base], tags=["test"]))
+    yield str(index_dir / "index.json"), model_dir
+    srv.shutdown()
+
+
+def test_list_and_info(published):
+    index, _ = published
+    models = api.list_models(index=index)
+    assert [m["name"] for m in models] == ["unmuzzle/api-test"]
+    assert models[0]["revision"]
+    info = api.model_info("unmuzzle/api-test", index=index)
+    assert info["total_size"] > 0 and not info["signed"]
+
+
+def test_get_and_verify_api(published, tmp_path, monkeypatch):
+    index, model_dir = published
+    monkeypatch.setenv("HF_HOME", str(tmp_path / "hf"))
+    result = api.get("unmuzzle/api-test", index=index, method="http", jobs=2)
+    assert result["hf_cache"] and result["files"] == 2
+    assert "local_files_only=True" in result["load_with"]
+    v = api.verify("unmuzzle/api-test", index=index)
+    assert v["ok"] and v["checked"] == 2
+
+
+def test_get_missing_model_errors(published):
+    index, _ = published
+    with pytest.raises(api.UnmuzzleError, match="not found"):
+        api.get("unmuzzle/nope", index=index)
+
+
+def test_require_signature_on_unsigned_entry(published):
+    index, _ = published
+    with pytest.raises(api.UnmuzzleError, match="unsigned"):
+        api.get("unmuzzle/api-test", index=index, require_signature=True)
+
+
+def test_cli_json_output(published, tmp_path, monkeypatch, capsys):
+    index, _ = published
+    monkeypatch.setenv("HF_HOME", str(tmp_path / "hf"))
+    rc = main(["list", "--json", "--index", index])
+    assert rc == 0
+    parsed = json.loads(capsys.readouterr().out)
+    assert parsed[0]["name"] == "unmuzzle/api-test"
+
+    rc = main(["get", "unmuzzle/api-test", "--json", "--index", index, "--jobs", "2"])
+    assert rc == 0
+    result = json.loads(capsys.readouterr().out)
+    assert result["hf_cache"] is True
+
+    rc = main(["get", "unmuzzle/nope", "--json", "--index", index])
+    assert rc == 1
+    assert "error" in json.loads(capsys.readouterr().err)
+
+
+def test_keygen(tmp_path, monkeypatch):
+    import shutil
+    if not shutil.which("minisign"):
+        pytest.skip("minisign not installed")
+    key = tmp_path / "k.key"
+    result = api.keygen(str(key))
+    assert result["pubkey"] and key.exists()
+    with pytest.raises(api.UnmuzzleError, match="already exists"):
+        api.keygen(str(key))
+
+
+def test_sign_and_verify_roundtrip(published, tmp_path):
+    import shutil
+    if not shutil.which("minisign"):
+        pytest.skip("minisign not installed")
+    index, model_dir = published
+    key = tmp_path / "k.key"
+    api.keygen(str(key))
+    result = api.publish(str(model_dir), "unmuzzle/signed-test",
+                         http_bases=["https://example.com/x"],
+                         sign_key=str(key), index_dir=str(tmp_path / "idx2"))
+    assert result["signed"] and result["entry"]["publisher_pubkey"]
+    from unmuzzle.index import validate_entry
+    status = api.check_signature(validate_entry(result["entry"]), require=True)
+    assert status == {"signed": True, "verified": True}

unmuzzle-0.1.0/tests/test_download.py

@@ -0,0 +1,72 @@
+import hashlib
+import os
+
+import pytest
+
+from unmuzzle.download import DownloadError, download_file, sha256_file
+
+from helpers import serve
+
+
+@pytest.fixture
+def server(tmp_path):
+    src = tmp_path / "src"
+    src.mkdir()
+    payload = os.urandom(300_000)  # spans multiple chunks at test chunk size
+    (src / "weights.bin").write_bytes(payload)
+    srv, base = serve(src)
+    yield base, payload
+    srv.shutdown()
+
+
+def test_download_multichunk(server, tmp_path):
+    base, payload = server
+    dest = tmp_path / "out" / "weights.bin"
+    sha = hashlib.sha256(payload).hexdigest()
+    download_file([base], "weights.bin", dest, len(payload), sha,
+                  jobs=4, chunk_size=64 * 1024)
+    assert dest.read_bytes() == payload
+    assert not (dest.parent / "weights.bin.parts").exists()
+
+
+def test_download_resumes_from_parts(server, tmp_path):
+    base, payload = server
+    dest = tmp_path / "weights.bin"
+    sha = hashlib.sha256(payload).hexdigest()
+    chunk = 64 * 1024
+    # pre-seed the first chunk as if a previous run was interrupted
+    parts = tmp_path / "weights.bin.parts"
+    parts.mkdir()
+    (parts / "000000").write_bytes(payload[:chunk])
+    download_file([base], "weights.bin", dest, len(payload), sha,
+                  jobs=2, chunk_size=chunk)
+    assert dest.read_bytes() == payload
+
+
+def test_checksum_mismatch_raises(server, tmp_path):
+    base, payload = server
+    dest = tmp_path / "weights.bin"
+    with pytest.raises(DownloadError, match="sha256 mismatch"):
+        download_file([base], "weights.bin", dest, len(payload), "0" * 64,
+                      jobs=2, chunk_size=64 * 1024)
+    assert not dest.exists()
+
+
+def test_mirror_failover(server, tmp_path):
+    base, payload = server
+    dest = tmp_path / "weights.bin"
+    sha = hashlib.sha256(payload).hexdigest()
+    download_file(["http://127.0.0.1:1/dead", base], "weights.bin",
+                  dest, len(payload), sha, jobs=2, chunk_size=128 * 1024)
+    assert dest.read_bytes() == payload
+
+
+def test_existing_verified_file_skips(server, tmp_path):
+    base, payload = server
+    dest = tmp_path / "weights.bin"
+    dest.write_bytes(payload)
+    sha = hashlib.sha256(payload).hexdigest()
+    assert sha256_file(dest) == sha
+    download_file(["http://127.0.0.1:1/dead"], "weights.bin", dest,
+                  len(payload), sha)  # would fail if it tried the network
+    assert dest.read_bytes() == payload

unmuzzle-0.1.0/tests/test_e2e.py

@@ -0,0 +1,79 @@
+import json
+import os
+
+from unmuzzle import hfcache
+from unmuzzle.cli import main
+from unmuzzle.publish import build_entry, write_entry
+
+from helpers import serve
+
+
+def make_model(tmp_path):
+    model_dir = tmp_path / "model"
+    model_dir.mkdir()
+    (model_dir / "config.json").write_text(json.dumps({"architectures": ["TestForCausalLM"]}))
+    (model_dir / "weights.bin").write_bytes(os.urandom(200_000))
+    (model_dir / ".DS_Store").write_bytes(b"junk")  # must be skipped
+    return model_dir
+
+
+def test_publish_get_verify_e2e(tmp_path, monkeypatch, capsys):
+    model_dir = make_model(tmp_path)
+
+    # publisher: serve the model dir over http, build + sign-free index entry
+    srv, base = serve(model_dir)
+    index_dir = tmp_path / "index"
+    entry = build_entry(model_dir, "unmuzzle/e2e-model", http_bases=[base],
+                        description="e2e", tags=["test"])
+    write_entry(index_dir, entry)
+    index_json = index_dir / "index.json"
+    assert index_json.exists()
+
+    # client: install into an isolated HF cache
+    hf_home = tmp_path / "hf"
+    monkeypatch.setenv("HF_HOME", str(hf_home))
+    rc = main(["get", "unmuzzle/e2e-model", "--index", str(index_json), "--jobs", "4"])
+    assert rc == 0
+    srv.shutdown()
+
+    out = capsys.readouterr().out
+    assert "installed into HF cache" in out
+
+    from unmuzzle.index import validate_entry
+    rev = validate_entry(entry).revision()
+    snapshot = hfcache.model_cache_dir("unmuzzle/e2e-model") / "snapshots" / rev
+    assert (snapshot / "config.json").read_text() == (model_dir / "config.json").read_text()
+    assert (snapshot / "weights.bin").read_bytes() == (model_dir / "weights.bin").read_bytes()
+    assert not (snapshot / ".DS_Store").exists()
+
+    # verify command passes
+    rc = main(["verify", "unmuzzle/e2e-model", "--index", str(index_json)])
+    assert rc == 0
+
+    # refs/main points at the revision, so transformers can resolve it offline
+    refs = hfcache.model_cache_dir("unmuzzle/e2e-model") / "refs" / "main"
+    assert refs.read_text() == rev
+
+
+def test_get_to_plain_dest(tmp_path, capsys):
+    model_dir = make_model(tmp_path)
+    srv, base = serve(model_dir)
+    index_dir = tmp_path / "index"
+    write_entry(index_dir, build_entry(model_dir, "unmuzzle/plain", http_bases=[base]))
+    dest = tmp_path / "dest"
+    rc = main(["get", "unmuzzle/plain", "--dest", str(dest),
+               "--index", str(index_dir / "index.json")])
+    srv.shutdown()
+    assert rc == 0
+    assert (dest / "weights.bin").read_bytes() == (model_dir / "weights.bin").read_bytes()
+    assert "done. Files in" in capsys.readouterr().out
+
+
+def test_publish_rejects_empty_dir(tmp_path):
+    empty = tmp_path / "empty"
+    empty.mkdir()
+    try:
+        build_entry(empty, "unmuzzle/x", http_bases=["https://x"])
+        assert False, "should have raised"
+    except ValueError:
+        pass

unmuzzle-0.1.0/tests/test_hfcache.py

@@ -0,0 +1,26 @@
+import os
+
+from unmuzzle.hfcache import install, model_cache_dir
+
+
+def test_install_layout(tmp_path, monkeypatch):
+    monkeypatch.setenv("HF_HOME", str(tmp_path / "hf"))
+    staging = tmp_path / "staging"
+    staging.mkdir()
+    (staging / "config.json").write_text("{}")
+    sub = staging / "subdir"
+    sub.mkdir()
+    (sub / "weights.bin").write_bytes(os.urandom(1000))
+
+    files = [
+        {"path": "config.json", "size": 2, "sha256": "a" * 64},
+        {"path": "subdir/weights.bin", "size": 1000, "sha256": "b" * 64},
+    ]
+    snapshot = install("unmuzzle/test", "rev123", staging, files)
+
+    cache = model_cache_dir("unmuzzle/test")
+    assert (cache / "blobs" / ("a" * 64)).exists()
+    assert (cache / "blobs" / ("b" * 64)).exists()
+    link = snapshot / "subdir" / "weights.bin"
+    assert link.read_bytes() == (sub / "weights.bin").read_bytes()
+    assert (cache / "refs" / "main").read_text() == "rev123"

unmuzzle-0.1.0/tests/test_index.py

@@ -0,0 +1,54 @@
+import json
+
+import pytest
+
+from unmuzzle.index import IndexError, find_model, load_index, validate_entry
+
+
+def entry(**kw):
+    base = {
+        "name": "unmuzzle/test-model",
+        "files": [
+            {"path": "config.json", "size": 10, "sha256": "a" * 64},
+            {"path": "model.safetensors", "size": 100, "sha256": "b" * 64},
+        ],
+        "mirrors": {"http": ["https://example.com/m"], "magnet": None},
+    }
+    base.update(kw)
+    return base
+
+
+def test_validate_ok():
+    e = validate_entry(entry())
+    assert e.name == "unmuzzle/test-model"
+    assert e.total_size == 110
+    assert e.revision() and len(e.revision()) == 16
+
+
+def test_manifest_is_deterministic_and_sorted():
+    e = validate_entry(entry())
+    assert e.canonical_manifest() == f"{'a' * 64}  config.json\n{'b' * 64}  model.safetensors\n"
+
+
+def test_rejects_traversal():
+    with pytest.raises(IndexError, match="unsafe path"):
+        validate_entry(entry(files=[{"path": "../x", "size": 1, "sha256": "a" * 64}]))
+
+
+def test_rejects_missing_mirrors():
+    with pytest.raises(IndexError, match="no mirrors"):
+        validate_entry(entry(mirrors={"http": [], "magnet": None}))
+
+
+def test_rejects_bad_name():
+    with pytest.raises(IndexError):
+        validate_entry(entry(name="no-org"))
+
+
+def test_load_and_find(tmp_path):
+    idx = tmp_path / "index.json"
+    idx.write_text(json.dumps({"version": 1, "models": [entry()]}))
+    entries = load_index(str(idx))
+    assert find_model(entries, "unmuzzle/test-model").name == "unmuzzle/test-model"
+    assert find_model(entries, "test-model").name == "unmuzzle/test-model"  # shorthand
+    assert find_model(entries, "nope") is None

unmuzzle-0.1.0/unmuzzle/__init__.py

@@ -0,0 +1,3 @@
+"""Unmuzzle: censorship-resistant distribution for open-weight models."""
+
+__version__ = "0.1.0"