vicinity 0.1.0__tar.gz → 0.2.0__tar.gz

vicinity-0.2.0/.github/workflows/ci.yaml

@@ -0,0 +1,67 @@
+name: Run tests and upload coverage
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
+
+jobs:
+  test:
+    name: Run tests with pytest
+    if: ${{ !github.event.pull_request.draft }}  # Skip draft PRs
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: ["ubuntu-latest", "windows-latest"]
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+        exclude:
+          - os: windows-latest
+            python-version: "3.9"
+          - os: windows-latest
+            python-version: "3.11"
+          - os: windows-latest
+            python-version: "3.12"
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }} on ${{ matrix.os }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          allow-prereleases: true
+
+      # Step for Windows: Create and activate a virtual environment
+      - name: Create and activate a virtual environment (Windows)
+        if: ${{ runner.os == 'Windows' }}
+        run: |
+          irm https://astral.sh/uv/install.ps1 | iex
+          $env:Path = "C:\Users\runneradmin\.local\bin;$env:Path"
+          uv venv .venv
+          "VIRTUAL_ENV=.venv" | Out-File -FilePath $env:GITHUB_ENV -Append
+          "$PWD/.venv/Scripts" | Out-File -FilePath $env:GITHUB_PATH -Append
+
+      # Step for Unix: Create and activate a virtual environment
+      - name: Create and activate a virtual environment (Unix)
+        if: ${{ runner.os != 'Windows' }}
+        run: |
+          curl -LsSf https://astral.sh/uv/install.sh | sh
+          uv venv .venv
+          echo "VIRTUAL_ENV=.venv" >> $GITHUB_ENV
+          echo "$PWD/.venv/bin" >> $GITHUB_PATH
+
+      # Install dependencies using uv pip
+      - name: Install dependencies
+        run: make install-no-pre-commit
+
+      # Run tests with coverage
+      - name: Run tests under coverage
+        run: |
+          coverage run -m pytest
+          coverage report
+
+      # Upload results to Codecov
+      - name: Upload results to Codecov
+        uses: codecov/codecov-action@v4
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}

vicinity-0.2.0/Makefile

@@ -0,0 +1,21 @@
+clean:
+
+
+venv:
+	uv venv
+
+install: venv
+	uv sync --all-extras
+	uv run pre-commit install
+
+install-no-pre-commit:
+	uv pip install ".[dev,hnsw,pynndescent,annoy,faiss]"
+
+install-base:
+	uv sync --extra dev
+
+fix:
+	uv run pre-commit run --all-files
+
+test:
+	uv run pytest --cov=vicinity --cov-report=term-missing

