Address the typed models/ URI where the parser maps it

I rejected this the first time Codex raised it, and I was wrong. I checked
REPO_TYPES_URL_PREFIXES on 0.36.2, saw no models/ entry, and concluded the form was
unsupported. It is supported from 1.16, which routes resolve_path through
parse_hf_uri:

  1.25.1   resolve_path("models/openai-community/gpt2") -> model openai-community/gpt2
  0.36.2   resolve_path("models/openai-community/gpt2") -> FileNotFoundError

So the prefilter was calling an addressable model absent on current releases. That is
the branch's own thesis turned on a shape I introduced, and it is the second time I
have answered a question about resolve_path from the wrong version's constants.

Gated on the parser, not on a version. REPO_TYPES_MAPPING contains models on both
releases so it cannot discriminate, and stripping the prefix unconditionally would be
worse than leaving it: on 0.36.2 that probes org/repo and answers True for an address
that version cannot reach. _hub_addresses_typed_model_uris asks parse_hf_uri directly
and answers False when it is absent.

Deliberately narrow. parse_hf_uri reads models/a/b/c as repo a/b plus file c, and
/abs/base as repo abs/base, so this file keeps its own path rules rather than
delegating them: /models/org/repo, ./models/org/repo, ~/models/org/repo and
models/a/b/c all stay False with the capability forced on. datasets/, spaces/ and
kernels/ resolve too and stay rejected, since none can be the base model of a merge.

Tests assert the classification equals the capability rather than hardcoding either
answer, so they hold across the supported range. Behavioral gate 593 passed, 2 skipped.

Author: danielhanchen

tests/test_hub_transport_errors_single_segment.py

@@ -257,6 +257,53 @@ def test_a_single_segment_id_keeps_its_revision(name):
     assert saving_utils._is_hub_repo_id(name) is True
 
 
+@pytest.mark.parametrize("name", [
+    "models/openai-community/gpt2",
+    "hf://models/openai-community/gpt2",
+    "models/openai-community/gpt2@main",
+])
+def test_a_typed_model_uri_tracks_what_the_parser_does(name):
+    """`models/namespace/name` is the typed form of a model address.
+
+    Whether it resolves is a property of the installed release, not of a version
+    number, so this asserts the classification *equals the capability* rather than
+    hardcoding either answer:
+
+        1.25.1   resolve_path("models/openai-community/gpt2") -> model openai-community/gpt2
+        0.36.2   resolve_path("models/openai-community/gpt2") -> FileNotFoundError
+
+    Stripping the prefix unconditionally would be worse than not stripping it, since
+    on 0.36.2 that probes `openai-community/gpt2` and would answer True for an
+    address that version cannot reach. Caught by Codex, twice: I rejected it the
+    first time from 0.36.2's prefix table, which is the wrong version to check.
+    """
+    supported = saving_utils._hub_addresses_typed_model_uris()
+    assert saving_utils._is_hub_repo_id(name) is supported
+
+
+@pytest.mark.parametrize("name", [
+    "/models/org/repo", "./models/org/repo", "~/models/org/repo", "models/a/b/c",
+])
+def test_the_typed_prefix_never_launders_a_path(monkeypatch, name):
+    """With the capability forced on, a path that merely begins with `models` stays a
+    path. `parse_hf_uri` itself would read `models/a/b/c` as repo `a/b` plus file `c`,
+    and `/abs/base` as repo `abs/base`, which is why this file does not delegate its
+    path rules to that parser."""
+    monkeypatch.setattr(saving_utils, "_hub_addresses_typed_model_uris", lambda: True)
+    assert saving_utils._is_hub_repo_id(name) is False
+
+
+@pytest.mark.parametrize("name", [
+    "datasets/stanfordnlp/imdb", "spaces/org/demo", "kernels/org/k",
+])
+def test_repo_types_that_cannot_be_a_base_model_stay_rejected(monkeypatch, name):
+    """These resolve too, and are rejected deliberately: a dataset, a Space and a
+    kernel are not the base model of a LoRA merge, so a Hub probe for one is a
+    round trip that can only answer a question nobody asked."""
+    monkeypatch.setattr(saving_utils, "_hub_addresses_typed_model_uris", lambda: True)
+    assert saving_utils._is_hub_repo_id(name) is False
+
+
 @pytest.mark.parametrize("save_method", ["merged_4bit", "forced_merged_4bit", "merged_16bit", None])
 def test_an_at_sign_in_a_local_directory_changes_nothing(monkeypatch, tmp_path, save_method):
     """The argument the revision split rests on, which nothing else pins.

unsloth_zoo/saving_utils.py

@@ -4516,6 +4516,40 @@ def find_lora_base_model(model_to_inspect):
 # a message that does not say what the guard says was not raised by the guard.
 _SINGLE_SEGMENT_REJECTION = re.compile(r"single[\s\-_]?segment|namespace/name", re.IGNORECASE)
 
+def _hub_addresses_typed_model_uris():
+    """Does the installed huggingface_hub read `models/namespace/name` as a model?
+
+    Asked of the parser `resolve_path` actually consults, never of a version number.
+    1.16+ routes through `parse_hf_uri`, which maps the optional `models/` type
+    prefix; 0.36.2 tests `REPO_TYPES_URL_PREFIXES.values()`, which holds only
+    `datasets/` and `spaces/`, so there `models/org/repo` resolves to nothing:
+
+        1.25.1   resolve_path("models/openai-community/gpt2") -> model openai-community/gpt2
+        0.36.2   resolve_path("models/openai-community/gpt2") -> FileNotFoundError
+
+    `REPO_TYPES_MAPPING` contains `models` on both, so it cannot tell them apart.
+    Stripping the prefix unconditionally would be worse than leaving it: on 0.36.2 it
+    would probe `org/repo` and answer True for an address that version cannot reach.
+
+    Only `models/` is worth asking about. `datasets/`, `spaces/` and `kernels/` all
+    resolve too, and are all rejected by the depth rule on purpose, because none of
+    them can be the base model of a LoRA merge.
+    """
+    try:
+        from huggingface_hub.utils._hf_uris import parse_hf_uri
+    except Exception:
+        try:
+            from huggingface_hub.hf_file_system import parse_hf_uri
+        except Exception:
+            return False
+    try:
+        parsed = parse_hf_uri("hf://models/namespace/name")
+    except Exception:
+        return False
+    return getattr(parsed, "type", None) == "model" and getattr(parsed, "id", None) == "namespace/name"
+pass
+
+
 def _as_hub_addressed(model_name):
     """The repo id part of a name, the way `HfFileSystem` itself addresses it.
 
@@ -4538,6 +4572,12 @@ def _as_hub_addressed(model_name):
     """
     name = str(model_name)
     if name.startswith("hf://"): name = name[len("hf://"):]
+    # `models/namespace/name` is the typed form of the same model address, and where
+    # the installed version reads it that way its three segments must not read as a
+    # filesystem path. Gated on the parser rather than stripped outright, because on
+    # a version that does not map the prefix this would probe a different repo.
+    if name.startswith("models/") and _hub_addresses_typed_model_uris():
+        name = name[len("models/"):]
     # Split a revision only when what precedes it is addressable, so an `@` inside
     # an ordinary path is left alone. `gpt2@main` counts: the zero-slash branch of
     # `resolve_path` splits `@` too, so a canonical single segment id carries a