fix(python): scope Instructor compatibility shim

nodejs/.cargo/config.toml

@@ -1,21 +0,0 @@
-# Keep Node's Linux x64 addons compatible with pre-Haswell CPUs.
-# lance-linalg dispatches hot vector kernels to newer SIMD tiers at runtime.
-[env]
-LANCEDB_NODE_ENFORCE_X86_64_V2 = "1"
-
-[target.x86_64-unknown-linux-gnu]
-rustflags = [
-    "-C",
-    "target-cpu=x86-64-v2",
-    "-C",
-    "target-feature=-avx,-avx2,-fma,-f16c",
-]
-
-# Preserve the workspace's dynamic C runtime configuration for musl.
-[target.x86_64-unknown-linux-musl]
-rustflags = [
-    "-C",
-    "target-cpu=x86-64-v2",
-    "-C",
-    "target-feature=-crt-static,-avx,-avx2,-fma,-f16c",
-]

nodejs/Cargo.toml

@@ -12,10 +12,6 @@ categories.workspace = true
 [lib]
 crate-type = ["cdylib"]
 
-[[test]]
-name = "x86_64_v2_build_flags"
-path = "build_support/x86_64_v2.rs"
-
 [dependencies]
 async-trait.workspace = true
 arrow-ipc.workspace = true

nodejs/__test__/cpu_compatibility.test.ts

@@ -1,50 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-import * as tmp from "tmp";
-
-import { connect } from "../lancedb";
-import {
-  Field,
-  FixedSizeList,
-  Float32,
-  Int32,
-  Schema,
-  makeArrowTable,
-} from "../lancedb/arrow";
-
-test("cosine vector search runs on the pre-Haswell build baseline", async () => {
-  const tmpDir = tmp.dirSync({ unsafeCleanup: true });
-
-  try {
-    const db = await connect(tmpDir.name);
-    const schema = new Schema([
-      new Field("id", new Int32(), false),
-      new Field(
-        "vector",
-        new FixedSizeList(3, new Field("item", new Float32(), false)),
-        false,
-      ),
-    ]);
-    const data = makeArrowTable(
-      [
-        { id: 1, vector: [1, 0, 0] },
-        { id: 2, vector: [0, 1, 0] },
-      ],
-      { schema },
-    );
-    const table = await db.createTable("vectors", data);
-
-    const results = await table
-      .vectorSearch([1, 0, 0])
-      .distanceType("cosine")
-      .limit(1)
-      .toArray();
-
-    expect(results).toHaveLength(1);
-    expect(results[0].id).toBe(1);
-    expect(results[0]._distance).toBeCloseTo(0);
-  } finally {
-    tmpDir.removeCallback();
-  }
-}, 60_000);

nodejs/build.rs

@@ -3,29 +3,6 @@
 
 extern crate napi_build;
 
-use std::env;
-
-#[path = "build_support/x86_64_v2.rs"]
-mod x86_64_v2;
-
-const ENFORCE_BASELINE: &str = "LANCEDB_NODE_ENFORCE_X86_64_V2";
-
 fn main() {
     napi_build::setup();
-    println!("cargo:rerun-if-env-changed={ENFORCE_BASELINE}");
-    println!("cargo:rerun-if-env-changed=CARGO_ENCODED_RUSTFLAGS");
-
-    let is_linux_x64 = env::var("CARGO_CFG_TARGET_ARCH").as_deref() == Ok("x86_64")
-        && env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("linux");
-    let is_release = env::var("PROFILE").as_deref() == Ok("release");
-    let is_node_build = env::var(ENFORCE_BASELINE).as_deref() == Ok("1");
-
-    if !is_linux_x64 || (!is_release && !is_node_build) {
-        return;
-    }
-
-    let encoded_rustflags = env::var("CARGO_ENCODED_RUSTFLAGS").unwrap_or_default();
-    x86_64_v2::validate_encoded_rustflags(&encoded_rustflags).unwrap_or_else(|error| {
-        panic!("Linux x64 Node addons must use the x86-64-v2 baseline; {error}")
-    });
 }

nodejs/build_support/x86_64_v2.rs

