pyglass-portable 2.1.0__tar.gz

pyglass_portable-2.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 zh Wang
+
+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.

pyglass_portable-2.1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: pyglass-portable
+Version: 2.1.0
+Summary: Portable wheels of pyglass (zilliztech) — a fast HNSW/NSG graph ANN library that builds and runs on macOS (Apple Silicon and Intel) and non-AVX-512 x86 (AMD, older Intel). Imported as `glass`.
+Author: Zihao Wang
+Maintainer: Ian Driver
+License: MIT
+Project-URL: Homepage, https://github.com/iandriver/pyglass
+Project-URL: Upstream, https://github.com/zilliztech/pyglass
+Project-URL: Issues, https://github.com/iandriver/pyglass/issues
+Keywords: nearest-neighbors,ann,hnsw,nsg,vector-search,pyglass,similarity-search
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C++
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: license-file
+
+# pyglass-portable
+
+Portable prebuilt wheels of [**pyglass**](https://github.com/zilliztech/pyglass)
+(zilliztech) — a fast HNSW / NSG graph-based approximate-nearest-neighbor library.
+
+Upstream publishes only an **AVX-512** x86_64 wheel, which crashes (`SIGILL`) on
+CPUs without AVX-512 — Apple Silicon, AMD, older Intel. pyglass's *source* is
+portable (AVX2 / NEON / scalar kernels); this repackage builds it with a portable
+baseline so it installs and runs on those machines too. **The import name stays
+`glass`** — it's a drop-in for upstream, not a fork of the algorithm.
+
+```bash
+uv pip install pyglass-portable      # or: pip install pyglass-portable
+```
+
+Prebuilt wheels: Linux x86_64 (AVX2) and macOS arm64 (NEON), Python 3.9+. Intel
+Macs and ARM Linux build from the sdist — `pip install` compiles it portably (it
+needs a C++20 compiler; on macOS, `brew install libomp`).
+
+```python
+import numpy as np, glass
+
+X = np.random.rand(100_000, 128).astype("float32")
+index = glass.Index("HNSW", "L2", "FP32", R=32, L=200)
+graph = index.build(X)
+searcher = glass.Searcher(graph, X, "L2", "FP32")
+searcher.set_ef(64); searcher.optimize()
+ids, dists = searcher.batch_search(X[:1000], 10)
+```
+
+It also works as a `scanpy` neighbors backend via
+[`pipnn.contrib.GlassTransformer`](https://github.com/iandriver/pipnn-scanpy).
+
+## Relationship to upstream
+
+This is an unofficial repackage for platform coverage only — **no algorithm
+changes**. The portability fixes are proposed upstream in
+[zilliztech/pyglass#24](https://github.com/zilliztech/pyglass/pull/24); if they
+land and upstream ships portable wheels, prefer `glassppy`. Version tracks the
+upstream source version.
+
+Credit to the pyglass authors (Zihao Wang / zilliztech). MIT licensed, same as
+upstream.

pyglass_portable-2.1.0/README.md

@@ -0,0 +1,155 @@
+# Graph Library for Approximate Similarity Search
+
+pyglass is a library for fast inference of graph index for approximate similarity search.
+
+## Features
+
+- Supports multiple graph algorithms, like [**HNSW**](https://github.com/nmslib/hnswlib) and [**NSG**](https://github.com/ZJULearning/nsg).
+- Supports multiple hardware platforms, like **X86** and **ARM**. Support for **GPU** is on the way
+- No third-party library dependencies, does not rely on OpenBLAS / MKL or any other computing framework.
+- Sophisticated memory management and data structure design, very low memory footprint.
+- It's high performant.
+
+## Getting Started
+
+Install pyglass with pip
+
+```bash
+pip install -v -e "python"
+```
+
+### Using uv
+
+It is recommended to use `uv` for setting up the development environment.
+
+1. **Install `uv`**
+```bash
+pip install uv
+```
+
+2. **Create and Activate Virtual Environment**
+```bash
+# Create the virtual environment in a .venv directory
+uv venv
+# Activate the environment (on bash/zsh)
+source .venv/bin/activate
+```
+*Note: For other shells like Fish or Powershell, use the corresponding activation script in the `.venv/bin/` directory.*
+
+3. **Install the Project**
+```bash
+# Install the project and its dependencies in editable mode
+uv pip install -v -e "python"
+```
+
+### Development
+
+For C++ development, you might want to generate a `compile_commands.json` file for your editor's language server. You can use [Bear](https://github.com/rizsotto/Bear) to do this.
+
+**1. Install Bear**
+
+On Debian-based systems (like Ubuntu), you can install Bear with:
+```bash
+apt install bear
+```
+
+**2. Generate `compile_commands.json`**
+
+Run the installation command from within `bear`:
+```bash
+bear -- uv pip install -v -e "python"
+```
+This will create a `compile_commands.json` file in the project's root directory.
+
+## Quick Tour
+A runnable demo is at [examples/demo.ipynb](https://github.com/zilliztech/pyglass/blob/master/examples/demo.ipynb). It's highly recommended to try it.
+
+## Usage
+**Import library**
+```python
+>>> import glass
+```
+**Load Data**
+```python
+>>> import numpy as np
+>>> n, d = 10000, 128
+>>> X = np.random.randn(n, d)
+>>> Y = np.random.randn(d)
+```
+**Create Index**
+pyglass supports **HNSW** and **NSG** index currently, with different quantization support
+```python
+>>> index = glass.Index(index_type="HNSW", metric="L2", R=32, L=50)
+>>> index = glass.Index(index_type="NSG", metric="L2", R=32, L=50, quant="SQ8U")
+```
+**Build Graph**
+```python
+>>> graph = index.build(X)
+```
+**Create Searcher**
+```python
+>>> searcher = glass.Searcher(graph=graph, data=X, metric="L2", quantizer="SQ4U")
+>>> searcher.set_ef(32)
+```
+**(Optional) Optimize Searcher**
+```python
+>>> searcher.optimize()
+```
+**Searching**
+```python
+>>> ret = searcher.search(query=Y, k=10)
+>>> print(ret)
+```
+
+## Supported Quantization Methods
+
+- FP8_E5M2
+- PQ8
+- SQ8
+- SQ8U
+- SQ6
+- SQ4
+- SQ4U
+- SQ4UA
+- SQ2U
+- BinaryQuant
+
+**Rule of Thumb**: Use SQ8U for indexing, and SQ4U for searching is almost always a good choice.
+
+## Performance
+
+Glass is among one of the top performant ann algorithms on [ann-benchmarks](https://ann-benchmarks.com/)
+
+### fashion-mnist-784-euclidean
+![](docs/figures/fashion-mnist-784-euclidean_10_euclidean.png)
+### gist-960-euclidean
+![](docs/figures/gist-960-euclidean_10_euclidean.png)
+### sift-128-euclidean
+![](docs/figures/sift-128-euclidean_10_euclidean.png)
+
+### Quick Benchmark
+
+1. Change configuration file `examples/config.json`
+2. Run benchmark
+```
+python3 examples/main.py
+```
+If you encounter network issues when downloading datasets, you can try setting the `HF_ENDPOINT` environment variable to `https://hf-mirror.com` or something else.
+
+## Citation
+
+You can cite the PyGlass repo as follows:
+```bibtex
+@misc{PyGlass,
+    author = {Zihao Wang},
+    title = {Graph Library for Approximate Similarity Search},
+    url = {https://github.com/zilliztech/pyglass},
+    year = {2025},
+    month = {4},
+}
+```
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=zilliztech/pyglass&type=Date)](https://www.star-history.com/#zilliztech/pyglass&Date)
+

pyglass_portable-2.1.0/README_portable.md

@@ -0,0 +1,43 @@
+# pyglass-portable
+
+Portable prebuilt wheels of [**pyglass**](https://github.com/zilliztech/pyglass)
+(zilliztech) — a fast HNSW / NSG graph-based approximate-nearest-neighbor library.
+
+Upstream publishes only an **AVX-512** x86_64 wheel, which crashes (`SIGILL`) on
+CPUs without AVX-512 — Apple Silicon, AMD, older Intel. pyglass's *source* is
+portable (AVX2 / NEON / scalar kernels); this repackage builds it with a portable
+baseline so it installs and runs on those machines too. **The import name stays
+`glass`** — it's a drop-in for upstream, not a fork of the algorithm.
+
+```bash
+uv pip install pyglass-portable      # or: pip install pyglass-portable
+```
+
+Prebuilt wheels: Linux x86_64 (AVX2) and macOS arm64 (NEON), Python 3.9+. Intel
+Macs and ARM Linux build from the sdist — `pip install` compiles it portably (it
+needs a C++20 compiler; on macOS, `brew install libomp`).
+
+```python
+import numpy as np, glass
+
+X = np.random.rand(100_000, 128).astype("float32")
+index = glass.Index("HNSW", "L2", "FP32", R=32, L=200)
+graph = index.build(X)
+searcher = glass.Searcher(graph, X, "L2", "FP32")
+searcher.set_ef(64); searcher.optimize()
+ids, dists = searcher.batch_search(X[:1000], 10)
+```
+
+It also works as a `scanpy` neighbors backend via
+[`pipnn.contrib.GlassTransformer`](https://github.com/iandriver/pipnn-scanpy).
+
+## Relationship to upstream
+
+This is an unofficial repackage for platform coverage only — **no algorithm
+changes**. The portability fixes are proposed upstream in
+[zilliztech/pyglass#24](https://github.com/zilliztech/pyglass/pull/24); if they
+land and upstream ships portable wheels, prefer `glassppy`. Version tracks the
+upstream source version.
+
+Credit to the pyglass authors (Zihao Wang / zilliztech). MIT licensed, same as
+upstream.

pyglass_portable-2.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel", "numpy", "pybind11"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyglass-portable"
+version = "2.1.0"
+description = "Portable wheels of pyglass (zilliztech) — a fast HNSW/NSG graph ANN library that builds and runs on macOS (Apple Silicon and Intel) and non-AVX-512 x86 (AMD, older Intel). Imported as `glass`."
+readme = "README_portable.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Zihao Wang" }]
+maintainers = [{ name = "Ian Driver" }]
+keywords = ["nearest-neighbors", "ann", "hnsw", "nsg", "vector-search", "pyglass", "similarity-search"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: C++",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = ["numpy"]
+
+[project.urls]
+Homepage = "https://github.com/iandriver/pyglass"
+Upstream = "https://github.com/zilliztech/pyglass"
+Issues = "https://github.com/iandriver/pyglass/issues"
+
+# Wheels are built with cibuildwheel (see .github/workflows/release.yml).
+[tool.cibuildwheel]
+build = "cp39-* cp310-* cp311-* cp312-* cp313-*"
+skip = "*-musllinux* *_i686 pp*"
+build-frontend = "build"
+test-command = 'python -c "import glass, numpy as np; g=glass.Index(\"HNSW\",\"L2\",\"FP32\",32,200).build(np.random.rand(2000,32).astype(\"float32\")); print(\"glass OK\")"'
+
+# GLASS_MARCH (the portable x86 AVX2 baseline for redistributable wheels — without
+# it the build uses -march=native and bakes in the CI runner's ISA) is set per-job
+# in the release workflow, so it applies to x86 targets only and not arm64/NEON.
+[tool.cibuildwheel.linux]
+# manylinux_2_28 has a new-enough toolchain for C++20.
+manylinux-x86_64-image = "manylinux_2_28"
+
+[tool.cibuildwheel.macos]
+# libomp for OpenMP (build_extension.py picks it up from Homebrew).
+before-all = "brew install libomp"

pyglass_portable-2.1.0/python/ann_dataset/__init__.py

@@ -0,0 +1,3 @@
+from .dataset import dataset_dict
+
+__all__ = ["dataset_dict"]

pyglass_portable-2.1.0/python/ann_dataset/dataset.py

@@ -0,0 +1,93 @@
+import os
+import h5py
+import numpy as np
+from sklearn import preprocessing
+import requests
+from pathlib import Path
+
+HF_ENDPOINT = os.getenv("HF_ENDPOINT", "https://huggingface.co")
+
+
+class Dataset:
+    def __init__(self, name, metric="L2", normalize=False, url="", data_dir="datasets"):
+        self.name = name
+        self.metric = metric
+        self._normalize = normalize
+        self.file_path = Path(data_dir) / f"{self.name}.hdf5"
+        self._file = None
+        self._download_url = url
+
+        self._load_or_download_file()
+
+    def _load_or_download_file(self):
+        if not self.file_path.exists():
+            self.file_path.parent.mkdir(parents=True, exist_ok=True)
+            self._download_file()
+        self._file = h5py.File(self.file_path, "r")
+
+    def _download_file(self):
+        url = (
+            f"{HF_ENDPOINT}/datasets/{self._download_url}/resolve/main/{self.name}.hdf5"
+        )
+        print(f"Downloading {self.name} from {url} to {self.file_path}...")
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+        with open(self.file_path, "wb") as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+        print("Download complete.")
+
+    def _preprocess(self, data):
+        if self._normalize:
+            return preprocessing.normalize(data, norm="l2", axis=1)
+        return data
+
+    def get_database(self):
+        return self._preprocess(np.array(self._file["train"]))
+
+    def get_queries(self):
+        return self._preprocess(np.array(self._file["test"]))
+
+    def get_groundtruth(self, k):
+        return np.array(self._file["neighbors"])[:, :k]
+
+    def evaluate(self, pred, k=None):
+        nq, topk = pred.shape
+        if k is not None:
+            topk = k
+        gt = self.get_groundtruth(topk)
+        cnt = 0
+        for i in range(nq):
+            cnt += np.intersect1d(pred[i], gt[i]).size
+        return cnt / nq / k
+
+
+hhy3_url = "hhy3/ann-datasets"
+vibe_url = "vector-index-bench/vibe"
+
+dataset_configs = {
+    "sift-128-euclidean": {"metric": "L2", "normalize": False, "url": hhy3_url},
+    "fashion-mnist-784-euclidean": {
+        "metric": "L2",
+        "normalize": False,
+        "url": hhy3_url,
+    },
+    "nytimes-256-angular": {"metric": "IP", "normalize": True, "url": hhy3_url},
+    "glove-100-angular": {"metric": "IP", "normalize": False, "url": hhy3_url},
+    "glove-25-angular": {"metric": "IP", "normalize": True, "url": hhy3_url},
+    "lastfm-64-dot": {"metric": "IP", "normalize": True, "url": hhy3_url},
+    "gist-960-euclidean": {"metric": "L2", "normalize": False, "url": hhy3_url},
+    "cohere-768-angular": {"metric": "IP", "normalize": True, "url": hhy3_url},
+    "llama-128-ip": {"metric": "IP", "normalize": False, "url": vibe_url},
+    "yi-128-ip": {"metric": "IP", "normalize": False, "url": vibe_url},
+    "agnews-mxbai-1024-euclidean": {
+        "metric": "L2",
+        "normalize": False,
+        "url": vibe_url,
+    },
+}
+
+dataset_dict = {
+    name: lambda n=name, cfg=config: Dataset(n, **cfg)
+    for name, config in dataset_configs.items()
+}

pyglass_portable-2.1.0/python/bindings.cc

@@ -0,0 +1,295 @@
+#include <pybind11/functional.h>
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include <thread>
+
+#include <omp.h>
+
+#include "glass/algorithms/clustering.hpp"
+#include "glass/builder.hpp"
+#include "glass/hnsw/hnsw.hpp"
+#include "glass/nsg/nsg.hpp"
+#include "glass/nsg/rnndescent.hpp"
+#include "glass/searcher/graph_searcher.hpp"
+
+namespace py = pybind11;
+using namespace pybind11::literals; // needed to bring in _a literal
+
+inline void get_input_array_shapes(const py::buffer_info &buffer, size_t *rows,
+                                   size_t *features) {
+  if (buffer.ndim != 2 && buffer.ndim != 1) {
+    char msg[256];
+    snprintf(msg, sizeof(msg),
+             "Input vector data wrong shape. Number of dimensions %d. Data "
+             "must be a 1D or 2D array.",
+             buffer.ndim);
+  }
+  if (buffer.ndim == 2) {
+    *rows = buffer.shape[0];
+    *features = buffer.shape[1];
+  } else {
+    *rows = 1;
+    *features = buffer.shape[0];
+  }
+}
+
+void set_num_threads(int num_threads) { omp_set_num_threads(num_threads); }
+
+struct Graph {
+  glass::Graph<int> graph;
+
+  Graph() = default;
+
+  explicit Graph(Graph &&rhs) : graph(std::move(rhs.graph)) {}
+
+  Graph(const std::string &filename, const std::string &format = "glass") {
+    graph.load(filename, format);
+  }
+
+  explicit Graph(glass::Graph<int> graph) : graph(std::move(graph)) {}
+
+  void save(const std::string &filename) { graph.save(filename); }
+
+  void load(const std::string &filename, const std::string &format = "glass") {
+    graph.load(filename, format);
+  }
+};
+
+struct Index {
+  std::unique_ptr<glass::Builder> index = nullptr;
+
+  Index(const std::string &index_type, const std::string &metric,
+        const std::string &quant = "FP32", int R = 32, int L = 200) {
+    if (index_type == "HNSW") {
+      index = glass::create_hnsw(metric, quant, R, L);
+    } else if (index_type == "NSG") {
+      index = glass::create_nsg(quant, R, L, false);
+    } else if (index_type == "SSG") {
+      index = glass::create_nsg(quant, R, L, true);
+    } else if (index_type == "RNNDESCENT") {
+      index = glass::create_rnndescent(quant, R);
+    } else {
+      printf("Unknown index type\n");
+    }
+  }
+
+  Graph build(py::object input) {
+    py::array_t<float, py::array::c_style | py::array::forcecast> items(input);
+    auto buffer = items.request();
+    size_t rows, features;
+    get_input_array_shapes(buffer, &rows, &features);
+    float *vector_data = (float *)items.data(0);
+    return Graph(index->Build(vector_data, rows, features));
+  }
+
+  double get_construction_time() const { return index->GetConstructionTime(); }
+};
+
+struct Searcher {
+
+  std::unique_ptr<glass::GraphSearcherBase> searcher;
+
+  Searcher(Graph &graph, py::object input, const std::string &metric,
+           const std::string &quantizer, const std::string &refine_quant = "")
+      : searcher(
+            std::unique_ptr<glass::GraphSearcherBase>(glass::create_searcher(
+                std::move(graph.graph), metric, quantizer, refine_quant))) {
+    py::array_t<float, py::array::c_style | py::array::forcecast> items(input);
+    auto buffer = items.request();
+    size_t rows, features;
+    get_input_array_shapes(buffer, &rows, &features);
+    float *vector_data = (float *)items.data(0);
+    searcher->SetData(vector_data, rows, features);
+  }
+
+  py::object search(py::object query, int k) {
+    py::array_t<float, py::array::c_style | py::array::forcecast> items(query);
+    int *ids;
+    float *dis;
+    {
+      py::gil_scoped_release l;
+      ids = new int[k];
+      dis = new float[k];
+      searcher->Search(items.data(0), k, ids, dis);
+    }
+    py::capsule free_when_done(ids, [](void *f) { delete[] f; });
+    py::capsule free_when_done_dis(dis, [](void *f) { delete[] f; });
+    return py::make_tuple(
+        py::array_t<int32_t>({(size_t)k}, {sizeof(int32_t)}, ids, free_when_done),
+        py::array_t<float>({(size_t)k}, {sizeof(float)}, dis, free_when_done_dis));
+  }
+
+  py::object batch_search(py::object query, int k, int num_threads = 0) {
+    py::array_t<float, py::array::c_style | py::array::forcecast> items(query);
+    auto buffer = items.request();
+    int32_t *ids;
+    float *dis;
+    size_t nq, dim;
+    {
+      py::gil_scoped_release l;
+      get_input_array_shapes(buffer, &nq, &dim);
+      ids = new int[nq * k];
+      dis = new float[nq * k];
+      if (num_threads != 0) {
+        omp_set_num_threads(num_threads);
+      }
+      searcher->SearchBatch(items.data(0), nq, k, ids, dis);
+    }
+    py::capsule free_when_done(ids, [](void *f) { delete[] f; });
+    py::capsule free_when_done_dis(dis, [](void *f) { delete[] f; });
+    return py::make_tuple(
+        py::array_t<int32_t>({(size_t)nq, (size_t)k}, {k * sizeof(int32_t), sizeof(int32_t)}, ids, free_when_done),
+        py::array_t<float>({(size_t)nq, (size_t)k}, {k * sizeof(float), sizeof(float)}, dis, free_when_done_dis));
+  }
+
+  void set_ef(int ef) { searcher->SetEf(ef); }
+
+  void optimize(int num_threads = 0) { searcher->Optimize(num_threads); }
+
+  double get_last_search_avg_dist_cmps() const {
+    return searcher->GetLastSearchAvgDistCmps();
+  }
+};
+
+struct Clustering {
+
+  glass::Clustering internal;
+
+  Clustering(int32_t n_cluster, int32_t epochs = 10,
+             const std::string &init = "random")
+      : internal(n_cluster, epochs, init) {}
+
+  void fit(py::object data) {
+    py::array_t<float, py::array::c_style | py::array::forcecast> items(data);
+    auto buffer = items.request();
+    size_t n, dim;
+    {
+      py::gil_scoped_release l;
+      get_input_array_shapes(buffer, &n, &dim);
+      internal.fit(items.data(0), n, dim);
+    }
+  }
+
+  py::object predict(py::object data) {
+    py::array_t<float, py::array::c_style | py::array::forcecast> items(data);
+    auto buffer = items.request();
+    std::vector<int32_t> ids;
+    size_t n, dim;
+    {
+      py::gil_scoped_release l;
+      get_input_array_shapes(buffer, &n, &dim);
+      ids = internal.predict(items.data(0), n, dim);
+    }
+    return py::array(ids.size(), ids.data());
+  }
+
+  py::object transform(py::object data, bool inplace = false) {
+    py::array_t<float, py::array::c_style | py::array::forcecast> items(data);
+    auto buffer = items.request();
+    size_t n, dim;
+    {
+      py::gil_scoped_release l;
+      get_input_array_shapes(buffer, &n, &dim);
+      if (inplace) {
+        internal.transform((float *)items.data(0), n, dim);
+        return py::none();
+      } else {
+        // TODO
+        return py::none();
+      }
+    }
+  }
+};
+
+#define DECLARE_QUANT(py_name, cxx_name)                                       \
+  struct py_name {                                                             \
+    glass::cxx_name<glass::Metric::L2> quant;                                  \
+    py_name(int32_t dim) : quant(dim) {}                                       \
+                                                                               \
+    void train(py::object data) {                                              \
+      py::array_t<float, py::array::c_style | py::array::forcecast> items(     \
+          data);                                                               \
+      auto buffer = items.request();                                           \
+      size_t n, dim;                                                           \
+      {                                                                        \
+        py::gil_scoped_release l;                                              \
+        get_input_array_shapes(buffer, &n, &dim);                              \
+        quant.train(items.data(0), n);                                         \
+      }                                                                        \
+    }                                                                          \
+  };
+
+DECLARE_QUANT(quant_fp32, FP32Quantizer)
+DECLARE_QUANT(quant_bf16, BF16Quantizer)
+DECLARE_QUANT(quant_fp16, FP16Quantizer)
+DECLARE_QUANT(quant_e5m2, E5M2Quantizer)
+DECLARE_QUANT(quant_sq8, SQ8Quantizer)
+DECLARE_QUANT(quant_sq8u, SQ8QuantizerUniform)
+
+double build_graph(const std::string &index_type, py::object input,
+                   const std::string &graph_file, const std::string &metric,
+                   const std::string &quant = "FP32", int R = 32, int L = 200) {
+  Index index(index_type, metric, quant, R, L);
+  index.build(input).save(graph_file);
+  return index.get_construction_time();
+}
+
+PYBIND11_MODULE(glass, m) {
+  m.def("set_num_threads", &set_num_threads, py::arg("num_threads"));
+
+  py::class_<Graph>(m, "Graph")
+      .def(py::init<>())
+      .def(py::init<const std::string &, const std::string &>(),
+           py::arg("filename"), py::arg("format") = "glass")
+      .def("save", &Graph::save, py::arg("filename"))
+      .def("load", &Graph::load, py::arg("filename"),
+           py::arg("format") = "glass");
+
+  py::class_<Index>(m, "Index")
+      .def(py::init<const std::string &, const std::string &,
+                    const std::string &, int, int>(),
+           py::arg("index_type"), py::arg("metric"), py::arg("quant") = "FP32",
+           py::arg("R") = 32, py::arg("L") = 0)
+      .def("build", &Index::build, py::arg("data"))
+      .def("get_construction_time", &Index::get_construction_time);
+
+  py::class_<Searcher>(m, "Searcher")
+      .def(py::init<Graph &, py::object, const std::string &,
+                    const std::string &, const std::string &>(),
+           py::arg("graph"), py::arg("data"), py::arg("metric"),
+           py::arg("quantizer"), py::arg("refine_quant") = "")
+      .def("set_ef", &Searcher::set_ef, py::arg("ef"))
+      .def("search", &Searcher::search, py::arg("query"), py::arg("k"))
+      .def("batch_search", &Searcher::batch_search, py::arg("query"),
+           py::arg("k"), py::arg("num_threads") = 0)
+      .def("optimize", &Searcher::optimize, py::arg("num_threads") = 0)
+      .def("get_last_search_dist_cmps",
+           &Searcher::get_last_search_avg_dist_cmps);
+
+  py::class_<Clustering>(m, "Clustering")
+      .def(py::init<int32_t, int32_t, const std::string &>(),
+           py::arg("n_cluster"), py::arg("epochs") = 10,
+           py::arg("init") = "random")
+      .def("fit", &Clustering::fit, py::arg("data"))
+      .def("predict", &Clustering::predict, py::arg("data"))
+      .def("transform", &Clustering::transform, py::arg("data"),
+           py::arg("inplace") = false);
+
+#define PYDECLARE_QUANT(py_name)                                               \
+  py::class_<py_name>(m, #py_name)                                             \
+      .def(py::init<int32_t>(), py::arg("dim"))                                \
+      .def("train", &py_name::train, py::arg("data"));
+
+  PYDECLARE_QUANT(quant_fp32)
+  PYDECLARE_QUANT(quant_bf16)
+  PYDECLARE_QUANT(quant_fp16)
+  PYDECLARE_QUANT(quant_e5m2)
+  PYDECLARE_QUANT(quant_sq8)
+  PYDECLARE_QUANT(quant_sq8u)
+
+  m.def("build_graph", &build_graph, py::arg("index_type"), py::arg("input"),
+        py::arg("graph_file"), py::arg("metric"), py::arg("quant"),
+        py::arg("R"), py::arg("L"));
+}

pyglass_portable-2.1.0/python/pyglass_portable.egg-info/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: pyglass-portable
+Version: 2.1.0
+Summary: Portable wheels of pyglass (zilliztech) — a fast HNSW/NSG graph ANN library that builds and runs on macOS (Apple Silicon and Intel) and non-AVX-512 x86 (AMD, older Intel). Imported as `glass`.
+Author: Zihao Wang
+Maintainer: Ian Driver
+License: MIT
+Project-URL: Homepage, https://github.com/iandriver/pyglass
+Project-URL: Upstream, https://github.com/zilliztech/pyglass
+Project-URL: Issues, https://github.com/iandriver/pyglass/issues
+Keywords: nearest-neighbors,ann,hnsw,nsg,vector-search,pyglass,similarity-search
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C++
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: license-file
+
+# pyglass-portable
+
+Portable prebuilt wheels of [**pyglass**](https://github.com/zilliztech/pyglass)
+(zilliztech) — a fast HNSW / NSG graph-based approximate-nearest-neighbor library.
+
+Upstream publishes only an **AVX-512** x86_64 wheel, which crashes (`SIGILL`) on
+CPUs without AVX-512 — Apple Silicon, AMD, older Intel. pyglass's *source* is
+portable (AVX2 / NEON / scalar kernels); this repackage builds it with a portable
+baseline so it installs and runs on those machines too. **The import name stays
+`glass`** — it's a drop-in for upstream, not a fork of the algorithm.
+
+```bash
+uv pip install pyglass-portable      # or: pip install pyglass-portable
+```
+
+Prebuilt wheels: Linux x86_64 (AVX2) and macOS arm64 (NEON), Python 3.9+. Intel
+Macs and ARM Linux build from the sdist — `pip install` compiles it portably (it
+needs a C++20 compiler; on macOS, `brew install libomp`).
+
+```python
+import numpy as np, glass
+
+X = np.random.rand(100_000, 128).astype("float32")
+index = glass.Index("HNSW", "L2", "FP32", R=32, L=200)
+graph = index.build(X)
+searcher = glass.Searcher(graph, X, "L2", "FP32")
+searcher.set_ef(64); searcher.optimize()
+ids, dists = searcher.batch_search(X[:1000], 10)
+```
+
+It also works as a `scanpy` neighbors backend via
+[`pipnn.contrib.GlassTransformer`](https://github.com/iandriver/pipnn-scanpy).
+
+## Relationship to upstream
+
+This is an unofficial repackage for platform coverage only — **no algorithm
+changes**. The portability fixes are proposed upstream in
+[zilliztech/pyglass#24](https://github.com/zilliztech/pyglass/pull/24); if they
+land and upstream ships portable wheels, prefer `glassppy`. Version tracks the
+upstream source version.
+
+Credit to the pyglass authors (Zihao Wang / zilliztech). MIT licensed, same as
+upstream.

pyglass_portable-2.1.0/python/pyglass_portable.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+README_portable.md
+pyproject.toml
+setup.py
+./python/bindings.cc
+python/bindings.cc
+python/ann_dataset/__init__.py
+python/ann_dataset/dataset.py
+python/pyglass_portable.egg-info/PKG-INFO
+python/pyglass_portable.egg-info/SOURCES.txt
+python/pyglass_portable.egg-info/dependency_links.txt
+python/pyglass_portable.egg-info/requires.txt
+python/pyglass_portable.egg-info/top_level.txt

pyglass_portable-2.1.0/python/pyglass_portable.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyglass_portable-2.1.0/python/pyglass_portable.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy

pyglass_portable-2.1.0/python/pyglass_portable.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+ann_dataset
+glass

pyglass_portable-2.1.0/setup.cfg

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

pyglass_portable-2.1.0/setup.py

@@ -0,0 +1,24 @@
+"""Root build shim for the `pyglass-portable` repackage.
+
+Upstream's setup.py lives in `python/` and references `../glass` / `../third_party`
+relative to that directory. Building from the repo root instead makes the project
+self-contained (`glass/` and `third_party/` sit right here), which is what
+cibuildwheel needs. `python/build_extension.py` already resolves its sources and
+include dirs relative to the current working directory, so this shim just calls
+into it from the root.
+"""
+
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "python"))
+
+from build_extension import create_extension, get_build_ext_cmdclass  # noqa: E402
+from setuptools import setup  # noqa: E402
+
+setup(
+    ext_modules=create_extension(os.environ.get("GLASS_VERSION", "2.1.0")),
+    cmdclass=get_build_ext_cmdclass(),
+    package_dir={"": "python"},
+    packages=["ann_dataset"],
+)