The mirror page lists Hugging Face's trending models without anything typed, with views for what is new this month and what is most downloaded, filters for task and size, and each repository's parameter count, architecture, context length and age from one registry call. "Only what these nodes can run" is on by default and leaves out architectures the nodes' llama.cpp cannot load, and adapters, saying how many it hid. Listings are remembered for ten minutes. The stylesheet is now linked by a hash of its content. It is cached for a day, so under a fixed name a deploy's new styles reached people a day after its markup. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
233 lines
7.6 KiB
Go
233 lines
7.6 KiB
Go
package hf
|
|
|
|
import (
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"net/url"
|
|
"slices"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// registry stands in for Hugging Face, answering the two endpoints used.
|
|
func registry(t *testing.T, h http.HandlerFunc) *Client {
|
|
t.Helper()
|
|
srv := httptest.NewServer(h)
|
|
t.Cleanup(srv.Close)
|
|
return New(srv.URL, time.Second)
|
|
}
|
|
|
|
func TestTheRealSizeOfAWeightsFileIsTheLFSOne(t *testing.T) {
|
|
c := registry(t, func(w http.ResponseWriter, r *http.Request) {
|
|
if strings.HasSuffix(r.URL.Path, "/tree/abc123") {
|
|
_, _ = w.Write([]byte(`[
|
|
{"type":"file","path":"README.md","size":900,"oid":"gitblob"},
|
|
{"type":"file","path":"model.gguf","size":133,
|
|
"lfs":{"oid":"deadbeef","size":1117320736}}]`))
|
|
return
|
|
}
|
|
_, _ = w.Write([]byte(`{"id":"Qwen/X","sha":"abc123"}`))
|
|
})
|
|
|
|
repo, err := c.Repo(t.Context(), "Qwen/X")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var gguf File
|
|
for _, f := range repo.Files {
|
|
if f.Path == "model.gguf" {
|
|
gguf = f
|
|
}
|
|
}
|
|
// The plain size of an LFS file is the size of the pointer. Reading that
|
|
// one reports a gigabyte model as 133 bytes, which is the number somebody
|
|
// would then plan disk against.
|
|
if gguf.Bytes != 1117320736 {
|
|
t.Errorf("expected the LFS size, got %d", gguf.Bytes)
|
|
}
|
|
if gguf.SHA256 != "deadbeef" {
|
|
t.Errorf("expected the published checksum, got %q", gguf.SHA256)
|
|
}
|
|
}
|
|
|
|
func TestASmallFileHasNoChecksum(t *testing.T) {
|
|
c := registry(t, func(w http.ResponseWriter, r *http.Request) {
|
|
if strings.Contains(r.URL.Path, "/tree/") {
|
|
_, _ = w.Write([]byte(`[{"type":"file","path":"README.md","size":900,"oid":"gitblob"}]`))
|
|
return
|
|
}
|
|
_, _ = w.Write([]byte(`{"id":"Qwen/X","sha":"abc123"}`))
|
|
})
|
|
|
|
repo, _ := c.Repo(t.Context(), "Qwen/X")
|
|
// A git blob hash is not a checksum of the content, so reporting it as one
|
|
// would invite somebody to compare it with what the mirror computes and
|
|
// conclude the download was corrupt.
|
|
if repo.Files[0].SHA256 != "" {
|
|
t.Errorf("a git-stored file should publish no checksum, got %q", repo.Files[0].SHA256)
|
|
}
|
|
}
|
|
|
|
func TestTheDownloadURLIsPinnedToTheRevisionThatWasListed(t *testing.T) {
|
|
r := Repo{ID: "Qwen/X", Revision: "abc123def456"}
|
|
got := r.DownloadURL("https://hf.example", "model.gguf")
|
|
|
|
// "main" would mean the mirror fetches whatever is there when it gets round
|
|
// to it, which is not necessarily what was on screen when the button was
|
|
// pressed.
|
|
if !strings.Contains(got, "/resolve/abc123def456/") {
|
|
t.Errorf("the URL should pin the revision; got %s", got)
|
|
}
|
|
}
|
|
|
|
func TestAGatedRepositorySaysSoRatherThanBlamingTheNetwork(t *testing.T) {
|
|
c := registry(t, func(w http.ResponseWriter, _ *http.Request) {
|
|
w.WriteHeader(http.StatusUnauthorized)
|
|
})
|
|
|
|
_, err := c.Repo(t.Context(), "meta/gated")
|
|
if err == nil || !strings.Contains(err.Error(), "gated or private") {
|
|
t.Errorf("expected the reason to be named; got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestOneGatedResultDoesNotHideThePage(t *testing.T) {
|
|
c := registry(t, func(w http.ResponseWriter, _ *http.Request) {
|
|
// The field is documented as a boolean and is a word in practice.
|
|
// Decoding it strictly fails the whole response, so one gated model in
|
|
// a page of twenty would hide the other nineteen.
|
|
_, _ = w.Write([]byte(`[{"id":"a","gated":false},{"id":"b","gated":"manual"}]`))
|
|
})
|
|
|
|
got, err := c.Search(t.Context(), "qwen", 20)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != 2 {
|
|
t.Fatalf("expected both results, got %d", len(got))
|
|
}
|
|
if got[0].Gated.Is() || !got[1].Gated.Is() {
|
|
t.Errorf("gating did not decode: %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestSomethingThatIsNotARepositoryIsRefusedBeforeTheCall(t *testing.T) {
|
|
called := false
|
|
c := registry(t, func(http.ResponseWriter, *http.Request) { called = true })
|
|
|
|
if _, err := c.Repo(t.Context(), "qwen"); err == nil {
|
|
t.Error("a bare name is not owner/name and should be refused")
|
|
}
|
|
if called {
|
|
t.Error("nothing should have been requested")
|
|
}
|
|
}
|
|
|
|
func TestWeightsAreToldApartFromDocumentation(t *testing.T) {
|
|
// Crude and right: the registry does not label them, and an operator
|
|
// filling a mirror wants the four files out of thirty worth gigabytes.
|
|
for _, f := range []string{"model.gguf", "model-00001-of-00002.safetensors", "pytorch_model.bin"} {
|
|
if !(File{Path: f}).IsWeights() {
|
|
t.Errorf("%s should count as weights", f)
|
|
}
|
|
}
|
|
for _, f := range []string{"README.md", "config.json", ".gitattributes", "tokenizer.model"} {
|
|
if (File{Path: f}).IsWeights() {
|
|
t.Errorf("%s should not count as weights", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestShardsBecomeOneSetAndAlternativesStaySeparate(t *testing.T) {
|
|
// Straight from a real repository, which holds both the split and the
|
|
// joined copy of the same quantisation.
|
|
sets := Group([]File{
|
|
{Path: "qwen-fp16-00001-of-00004.gguf", Bytes: 1},
|
|
{Path: "qwen-fp16-00002-of-00004.gguf", Bytes: 1},
|
|
{Path: "qwen-fp16-00003-of-00004.gguf", Bytes: 1},
|
|
{Path: "qwen-fp16-00004-of-00004.gguf", Bytes: 1},
|
|
{Path: "qwen-fp16.gguf", Bytes: 4},
|
|
{Path: "qwen-q4_k_m.gguf", Bytes: 2},
|
|
})
|
|
|
|
if len(sets) != 3 {
|
|
t.Fatalf("expected the shards as one and the two whole files apart, got %d: %+v",
|
|
len(sets), sets)
|
|
}
|
|
if sets[0].Shards != 4 || sets[0].Bytes != 4 {
|
|
t.Errorf("the shard set should total its parts, got %+v", sets[0])
|
|
}
|
|
// Two GGUFs in a repository are alternatives: fetching both is wasting
|
|
// gigabytes on a copy nobody asked for.
|
|
if sets[1].Shards != 0 || sets[2].Shards != 0 {
|
|
t.Errorf("whole files are not shard sets: %+v %+v", sets[1], sets[2])
|
|
}
|
|
}
|
|
|
|
func TestASplitAndAJoinedCopyDoNotReadAsOneEntry(t *testing.T) {
|
|
sets := Group([]File{
|
|
{Path: "m-q4-00001-of-00002.gguf"}, {Path: "m-q4-00002-of-00002.gguf"},
|
|
{Path: "m-q4.gguf"},
|
|
})
|
|
if sets[0].Name == sets[1].Name {
|
|
t.Errorf("the split and the joined copy collided on %q", sets[0].Name)
|
|
}
|
|
if !strings.Contains(sets[0].Name, "-of-00002") {
|
|
t.Errorf("a shard set should keep the notation; got %q", sets[0].Name)
|
|
}
|
|
}
|
|
|
|
func TestAShardSetPublishesNoSingleChecksum(t *testing.T) {
|
|
sets := Group([]File{
|
|
{Path: "m-00001-of-00002.safetensors", SHA256: "aaa"},
|
|
{Path: "m-00002-of-00002.safetensors", SHA256: "bbb"},
|
|
})
|
|
// Several files have several checksums and no single value for the set;
|
|
// showing one invites comparing it against the wrong thing.
|
|
if got := sets[0].SHA256(); got != "" {
|
|
t.Errorf("expected no checksum for a set, got %q", got)
|
|
}
|
|
}
|
|
|
|
func TestExploringAsksForWhatThePageFilters(t *testing.T) {
|
|
var got url.Values
|
|
calls := 0
|
|
c := registry(t, func(w http.ResponseWriter, r *http.Request) {
|
|
calls++
|
|
got = r.URL.Query()
|
|
_, _ = w.Write([]byte(`[{"id":"a/b-GGUF","gguf":{"total":7615616512,"architecture":"qwen2","context_length":32768}}]`))
|
|
})
|
|
|
|
q := Query{Sort: SortTrending, Task: "text-generation", GGUF: true, MaxParams: 9e9, Limit: 30}
|
|
models, err := c.Explore(t.Context(), q)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for k, want := range map[string]string{
|
|
"sort": "trendingScore", "pipeline_tag": "text-generation", "filter": "gguf",
|
|
"num_parameters": "min:0,max:9000000000", "limit": "30",
|
|
} {
|
|
if got.Get(k) != want {
|
|
t.Errorf("%s = %q, want %q", k, got.Get(k), want)
|
|
}
|
|
}
|
|
// Expanding any field returns only the expanded ones, so the listing has
|
|
// to name the counts it shows as well as the GGUF summary.
|
|
if !slices.Contains(got["expand[]"], "gguf") || !slices.Contains(got["expand[]"], "downloads") {
|
|
t.Errorf("expand = %v", got["expand[]"])
|
|
}
|
|
if len(models) != 1 || models[0].Params() != 7615616512 || models[0].Architecture() != "qwen2" {
|
|
t.Errorf("the GGUF summary did not decode: %+v", models)
|
|
}
|
|
|
|
// The page opens on this; a second look within minutes is not a second
|
|
// trip to the registry.
|
|
if _, err := c.Explore(t.Context(), q); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if calls != 1 {
|
|
t.Errorf("the registry was asked %d times", calls)
|
|
}
|
|
}
|