@@ -1,430 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-use std::collections::{BTreeMap, BTreeSet};
-
-const SAFE_TARGET_CPUS: [&str; 2] = ["x86-64", "x86-64-v2"];
-const BASELINE_FEATURES: [&str; 9] = [
-    "cmpxchg16b",
-    "fxsr",
-    "popcnt",
-    "sse",
-    "sse2",
-    "sse3",
-    "sse4.1",
-    "sse4.2",
-    "ssse3",
-];
-
-pub(crate) fn validate_encoded_rustflags(encoded: &str) -> Result<(), String> {
-    let mut target_cpu = None;
-    let mut feature_states = BTreeMap::new();
-    let mut required_disables = BTreeSet::new();
-    let mut unsupported_features = BTreeSet::new();
-
-    for option in codegen_options(encoded)? {
-        let Some((name, value)) = option.split_once('=') else {
-            continue;
-        };
-
-        let name = name.replace('_', "-");
-        match name.as_str() {
-            "target-cpu" => target_cpu = Some(value),
-            "target-feature" => {
-                for toggle in value.split(',').filter(|toggle| !toggle.is_empty()) {
-                    let (enabled, feature) = match toggle.as_bytes()[0] {
-                        b'+' => (true, &toggle[1..]),
-                        b'-' => (false, &toggle[1..]),
-                        _ => return Err(format!("invalid target feature flag: {toggle}")),
-                    };
-
-                    feature_states.insert(feature, enabled);
-                    if enabled && !BASELINE_FEATURES.contains(&feature) {
-                        match feature {
-                            // These are inherited from the workspace configuration and
-                            // explicitly canceled by the Node configuration. Account for
-                            // their implied AVX prerequisite as well as the named feature.
-                            "avx" => {
-                                required_disables.insert("avx");
-                            }
-                            "avx2" => {
-                                required_disables.extend(["avx", "avx2"]);
-                            }
-                            "f16c" => {
-                                required_disables.extend(["avx", "f16c"]);
-                            }
-                            "fma" => {
-                                required_disables.extend(["avx", "fma"]);
-                            }
-                            _ => {
-                                unsupported_features.insert(feature);
-                            }
-                        }
-                    }
-                }
-            }
-            // LLVM arguments can independently alter the target feature set and
-            // cannot be proven safe by inspecting rustc's target options.
-            "llvm-args" => return Err("LLVM arguments can override the CPU baseline".to_owned()),
-            _ => {}
-        }
-    }
-
-    if let Some(cpu) = target_cpu.filter(|cpu| !SAFE_TARGET_CPUS.contains(cpu)) {
-        return Err(format!(
-            "effective target CPU is {}, expected x86-64-v2 or lower",
-            cpu
-        ));
-    }
-
-    if !unsupported_features.is_empty() {
-        return Err(format!(
-            "features above v2: {}",
-            unsupported_features
-                .into_iter()
-                .collect::<Vec<_>>()
-                .join(", ")
-        ));
-    }
-
-    let not_disabled = required_disables
-        .into_iter()
-        .filter(|feature| feature_states.get(feature) != Some(&false))
-        .collect::<Vec<_>>();
-    if !not_disabled.is_empty() {
-        return Err(format!(
-            "inherited features not fully disabled: {}",
-            not_disabled.join(", ")
-        ));
-    }
-
-    Ok(())
-}
-
-fn codegen_options(encoded: &str) -> Result<Vec<&str>, String> {
-    let arguments = encoded.split('\u{1f}').collect::<Vec<_>>();
-    if arguments.iter().any(|argument| argument.starts_with('@')) {
-        return Err("rustc response-file arguments cannot be validated".to_owned());
-    }
-
-    let mut options = Vec::new();
-    let mut index = 0;
-
-    while index < arguments.len() {
-        let argument = arguments[index];
-        if argument == "--cfg" {
-            index += 1;
-            let cfg = arguments
-                .get(index)
-                .copied()
-                .ok_or_else(|| "missing value after --cfg".to_owned())?;
-            reject_builtin_target_feature_cfg(cfg)?;
-        } else if let Some(cfg) = argument.strip_prefix("--cfg=") {
-            reject_builtin_target_feature_cfg(cfg)?;
-        } else if argument == "-C" || argument == "--codegen" {
-            index += 1;
-            let option = arguments
-                .get(index)
-                .copied()
-                .ok_or_else(|| format!("missing value after {argument}"))?;
-            options.push(option.trim_start_matches('='));
-        } else if let Some(option) = argument.strip_prefix("-C") {
-            if !option.is_empty() {
-                options.push(option.trim_start_matches('='));
-            }
-        } else if let Some(option) = argument.strip_prefix("--codegen=") {
-            options.push(option);
-        }
-        index += 1;
-    }
-
-    Ok(options)
-}
-
-fn reject_builtin_target_feature_cfg(cfg: &str) -> Result<(), String> {
-    let key = cfg.split_once('=').map_or(cfg, |(key, _)| key);
-    if key.contains("/*") || key.contains("//") {
-        return Err("comment-bearing cfgs cannot be validated".to_owned());
-    }
-    if !key.is_ascii() {
-        return Err("non-ASCII cfg keys cannot be validated".to_owned());
-    }
-
-    let name = key.trim();
-    let name = name.strip_prefix("r#").unwrap_or(name);
-    if name == "target_feature" {
-        return Err("built-in target_feature cfgs can override runtime CPU detection".to_owned());
-    }
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn encoded(arguments: &[&str]) -> String {
-        arguments.join("\u{1f}")
-    }
-
-    #[test]
-    fn accepts_merged_workspace_and_node_flags() {
-        let flags = encoded(&[
-            "-C",
-            "target-cpu=haswell",
-            "-C",
-            "target-feature=+avx2,+fma,+f16c",
-            "-C",
-            "target-cpu=x86-64-v2",
-            "-C",
-            "target-feature=-avx,-avx2,-fma,-f16c",
-        ]);
-
-        assert_eq!(validate_encoded_rustflags(&flags), Ok(()));
-    }
-
-    #[test]
-    fn accepts_non_merging_v2_boundary() {
-        let flags = encoded(&["-Ctarget-cpu=x86-64-v2"]);
-
-        assert_eq!(validate_encoded_rustflags(&flags), Ok(()));
-    }
-
-    #[test]
-    fn accepts_default_cpu_with_non_codegen_flags() {
-        let flags = encoded(&["-D", "warnings"]);
-
-        assert_eq!(validate_encoded_rustflags(&flags), Ok(()));
-    }
-
-    #[test]
-    fn accepts_unrelated_custom_cfg() {
-        let flags = encoded(&["--cfg=tokio_unstable"]);
-
-        assert_eq!(validate_encoded_rustflags(&flags), Ok(()));
-    }
-
-    #[test]
-    fn accepts_comment_like_syntax_in_cfg_value() {
-        let flags = encoded(&[r#"--cfg=endpoint="https://example.com/*""#]);
-
-        assert_eq!(validate_encoded_rustflags(&flags), Ok(()));
-    }
-
-    #[test]
-    fn accepts_explicit_x86_64_v1_cpu() {
-        let flags = encoded(&["-Ctarget-cpu=x86-64"]);
-
-        assert_eq!(validate_encoded_rustflags(&flags), Ok(()));
-    }
-
-    #[test]
-    fn accepts_musl_dynamic_crt_configuration() {
-        let flags = encoded(&[
-            "-C",
-            "target-cpu=haswell",
-            "-C",
-            "target-feature=-crt-static,+avx2,+fma,+f16c",
-            "-C",
-            "target-cpu=x86-64-v2",
-            "-C",
-            "target-feature=-crt-static,-avx,-avx2,-fma,-f16c",
-        ]);
-
-        assert_eq!(validate_encoded_rustflags(&flags), Ok(()));
-    }
-
-    #[test]
-    fn rejects_feature_omitted_from_target_cfg() {
-        let flags = encoded(&["-Ctarget-cpu=x86-64-v2", "-Ctarget-feature=+apxf"]);
-
-        assert_eq!(
-            validate_encoded_rustflags(&flags),
-            Err("features above v2: apxf".to_owned())
-        );
-    }
-
-    #[test]
-    fn rejects_underscore_spelling_above_baseline_feature() {
-        let flags = encoded(&["-Ctarget_cpu=x86-64-v2", "-Ctarget_feature=+apxf"]);
-
-        assert_eq!(
-            validate_encoded_rustflags(&flags),
-            Err("features above v2: apxf".to_owned())
-        );
-    }
-
-    #[test]
-    fn rejects_unexpected_above_baseline_feature() {
-        let flags = encoded(&[
-            "--codegen=target-cpu=x86-64-v2",
-            "--codegen",
-            "target-feature=+bmi2",
-        ]);
-
-        assert_eq!(
-            validate_encoded_rustflags(&flags),
-            Err("features above v2: bmi2".to_owned())
-        );
-    }
-
-    #[test]
-    fn rejects_cpu_above_v2() {
-        let flags = encoded(&["-Ctarget-cpu=haswell"]);
-
-        assert_eq!(
-            validate_encoded_rustflags(&flags),
-            Err("effective target CPU is haswell, expected x86-64-v2 or lower".to_owned())
-        );
-    }
-
-    #[test]
-    fn rejects_incompletely_disabled_feature_implications() {
-        let flags = encoded(&["-Ctarget-cpu=x86-64-v2", "-Ctarget-feature=+avx2,-avx2"]);
-
-        assert_eq!(
-            validate_encoded_rustflags(&flags),
-            Err("inherited features not fully disabled: avx".to_owned())
-        );
-    }
-
-    #[test]
-    fn rejects_llvm_feature_overrides() {
-        let flags = encoded(&["-Ctarget-cpu=x86-64-v2", "-Cllvm-args=-mattr=+apxf"]);
-
-        assert_eq!(
-            validate_encoded_rustflags(&flags),
-            Err("LLVM arguments can override the CPU baseline".to_owned())
-        );
-    }
-
-    #[test]
-    fn rejects_underscore_spelling_llvm_feature_overrides() {
-        let flags = encoded(&["-Ctarget_cpu=x86-64-v2", "-Cllvm_args=-mattr=+apxf"]);
-
-        assert_eq!(
-            validate_encoded_rustflags(&flags),
-            Err("LLVM arguments can override the CPU baseline".to_owned())
-        );
-    }
-
-    #[test]
-    fn rejects_response_file_arguments() {
-        let flags = encoded(&["-Ctarget-cpu=x86-64-v2", "@flags.rsp"]);
-
-        assert_eq!(
-            validate_encoded_rustflags(&flags),
-            Err("rustc response-file arguments cannot be validated".to_owned())
-        );
-    }
-
-    #[test]
-    fn rejects_split_builtin_target_feature_cfg() {
-        let flags = encoded(&[
-            "-Ctarget-cpu=x86-64-v2",
-            "--cfg",
-            r#"target_feature="avx2""#,
-            "-Aexplicit_builtin_cfgs_in_flags",
-        ]);
-
-        assert_eq!(
-            validate_encoded_rustflags(&flags),
-            Err("built-in target_feature cfgs can override runtime CPU detection".to_owned())
-        );
-    }
-
-    #[test]
-    fn rejects_equals_builtin_target_feature_cfg() {
-        let flags = encoded(&[
-            "-Ctarget-cpu=x86-64-v2",
-            r#"--cfg=target_feature="avx2""#,
-            "-Aexplicit_builtin_cfgs_in_flags",
-        ]);
-
-        assert_eq!(
-            validate_encoded_rustflags(&flags),
-            Err("built-in target_feature cfgs can override runtime CPU detection".to_owned())
-        );
-    }
-
-    #[test]
-    fn rejects_raw_identifier_builtin_target_feature_cfg() {
-        let flags = encoded(&[
-            "-Ctarget-cpu=x86-64-v2",
-            r#"--cfg=r#target_feature="avx2""#,
-            "-Aexplicit_builtin_cfgs_in_flags",
-        ]);
-
-        assert_eq!(
-            validate_encoded_rustflags(&flags),
-            Err("built-in target_feature cfgs can override runtime CPU detection".to_owned())
-        );
-    }
-
-    #[test]
-    fn rejects_block_comment_after_cfg_name() {
-        let flags = encoded(&[
-            "--cfg",
-            r#"target_feature/*gate*/="avx2""#,
-            "-Aexplicit_builtin_cfgs_in_flags",
-        ]);
-
-        assert_eq!(
-            validate_encoded_rustflags(&flags),
-            Err("comment-bearing cfgs cannot be validated".to_owned())
-        );
-    }
-
-    #[test]
-    fn rejects_block_comment_before_cfg_name() {
-        let flags = encoded(&[
-            r#"--cfg=/*gate*/target_feature="avx2""#,
-            "-Aexplicit_builtin_cfgs_in_flags",
-        ]);
-
-        assert_eq!(
-            validate_encoded_rustflags(&flags),
-            Err("comment-bearing cfgs cannot be validated".to_owned())
-        );
-    }
-
-    #[test]
-    fn rejects_line_comment_cfg_trivia() {
-        let flags = encoded(&[
-            "--cfg",
-            "target_feature// gate\n=\"avx2\"",
-            "-Aexplicit_builtin_cfgs_in_flags",
-        ]);
-
-        assert_eq!(
-            validate_encoded_rustflags(&flags),
-            Err("comment-bearing cfgs cannot be validated".to_owned())
-        );
-    }
-
-    #[test]
-    fn rejects_leading_bom_in_cfg_key() {
-        let flags = encoded(&[
-            "--cfg",
-            "\u{feff}target_feature=\"avx2\"",
-            "-Aexplicit_builtin_cfgs_in_flags",
-        ]);
-
-        assert_eq!(
-            validate_encoded_rustflags(&flags),
-            Err("non-ASCII cfg keys cannot be validated".to_owned())
-        );
-    }
-
-    #[test]
-    fn rejects_non_ascii_pattern_whitespace_in_cfg_key() {
-        for whitespace in ['\u{200e}', '\u{200f}'] {
-            let cfg = format!("{whitespace}target_feature=\"avx2\"");
-            let flags = encoded(&["--cfg", &cfg, "-Aexplicit_builtin_cfgs_in_flags"]);
-
-            assert_eq!(
-                validate_encoded_rustflags(&flags),
-                Err("non-ASCII cfg keys cannot be validated".to_owned())
-            );
-        }
-    }
-}

nodejs/ci/pre_haswell_smoke.js

@@ -1,37 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-const assert = require("node:assert/strict");
-const fs = require("node:fs");
-const os = require("node:os");
-const path = require("node:path");
-
-const { connect } = require("../dist");
-
-async function main() {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "lancedb-cpu-"));
-
-  try {
-    const db = await connect(tmpDir);
-    const table = await db.createTable("vectors", [
-      { id: 1, vector: [1, 0, 0] },
-      { id: 2, vector: [0, 1, 0] },
-    ]);
-    const results = await table
-      .vectorSearch([1, 0, 0])
-      .distanceType("cosine")
-      .limit(1)
-      .toArray();
-
-    assert.equal(results.length, 1);
-    assert.equal(results[0].id, 1);
-    assert.ok(Math.abs(results[0]._distance) < 1e-6);
-  } finally {
-    fs.rmSync(tmpDir, { force: true, recursive: true });
-  }
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});