{vicinity-0.1.0 → vicinity-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vicinity
-Version: 0.1.0
+Version: 0.2.0
 Summary: Lightweight Nearest Neighbors with Flexible Backends
 Author-email: Stéphan Tulkens <stephantul@gmail.com>, Thomas van Dongen <thomas123@live.nl>
 License: MIT License
@@ -25,6 +25,9 @@ License: MIT License
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
         
+Project-URL: Homepage, https://github.com/MinishLab
+Project-URL: Bug Reports, https://github.com/MinishLab/vicinity/issues
+Project-URL: Source, https://github.com/MinishLab/vicinity
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -32,10 +35,11 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.10
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
@@ -49,8 +53,18 @@ Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-coverage; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
+Requires-Dist: setuptools; extra == "dev"
 Provides-Extra: hnsw
 Requires-Dist: hnswlib; extra == "hnsw"
+Provides-Extra: pynndescent
+Requires-Dist: pynndescent>=0.5.10; extra == "pynndescent"
+Requires-Dist: numba>=0.59.0; extra == "pynndescent"
+Requires-Dist: llvmlite>=0.42.0; extra == "pynndescent"
+Requires-Dist: numpy>=1.24.0; extra == "pynndescent"
+Provides-Extra: annoy
+Requires-Dist: annoy; extra == "annoy"
+Provides-Extra: faiss
+Requires-Dist: faiss-cpu; extra == "faiss"
 
 <div align="center">
 
@@ -58,11 +72,28 @@ Requires-Dist: hnswlib; extra == "hnsw"
 
 </div>
 
+
+<div align="center">
+  <h2>
+    <a href="https://pypi.org/project/vicinity/"><img src="https://img.shields.io/pypi/v/vicinity?color=%23007ec6&label=pypi%20package" alt="Package version"></a>
+    <a href="https://pypi.org/project/vicinity/"><img src="https://img.shields.io/pypi/pyversions/vicinity" alt="Supported Python versions"></a>
+    <a href="https://pepy.tech/project/vicinity">
+    <img src="https://static.pepy.tech/badge/vicinity" alt="Downloads">
+    </a>
+    <a href="https://app.codecov.io/gh/MinishLab/vicinity">
+    <img src="https://codecov.io/gh/MinishLab/vicinity/graph/badge.svg?token=0MQ2945OZL" alt="Codecov">
+    </a>
+    <a href="https://github.com/MinishLab/vicinity/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-green" alt="License - MIT"></a>
+  </h2>
+</div>
+
+
 ## Table of contents
 
 - [Quickstart](#quickstart)
 - [Main Features](#main-features)
 - [Supported Backends](#supported-backends)
+  - [Backend Parameters](#backend-parameters)
 - [Usage](#usage)
 
 Vicinity is the lightest-weight vector store. Just put in some vectors, calculate query vectors, and off you go. It provides a simple and intuitive API for nearest neighbor search, with support for different backends.
@@ -113,6 +144,29 @@ Vicinity provides the following features:
 The following backends are supported:
 - `BASIC`: A simple flat index for vector storage and search.
 - `HNSW`: Hierarchical Navigable Small World Graph for approximate nearest neighbor search.
+- `FAISS`: All FAISS indexes for approximate nearest neighbor search are supported.
+- `ANNOY`: "Approximate Nearest Neighbors Oh Yeah" for approximate nearest neighbor search.
+- `PYNNDescent`: Approximate nearest neighbor search using PyNNDescent.
+
+### Backend Parameters
+
+| Backend        | Parameter          | Description                                                                                   | Default Value       |
+|----------------|--------------------|-----------------------------------------------------------------------------------------------|---------------------|
+| **Annoy**      | `metric`           | Similarity metric to use (`dot`, `euclidean`, `cosine`).                                      | `"cosine"`          |
+|                | `trees`            | Number of trees to use for indexing.                                                          | `100`               |
+|                | `length`           | Optional length of the dataset.                                                               | `None`              |
+| **FAISS**      | `index_type`       | Type of FAISS index (`flat`, `ivf`, `hnsw`, `lsh`, `scalar`, `pq`, `ivf_scalar`, `ivfpq`, `ivfpqr`). | `"hnsw"`           |
+|                | `metric`           | Similarity metric to use (`cosine`, `l2`).                                                    | `"cosine"`          |
+|                | `nlist`            | Number of cells for IVF indexes.                                                              | `100`               |
+|                | `m`                | Number of subquantizers for PQ and HNSW indexes.                                              | `8`                 |
+|                | `nbits`            | Number of bits for LSH and PQ indexes.                                                        | `8`                 |
+|                | `refine_nbits`     | Number of bits for the refinement stage in IVFPQR indexes.                                    | `8`                 |
+| **HNSW**       | `space`            | Similarity space to use (`cosine`, `l2`).                                                     | `"cosine"`          |
+|                | `ef_construction`  | Size of the dynamic list during index construction.                                           | `200`               |
+|                | `m`                | Number of connections per layer.                                                              | `16`                |
+| **PyNNDescent**| `n_neighbors`      | Number of neighbors to use for search.                                                        | `15`                |
+|                | `metric`           | Similarity metric to use (`cosine`, `euclidean`, `manhattan`).                                | `"cosine"`          |
+
 
 ## Usage
 

vicinity-0.2.0/README.md

@@ -0,0 +1,186 @@
+<div align="center">
+
+# Vicinity: The Lightweight Vector Store
+
+</div>
+
+
+<div align="center">
+  <h2>
+    <a href="https://pypi.org/project/vicinity/"><img src="https://img.shields.io/pypi/v/vicinity?color=%23007ec6&label=pypi%20package" alt="Package version"></a>
+    <a href="https://pypi.org/project/vicinity/"><img src="https://img.shields.io/pypi/pyversions/vicinity" alt="Supported Python versions"></a>
+    <a href="https://pepy.tech/project/vicinity">
+    <img src="https://static.pepy.tech/badge/vicinity" alt="Downloads">
+    </a>
+    <a href="https://app.codecov.io/gh/MinishLab/vicinity">
+    <img src="https://codecov.io/gh/MinishLab/vicinity/graph/badge.svg?token=0MQ2945OZL" alt="Codecov">
+    </a>
+    <a href="https://github.com/MinishLab/vicinity/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-green" alt="License - MIT"></a>
+  </h2>
+</div>
+
+
+## Table of contents
+
+- [Quickstart](#quickstart)
+- [Main Features](#main-features)
+- [Supported Backends](#supported-backends)
+  - [Backend Parameters](#backend-parameters)
+- [Usage](#usage)
+
+Vicinity is the lightest-weight vector store. Just put in some vectors, calculate query vectors, and off you go. It provides a simple and intuitive API for nearest neighbor search, with support for different backends.
+
+## Quickstart
+
+Install the package with:
+```bash
+pip install vicinity
+```
+
+The following code snippet demonstrates how to use Vicinity for nearest neighbor search:
+```python
+import numpy as np
+from vicinity import Vicinity
+from vicinity.datatypes import Backend
+
+# Create some dummy data
+items = ["triforce", "master sword", "hylian shield", "boomerang", "hookshot"]
+vectors = np.random.rand(len(items), 128)
+
+# Initialize the Vicinity instance (using the basic backend)
+vicinity = Vicinity.from_vectors_and_items(vectors=vectors, items=items, backend_type=Backend.BASIC)
+
+# Query for nearest neighbors with a top-k search
+query_vector = np.random.rand(128)
+results = vicinity.query([query_vector], k=3)
+
+# Query for nearest neighbors with a threshold search
+results = vicinity.query_threshold([query_vector], threshold=0.9)
+
+# Save the vector store
+vicinity.save('my_vector_store')
+
+# Load the vector store
+vicinity = Vicinity.load('my_vector_store')
+```
+
+## Main Features
+Vicinity provides the following features:
+- Lightweight: Minimal dependencies and fast performance.
+- Flexible Backend Support: Use different backends for vector storage and search.
+- Dynamic Updates: Insert and delete items in the vector store.
+- Serialization: Save and load vector stores for persistence.
+- Easy to Use: Simple and intuitive API.
+
+## Supported Backends
+The following backends are supported:
+- `BASIC`: A simple flat index for vector storage and search.
+- `HNSW`: Hierarchical Navigable Small World Graph for approximate nearest neighbor search.
+- `FAISS`: All FAISS indexes for approximate nearest neighbor search are supported.
+- `ANNOY`: "Approximate Nearest Neighbors Oh Yeah" for approximate nearest neighbor search.
+- `PYNNDescent`: Approximate nearest neighbor search using PyNNDescent.
+
+### Backend Parameters
+
+| Backend        | Parameter          | Description                                                                                   | Default Value       |
+|----------------|--------------------|-----------------------------------------------------------------------------------------------|---------------------|
+| **Annoy**      | `metric`           | Similarity metric to use (`dot`, `euclidean`, `cosine`).                                      | `"cosine"`          |
+|                | `trees`            | Number of trees to use for indexing.                                                          | `100`               |
+|                | `length`           | Optional length of the dataset.                                                               | `None`              |
+| **FAISS**      | `index_type`       | Type of FAISS index (`flat`, `ivf`, `hnsw`, `lsh`, `scalar`, `pq`, `ivf_scalar`, `ivfpq`, `ivfpqr`). | `"hnsw"`           |
+|                | `metric`           | Similarity metric to use (`cosine`, `l2`).                                                    | `"cosine"`          |
+|                | `nlist`            | Number of cells for IVF indexes.                                                              | `100`               |
+|                | `m`                | Number of subquantizers for PQ and HNSW indexes.                                              | `8`                 |
+|                | `nbits`            | Number of bits for LSH and PQ indexes.                                                        | `8`                 |
+|                | `refine_nbits`     | Number of bits for the refinement stage in IVFPQR indexes.                                    | `8`                 |
+| **HNSW**       | `space`            | Similarity space to use (`cosine`, `l2`).                                                     | `"cosine"`          |
+|                | `ef_construction`  | Size of the dynamic list during index construction.                                           | `200`               |
+|                | `m`                | Number of connections per layer.                                                              | `16`                |
+| **PyNNDescent**| `n_neighbors`      | Number of neighbors to use for search.                                                        | `15`                |
+|                | `metric`           | Similarity metric to use (`cosine`, `euclidean`, `manhattan`).                                | `"cosine"`          |
+
+
+## Usage
+
+<details>
+<summary>  Creating a Vector Store
+ </summary>
+<br>
+
+You can create a Vicinity instance by providing items and their corresponding vectors:
+
+
+```python
+from vicinity import Vicinity
+import numpy as np
+
+items = ["triforce", "master sword", "hylian shield", "boomerang", "hookshot"]
+vectors = np.random.rand(len(items), 128)
+
+vicinity = Vicinity.from_vectors_and_items(vectors=vectors, items=items)
+```
+
+</details>
+
+<details>
+<summary>  Querying
+ </summary>
+<br>
+
+Find the k nearest neighbors for a given vector:
+
+```python
+query_vector = np.random.rand(128)
+results = vicinity.query([query_vector], k=3)
+```
+
+Find all neighbors within a given threshold:
+
+```python
+query_vector = np.random.rand(128)
+results = vicinity.query_threshold([query_vector], threshold=0.9)
+```
+</details>
+
+<details>
+
+<summary>  Inserting and Deleting Items
+ </summary>
+<br>
+
+Insert new items:
+
+```python
+new_items = ["ocarina", "bow"]
+new_vectors = np.random.rand(2, 128)
+vicinity.insert(new_items, new_vectors)
+```
+
+Delete items:
+
+```python
+vicinity.delete(["hookshot"])
+```
+</details>
+
+<details>
+<summary>  Saving and Loading
+ </summary>
+<br>
+
+Save the vector store:
+
+```python
+vicinity.save('my_vector_store')
+```
+
+Load the vector store:
+
+```python
+vicinity = Vicinity.load('my_vector_store')
+```
+</details>
+
+## License
+
+MIT

{vicinity-0.1.0 → vicinity-0.2.0}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vicinity"
 description = "Lightweight Nearest Neighbors with Flexible Backends"
 readme = { file = "README.md", content-type = "text/markdown" }
 dynamic = ["version"]
-requires-python = ">=3.10"
+requires-python = ">=3.9"
 license = { file = "LICENSE" }
 authors = [{ name = "Stéphan Tulkens", email = "stephantul@gmail.com"}, {name = "Thomas van Dongen", email = "thomas123@live.nl"}]
 
@@ -15,6 +15,7 @@ classifiers = [
     "Topic :: Software Development :: Libraries",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
@@ -39,8 +40,22 @@ dev = [
     "pytest",
     "pytest-coverage",
     "ruff",
+    "setuptools"
 ]
 hnsw = ["hnswlib"]
+pynndescent = [
+    "pynndescent>=0.5.10",
+    "numba>=0.59.0",
+    "llvmlite>=0.42.0",
+    "numpy>=1.24.0"
+]
+annoy = ["annoy"]
+faiss = ["faiss-cpu"]
+
+[project.urls]
+"Homepage" = "https://github.com/MinishLab"
+"Bug Reports" = "https://github.com/MinishLab/vicinity/issues"
+"Source" = "https://github.com/MinishLab/vicinity"
 
 [tool.ruff]
 exclude = [".venv/"]

vicinity-0.2.0/tests/conftest.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from vicinity import Vicinity
+from vicinity.datatypes import Backend
+
+random_gen = np.random.default_rng(42)
+
+_faiss_index_types = ["flat", "ivf", "hnsw", "lsh", "scalar", "pq", "ivf_scalar", "ivfpq", "ivfpqr"]
+
+
+@pytest.fixture(scope="session")
+def items() -> list[str]:
+    """Fixture providing a list of item names."""
+    return [f"item{i}" for i in range(1, 10001)]
+
+
+@pytest.fixture(scope="session")
+def vectors() -> np.ndarray:
+    """Fixture providing an array of vectors corresponding to items."""
+    return random_gen.random((10000, 8))
+
+
+@pytest.fixture(scope="session")
+def query_vector() -> np.ndarray:
+    """Fixture providing a query vector."""
+    return random_gen.random(8)
+
+
+BACKEND_PARAMS = [(Backend.FAISS, index_type) for index_type in _faiss_index_types] + [
+    (Backend.BASIC, None),
+    (Backend.HNSW, None),
+    (Backend.ANNOY, None),
+    (Backend.PYNNDESCENT, None),
+]
+
+# Create human-readable ids for each backend type
+BACKEND_IDS = [f"{backend.name}-{index_type}" if index_type else backend.name for backend, index_type in BACKEND_PARAMS]
+
+
+@pytest.fixture(params=BACKEND_PARAMS)
+def backend_type(request: pytest.FixtureRequest) -> Backend:
+    """Fixture parametrizing over all backend types defined in Backend."""
+    return request.param
+
+
+@pytest.fixture(params=BACKEND_PARAMS, ids=BACKEND_IDS)
+def vicinity_instance(request: pytest.FixtureRequest, items: list[str], vectors: np.ndarray) -> Vicinity:
+    """Fixture providing a Vicinity instance for each backend type."""
+    backend_type, index_type = request.param
+    # Handle FAISS backend with specific FAISS index types
+    if backend_type == Backend.FAISS:
+        if index_type in ("pq", "ivfpq", "ivfpqr"):
+            # Use smaller values for pq indexes since the dataset is small
+            return Vicinity.from_vectors_and_items(
+                vectors, items, backend_type=backend_type, index_type=index_type, m=2, nbits=4
+            )
+        else:
+            return Vicinity.from_vectors_and_items(
+                vectors, items, backend_type=backend_type, index_type=index_type, nlist=2, nbits=32
+            )
+
+    return Vicinity.from_vectors_and_items(vectors, items, backend_type=backend_type)

vicinity-0.1.0/tests/test_nearest.py → vicinity-0.2.0/tests/test_vicinity.py

@@ -8,16 +8,19 @@ import pytest
 from vicinity import Vicinity
 from vicinity.datatypes import Backend
 
+BackendType = tuple[Backend, str]
 
-def test_vicinity_init(backend_type: Backend, items: list[str], vectors: np.ndarray) -> None:
+
+def test_vicinity_init(backend_type: BackendType, items: list[str], vectors: np.ndarray) -> None:
     """
     Test Vicinity.init.
 
-    :param backend_type: The backend type to use (BASIC or HNSW).
+    :param backend_type: The backend type to use.
     :param items: A list of item names.
     :param vectors: An array of vectors.
     """
-    vicinity = Vicinity.from_vectors_and_items(vectors, items, backend_type=backend_type)
+    backend = backend_type[0]
+    vicinity = Vicinity.from_vectors_and_items(vectors, items, backend_type=backend)
     assert len(vicinity) == len(items)
     assert vicinity.items == items
     assert vicinity.dim == vectors.shape[1]
@@ -25,18 +28,19 @@ def test_vicinity_init(backend_type: Backend, items: list[str], vectors: np.ndar
     vectors = np.random.default_rng(42).random((len(items) - 1, 5))
 
     with pytest.raises(ValueError):
-        vicinity = Vicinity.from_vectors_and_items(vectors, items, backend_type=backend_type)
+        vicinity = Vicinity.from_vectors_and_items(vectors, items, backend_type=backend)
 
 
-def test_vicinity_from_vectors_and_items(backend_type: Backend, items: list[str], vectors: np.ndarray) -> None:
+def test_vicinity_from_vectors_and_items(backend_type: BackendType, items: list[str], vectors: np.ndarray) -> None:
     """
     Test Vicinity.from_vectors_and_items.
 
-    :param backend_type: The backend type to use (BASIC or HNSW).
+    :param backend_type: The backend type to use.
     :param items: A list of item names.
     :param vectors: An array of vectors.
     """
-    vicinity = Vicinity.from_vectors_and_items(vectors, items, backend_type=backend_type)
+    backend = backend_type[0]
+    vicinity = Vicinity.from_vectors_and_items(vectors, items, backend_type=backend)
 
     assert len(vicinity) == len(items)
     assert vicinity.items == items
@@ -67,7 +71,7 @@ def test_vicinity_query_threshold(vicinity_instance: Vicinity, query_vector: np.
     assert len(results) >= 1
 
 
-def test_vicinity_insert(backend_type: Backend, vicinity_instance: Vicinity, query_vector: np.ndarray) -> None:
+def test_vicinity_insert(vicinity_instance: Vicinity, query_vector: np.ndarray) -> None:
     """
     Test Vicinity.insert method.
 
@@ -75,18 +79,17 @@ def test_vicinity_insert(backend_type: Backend, vicinity_instance: Vicinity, que
     :param vicinity_instance: A Vicinity instance.
     :param query_vector: A query vector.
     """
-    if backend_type == Backend.HNSW:
-        # Don't test insert for HNSW backend
+    if vicinity_instance.backend.backend_type in {Backend.HNSW, Backend.ANNOY, Backend.PYNNDESCENT}:
+        # Skip insert for HNSW or Annoy backends.
         return
-    new_item = ["item101"]
+    new_item = ["item10001"]
     new_vector = query_vector
-
     vicinity_instance.insert(new_item, new_vector[None, :])
 
-    results = vicinity_instance.query(query_vector, k=1)
-    returned_item = results[0][0][0]
+    results = vicinity_instance.query(query_vector, k=50)
 
-    assert returned_item == "item101"
+    returned_items = [item for item, _ in results[0]]
+    assert "item10001" in returned_items
 
 
 def test_vicinity_delete(vicinity_instance: Vicinity, items: list[str], vectors: np.ndarray) -> None:
@@ -97,6 +100,17 @@ def test_vicinity_delete(vicinity_instance: Vicinity, items: list[str], vectors:
     :param items: List of item names.
     :param vectors: Array of vectors corresponding to items.
     """
+    if vicinity_instance.backend.backend_type in {Backend.ANNOY, Backend.PYNNDESCENT}:
+        # Skip delete for Annoy and Pynndescent backend
+        return
+
+    elif vicinity_instance.backend.backend_type == Backend.FAISS and vicinity_instance.backend.arguments.index_type in {
+        "hnsw",
+        "ivfpqr",
+    }:
+        # Skip delete test for FAISS index types that do not support deletion
+        return
+
     # Get the vector corresponding to "item2"
     item2_index = items.index("item2")
     item2_vector = vectors[item2_index]
@@ -150,7 +164,7 @@ def test_vicinity_delete_nonexistent(vicinity_instance: Vicinity) -> None:
     :raises ValueError: If deleting items that do not exist.
     """
     with pytest.raises(ValueError):
-        vicinity_instance.delete(["item102"])
+        vicinity_instance.delete(["item10002"])
 
 
 def test_vicinity_insert_mismatched_lengths(vicinity_instance: Vicinity, query_vector: np.ndarray) -> None:
@@ -160,7 +174,7 @@ def test_vicinity_insert_mismatched_lengths(vicinity_instance: Vicinity, query_v
     :param vicinity_instance: A Vicinity instance.
     :raises ValueError: If tokens and vectors lengths differ.
     """
-    new_items = ["item102", "item103"]
+    new_items = ["item10002", "item10003"]
     new_vector = query_vector
 
     with pytest.raises(ValueError):
@@ -174,7 +188,7 @@ def test_vicinity_insert_wrong_dimension(vicinity_instance: Vicinity) -> None:
     :param vicinity_instance: A Vicinity instance.
     :raises ValueError: If vectors have wrong dimension.
     """
-    new_item = ["item102"]
+    new_item = ["item10002"]
     new_vector = np.array([[0.5, 0.5, 0.5]])
 
     with pytest.raises(ValueError):