#include <pybind11/pybind11.h>

#include <pybind11/stl.h>

#include <pybind11/numpy.h>

#include "../include/feather.h"

namespace py = pybind11;

PYBIND11_MODULE(feather_py, m) {

m.doc() = "Feather: SQLite for Vectors";

py::class_<feather::DB, std::unique_ptr<feather::DB, py::nodelete>>(m, "DB")

.def_static("open", &feather::DB::open, py::arg("path"), py::arg("dim") = 768)

.def("add", [](feather::DB& db, uint64_t id, py::array_t<float> vec) {

auto buf = vec.request();

if (buf.size != db.dim()) throw std::runtime_error("Dimension mismatch");

const float* ptr = static_cast<const float*>(buf.ptr);

std::vector<float> vec_copy(ptr, ptr + buf.size);

db.add(id, vec_copy);

})

.def("search", [](const feather::DB& db, py::array_t<float> q, size_t k = 5) {

auto buf = q.request();

if (buf.size != db.dim()) throw std::runtime_error("Query dimension mismatch");

const float* ptr = static_cast<const float*>(buf.ptr);

std::vector<float> query(ptr, ptr + buf.size);

auto results = db.search(query, k);

py::array_t<uint64_t> ids(results.size());

py::array_t<float> distances(results.size());

auto ids_ptr = ids.mutable_data();

auto dist_ptr = distances.mutable_data();

for (size_t i = 0; i < results.size(); ++i) {

auto [id, dist] = results[i];

ids_ptr[i] = id;

dist_ptr[i] = dist;

}

return py::make_tuple(ids, distances);

}, py::arg("q"), py::arg("k") = 5)

.def("save", &feather::DB::save)

.def("dim", &feather::DB::dim);

}

/target

[package]

name = "feather-cli"

version = "0.1.0"

edition = "2021"

[dependencies]

clap = { version = "4.5", features = ["derive"] }

anyhow = "1.0"

ndarray = "0.15"

ndarray-npy = "0.1" # ← REMOVE features

[build-dependencies]

cc = "1.0"

fn main() {

cc::Build::new()

.cpp(true)

.file("../src/feather_core.cpp")

.include("../include")

.compile("feather");

println!("cargo:rustc-link-search=native=..");

println!("cargo:rustc-link-lib=static=feather");

use clap::{Parser, Subcommand};

use std::path::PathBuf;

use feather_cli::DB;

use ndarray::Array1;

use ndarray_npy::ReadNpyExt; // ← FINAL: Import trait

struct Cli {

#[command(subcommand)]

command: Commands,

enum Commands {

New { path: PathBuf, #[arg(long)] dim: usize },

Add { db: PathBuf, id: u64, #[arg(short)] npy: PathBuf },

Search { db: PathBuf, #[arg(short)] npy: PathBuf, #[arg(long, default_value_t = 5)] k: usize },

fn main() -> anyhow::Result<()> {

let cli = Cli::parse();

match cli.command {

Commands::New { path, dim } => {

DB::open(&path, dim).ok_or_else(|| anyhow::anyhow!("Failed to create DB"))?;

println!("Created: {:?}", path);

}

Commands::Add { db, id, npy } => {

let db = DB::open(&db, 0).ok_or_else(|| anyhow::anyhow!("Open failed"))?;

let arr: Array1<f32> = npy.read_npy()?; // ← FINAL: PathBuf has .read_npy()

db.add(id, arr.as_slice().unwrap());

db.save();

println!("Added ID {}", id);

}

Commands::Search { db, npy, k } => {

let db = DB::open(&db, 0).ok_or_else(|| anyhow::anyhow!("Open failed"))?;

let arr: Array1<f32> = npy.read_npy()?; // ← FINAL: PathBuf has .read_npy()

let (ids, dists) = db.search(arr.as_slice().unwrap(), k);

for (id, dist) in ids.iter().zip(dists.iter()) {

println!("ID: {} dist: {:.4}", id, dist);

}

}

}

Ok(())

fn main() {

cc::Build::new()

.cpp(true)

.file("../src/feather_core.cpp")

.include("../include")

.flag("-std=c++17")

.compile("feather");

println!("cargo:rustc-link-search=native=..");

println!("cargo:rustc-link-lib=static=feather");

use std::ffi::{c_void, c_char};

use std::path::Path;

pub struct DB(*mut c_void); // ← `pub`

extern "C" {

fn feather_open(path: *const c_char, dim: usize) -> *mut c_void;

fn feather_add(db: *mut c_void, id: u64, vec: *const f32, len: usize);

fn feather_search(db: *mut c_void, query: *const f32, len: usize, k: usize,

out_ids: *mut u64, out_dists: *mut f32);

fn feather_save(db: *mut c_void);

fn feather_close(db: *mut c_void);

impl DB {

pub fn open(path: &Path, dim: usize) -> Option<Self> {

let c_path = std::ffi::CString::new(path.to_str()?).ok()?;

let ptr = unsafe { feather_open(c_path.as_ptr(), dim) };

if ptr.is_null() { None } else { Some(DB(ptr)) }

}

pub fn add(&self, id: u64, vec: &[f32]) {

unsafe { feather_add(self.0, id, vec.as_ptr(), vec.len()) }

}

pub fn search(&self, query: &[f32], k: usize) -> (Vec<u64>, Vec<f32>) {

let mut ids = vec![0u64; k];

let mut dists = vec![0f32; k];

unsafe {

feather_search(self.0, query.as_ptr(), query.len(), k, ids.as_mut_ptr(), dists.as_mut_ptr())

};

(ids, dists)

}

pub fn save(&self) { unsafe { feather_save(self.0) } }

impl Drop for DB {

fn drop(&mut self) { unsafe { feather_close(self.0) } }

use clap::{Parser, Subcommand};

use std::path::PathBuf;

use std::fs::File;

use feather_cli::DB;

use ndarray::Array1;

use ndarray_npy::read_npy; // ← FREE FUNCTION

struct Cli {

#[command(subcommand)]

command: Commands,

enum Commands {

New { path: PathBuf, #[arg(long)] dim: usize },

Add { db: PathBuf, id: u64, #[arg(short)] npy: PathBuf },

Search { db: PathBuf, #[arg(short)] npy: PathBuf, #[arg(long, default_value_t = 5)] k: usize },

fn main() -> anyhow::Result<()> {

let cli = Cli::parse();

match cli.command {

Commands::New { path, dim } => {

DB::open(&path, dim).ok_or_else(|| anyhow::anyhow!("Failed to create DB"))?;

println!("Created: {:?}", path);

}

Commands::Add { db, id, npy } => {

let db = DB::open(&db, 0).ok_or_else(|| anyhow::anyhow!("Open failed"))?;

let file = File::open(&npy)?;

let arr: Array1<f32> = read_npy(&file)?; // ← FIXED: free function

db.add(id, arr.as_slice().unwrap());

db.save();

println!("Added ID {}", id);

}

Commands::Search { db, npy, k } => {

let db = DB::open(&db, 0).ok_or_else(|| anyhow::anyhow!("Open failed"))?;

let file = File::open(&npy)?;

let arr: Array1<f32> = read_npy(&file)?; // ← FIXED: free function

let (ids, dists) = db.search(arr.as_slice().unwrap(), k);

for (id, dist) in ids.iter().zip(dists.iter()) {

println!("ID: {} dist: {:.4}", id, dist);

}

}

}

Ok(())