nodejs/package.json

@@ -88,7 +88,6 @@
     "lint-fix": "biome check --write . && biome format --write .",
     "prepublishOnly": "napi prepublish -t npm",
     "test": "jest --verbose",
-    "test:pre-haswell": "node ci/pre_haswell_smoke.js",
     "integration": "S3_TEST=1 pnpm test",
     "universal": "napi universalize",
     "version": "napi version"

python/python/lancedb/embeddings/instructor.py

@@ -3,6 +3,7 @@
 
 
 from typing import List
+from urllib.parse import unquote, urlparse
 
 import numpy as np
 
@@ -125,9 +126,20 @@ class InstructorEmbeddingFunction(TextEmbeddingFunction):
 
     @weak_lru(maxsize=1)
     def get_model(self):
-        instructor_embedding = attempt_import_or_raise(
-            "InstructorEmbedding", "InstructorEmbedding"
-        )
+        huggingface_hub = attempt_import_or_raise("huggingface_hub", "huggingface-hub")
+        missing = object()
+        original_cached_download = getattr(huggingface_hub, "cached_download", missing)
+        if original_cached_download is missing:
+            huggingface_hub.cached_download = _cached_download(huggingface_hub)
+
+        try:
+            instructor_embedding = attempt_import_or_raise(
+                "InstructorEmbedding", "InstructorEmbedding"
+            )
+        finally:
+            if original_cached_download is missing:
+                del huggingface_hub.cached_download
+
         torch = attempt_import_or_raise("torch", "torch")
 
         model = instructor_embedding.INSTRUCTOR(self.name)
@@ -140,3 +152,44 @@ class InstructorEmbeddingFunction(TextEmbeddingFunction):
                 model, {torch.nn.Linear}, dtype=torch.qint8
             )
         return model
+
+
+def _cached_download(huggingface_hub):
+    """Provide the legacy download API used by sentence-transformers 2.2.x."""
+
+    def cached_download(
+        *,
+        url,
+        cache_dir=None,
+        force_filename=None,
+        library_name=None,
+        library_version=None,
+        user_agent=None,
+        use_auth_token=None,
+        **_,
+    ):
+        path = urlparse(url).path.lstrip("/")
+        try:
+            repo_id, resolved_path = path.split("/resolve/", maxsplit=1)
+            revision, filename = resolved_path.split("/", maxsplit=1)
+        except ValueError as err:
+            raise ValueError(f"Unsupported Hugging Face Hub URL: {url}") from err
+
+        repo_id = unquote(repo_id)
+        revision = unquote(revision)
+        filename = unquote(filename)
+        # sentence-transformers derives force_filename from this Hub path with
+        # os.path.join. Using the URL path beneath local_dir produces the same
+        # local destination without sending Windows separators to the Hub.
+        return huggingface_hub.hf_hub_download(
+            repo_id=repo_id,
+            filename=filename,
+            revision=revision,
+            local_dir=cache_dir,
+            library_name=library_name,
+            library_version=library_version,
+            user_agent=user_agent,
+            token=use_auth_token,
+        )
+
+    return cached_download

python/python/tests/test_embeddings.py

@@ -1,8 +1,11 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright The LanceDB Authors
 
+import ntpath
 import os
 import pickle
+import sys
+from types import ModuleType
 from typing import List, Optional, Union
 from unittest.mock import MagicMock, patch
 
@@ -522,6 +525,59 @@ def test_embedding_function_safe_model_dump(embedding_type):
             )
 
 
+def test_instructor_embedding_supports_huggingface_hub_without_cached_download(
+    tmp_path, monkeypatch
+):
+    from lancedb.embeddings.instructor import InstructorEmbeddingFunction
+
+    hub_download = MagicMock(return_value="/cache/1_Pooling/config.json")
+    huggingface_hub = ModuleType("huggingface_hub")
+    huggingface_hub.hf_hub_download = hub_download
+    torch = ModuleType("torch")
+    monkeypatch.setitem(sys.modules, "huggingface_hub", huggingface_hub)
+    monkeypatch.setitem(sys.modules, "torch", torch)
+    monkeypatch.delitem(sys.modules, "InstructorEmbedding", raising=False)
+    monkeypatch.syspath_prepend(str(tmp_path))
+
+    (tmp_path / "InstructorEmbedding.py").write_text(
+        "from huggingface_hub import cached_download\n\n"
+        "class INSTRUCTOR:\n"
+        "    def __init__(self, name):\n"
+        "        self.name = name\n"
+    )
+
+    embedding = InstructorEmbeddingFunction.create(show_progress_bar=False)
+    instructor_model = embedding.get_model()
+
+    assert instructor_model.name == "hkunlp/instructor-base"
+    assert not hasattr(huggingface_hub, "cached_download")
+
+    instructor_embedding = sys.modules["InstructorEmbedding"]
+    path = instructor_embedding.cached_download(
+        url=(
+            "https://huggingface.co/hkunlp/instructor-base/resolve/abc123/"
+            "1_Pooling/config.json"
+        ),
+        cache_dir="/cache",
+        force_filename=ntpath.join("1_Pooling", "config.json"),
+        library_name="sentence-transformers",
+        library_version="2.2.2",
+        use_auth_token="token",
+    )
+
+    assert path == "/cache/1_Pooling/config.json"
+    hub_download.assert_called_once_with(
+        repo_id="hkunlp/instructor-base",
+        filename="1_Pooling/config.json",
+        revision="abc123",
+        local_dir="/cache",
+        library_name="sentence-transformers",
+        library_version="2.2.2",
+        user_agent=None,
+        token="token",
+    )
+
+
 @patch("time.sleep")
 def test_retry(mock_sleep):
     test_function = MagicMock(side_effect=[Exception] * 9 + ["result"])