fuzzybunny 0.1.2__tar.gz → 0.2.1__tar.gz

fuzzybunny-0.2.1/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: fuzzybunny
+Version: 0.2.1
+Summary: A fuzzy search tool for python written in C++
+Home-page: https://github.com/cachevector/fuzzybunny
+Project-URL: Bug Tracker, https://github.com/cachevector/fuzzybunny/issues
+Project-URL: Source Code, https://github.com/cachevector/fuzzybunny
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/cachevector/fuzzybunny/master/docs/assets/fuzzybunny.png" alt="FuzzyBunny Logo" width="150" />
+</p>
+
+<h1 align="center">FuzzyBunny</h1>
+
+<p align="center">
+  <b> A high-performance, lightweight Python library for fuzzy string matching and ranking, implemented in C++ with Pybind11. </b>
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/License-MIT-green" />
+  <img src="https://img.shields.io/badge/Language-C%2B%2B-00599C" />
+  <img src="https://img.shields.io/badge/Bindings-Pybind11-blue" />
+</p>
+
+## Features
+
+- **Blazing Fast**: C++ core for 2-5x speed improvement over pure Python alternatives.
+- **Multiple Scorers**: Support for Levenshtein, Jaccard, and Token Sort ratios.
+- **Partial Matching**: Find the best substring matches.
+- **Hybrid Scoring**: Combine multiple scorers with custom weights.
+- **Pandas & NumPy Integration**: Native support for Series and Arrays.
+- **Batch Processing**: Parallelized matching for large datasets using OpenMP.
+- **Unicode Support**: Handles international characters and normalization.
+- **Benchmarking Tools**: Built-in utilities to measure performance.
+
+## Installation
+
+```bash
+pip install fuzzybunny
+```
+
+## Quick Start
+
+```python
+import fuzzybunny
+
+# Basic matching
+score = fuzzybunny.levenshtein("kitten", "sitting")
+print(f"Similarity: {score:.2f}")
+
+# Ranking candidates
+candidates = ["apple", "apricot", "banana", "cherry"]
+results = fuzzybunny.rank("app", candidates, top_n=2)
+# [('apple', 0.6), ('apricot', 0.42)]
+```
+
+## Advanced Usage
+
+### Hybrid Scorer
+Combine different algorithms to get better results:
+
+```python
+results = fuzzybunny.rank(
+    "apple banana", 
+    ["banana apple"], 
+    scorer="hybrid", 
+    weights={"levenshtein": 0.3, "token_sort": 0.7}
+)
+```
+
+### Pandas Integration
+Use the specialized accessor for clean code:
+
+```python
+import pandas as pd
+import fuzzybunny
+
+df = pd.DataFrame({"names": ["apple pie", "banana bread", "cherry tart"]})
+results = df["names"].fuzzy.match("apple", mode="partial")
+```
+
+### Benchmarking
+Compare performance on your specific data:
+
+```python
+perf = fuzzybunny.benchmark("query", candidates)
+print(f"Levenshtein mean time: {perf['levenshtein']['mean']:.6f}s")
+```
+
+## License
+MIT

fuzzybunny-0.2.1/README.md

@@ -0,0 +1,83 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/cachevector/fuzzybunny/master/docs/assets/fuzzybunny.png" alt="FuzzyBunny Logo" width="150" />
+</p>
+
+<h1 align="center">FuzzyBunny</h1>
+
+<p align="center">
+  <b> A high-performance, lightweight Python library for fuzzy string matching and ranking, implemented in C++ with Pybind11. </b>
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/License-MIT-green" />
+  <img src="https://img.shields.io/badge/Language-C%2B%2B-00599C" />
+  <img src="https://img.shields.io/badge/Bindings-Pybind11-blue" />
+</p>
+
+## Features
+
+- **Blazing Fast**: C++ core for 2-5x speed improvement over pure Python alternatives.
+- **Multiple Scorers**: Support for Levenshtein, Jaccard, and Token Sort ratios.
+- **Partial Matching**: Find the best substring matches.
+- **Hybrid Scoring**: Combine multiple scorers with custom weights.
+- **Pandas & NumPy Integration**: Native support for Series and Arrays.
+- **Batch Processing**: Parallelized matching for large datasets using OpenMP.
+- **Unicode Support**: Handles international characters and normalization.
+- **Benchmarking Tools**: Built-in utilities to measure performance.
+
+## Installation
+
+```bash
+pip install fuzzybunny
+```
+
+## Quick Start
+
+```python
+import fuzzybunny
+
+# Basic matching
+score = fuzzybunny.levenshtein("kitten", "sitting")
+print(f"Similarity: {score:.2f}")
+
+# Ranking candidates
+candidates = ["apple", "apricot", "banana", "cherry"]
+results = fuzzybunny.rank("app", candidates, top_n=2)
+# [('apple', 0.6), ('apricot', 0.42)]
+```
+
+## Advanced Usage
+
+### Hybrid Scorer
+Combine different algorithms to get better results:
+
+```python
+results = fuzzybunny.rank(
+    "apple banana", 
+    ["banana apple"], 
+    scorer="hybrid", 
+    weights={"levenshtein": 0.3, "token_sort": 0.7}
+)
+```
+
+### Pandas Integration
+Use the specialized accessor for clean code:
+
+```python
+import pandas as pd
+import fuzzybunny
+
+df = pd.DataFrame({"names": ["apple pie", "banana bread", "cherry tart"]})
+results = df["names"].fuzzy.match("apple", mode="partial")
+```
+
+### Benchmarking
+Compare performance on your specific data:
+
+```python
+perf = fuzzybunny.benchmark("query", candidates)
+print(f"Levenshtein mean time: {perf['levenshtein']['mean']:.6f}s")
+```
+
+## License
+MIT

{fuzzybunny-0.1.2 → fuzzybunny-0.2.1}/setup.py

@@ -28,7 +28,7 @@ class PybindBuildExt(build_ext):
 
 ext_modules = [
     Extension(
-        "fuzzybunny",
+        "fuzzybunny._fuzzybunny",
         ["src/bindings.cpp", "src/scorers.cpp"],
         include_dirs=[
             pybind11.get_include(),
@@ -40,10 +40,17 @@ ext_modules = [
 
 setup(
     name="fuzzybunny",
-    version="0.1.2",
+    version="0.2.1",
     description="A fuzzy search tool for python written in C++",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",
+    url="https://github.com/cachevector/fuzzybunny",
+    project_urls={
+        "Bug Tracker": "https://github.com/cachevector/fuzzybunny/issues",
+        "Source Code": "https://github.com/cachevector/fuzzybunny",
+    },
+    packages=["fuzzybunny"],
+    package_dir={"": "src"},
     ext_modules=ext_modules,
     cmdclass={"build_ext": PybindBuildExt},
     zip_safe=False,

{fuzzybunny-0.1.2 → fuzzybunny-0.2.1}/src/bindings.cpp

@@ -5,7 +5,7 @@
 namespace py = pybind11;
 using namespace fuzzybunny;
 
-PYBIND11_MODULE(fuzzybunny, m) {
+PYBIND11_MODULE(_fuzzybunny, m) {
     m.doc() = R"pbdoc(
         FuzzyBunny: A fast fuzzy string matching library
         ------------------------------------------------
@@ -42,6 +42,7 @@ PYBIND11_MODULE(fuzzybunny, m) {
           py::arg("process") = true,
           py::arg("threshold") = 0.0,
           py::arg("top_n") = -1,
+          py::arg("weights") = std::map<std::string, double>{},
           "Rank candidates against a query string. Returns list of (string, score) tuples.");
 
     m.def("batch_match", &batch_match,
@@ -52,6 +53,7 @@ PYBIND11_MODULE(fuzzybunny, m) {
           py::arg("process") = true,
           py::arg("threshold") = 0.0,
           py::arg("top_n") = -1,
+          py::arg("weights") = std::map<std::string, double>{},
           "Batch match multiple queries against candidates.");
 
 #ifdef VERSION_INFO

fuzzybunny-0.2.1/src/fuzzybunny/__init__.py

@@ -0,0 +1,75 @@
+from . import _fuzzybunny
+from ._fuzzybunny import (
+    levenshtein,
+    jaccard,
+    token_sort,
+    partial_ratio,
+)
+
+from .benchmark import benchmark, benchmark_batch
+
+def rank(query, candidates, scorer="levenshtein", mode="full", process=True, threshold=0.0, top_n=-1, weights=None):
+    """
+    Enhanced rank function with support for Pandas Series and NumPy arrays.
+    """
+    if weights is None:
+        weights = {}
+
+    # Check for pandas/numpy
+    if _is_pandas_series(candidates):
+        candidates = candidates.astype(str).tolist()
+    elif _is_numpy_array(candidates):
+        candidates = candidates.astype(str).tolist()
+
+    return _fuzzybunny.rank(query, candidates, scorer, mode, process, threshold, top_n, weights)
+
+def batch_match(queries, candidates, scorer="levenshtein", mode="full", process=True, threshold=0.0, top_n=-1, weights=None):
+    """
+    Enhanced batch_match function with support for Pandas/NumPy candidates.
+    """
+    if weights is None:
+        weights = {}
+
+    if _is_pandas_series(candidates):
+        candidates = candidates.astype(str).tolist()
+    elif _is_numpy_array(candidates):
+        candidates = candidates.astype(str).tolist()
+
+    # queries can also be pandas/numpy
+    if _is_pandas_series(queries) or _is_numpy_array(queries):
+        import numpy as np
+        queries = np.array(queries).astype(str).tolist()
+
+    return _fuzzybunny.batch_match(queries, candidates, scorer, mode, process, threshold, top_n, weights)
+
+def _is_pandas_series(obj):
+    try:
+        import pandas as pd
+        return isinstance(obj, pd.Series)
+    except ImportError:
+        return False
+
+def _is_numpy_array(obj):
+    try:
+        import numpy as np
+        return isinstance(obj, np.ndarray)
+    except ImportError:
+        return False
+
+def _register_pandas_accessor():
+    try:
+        import pandas as pd
+        
+        @pd.api.extensions.register_series_accessor("fuzzy")
+        class FuzzyAccessor:
+            def __init__(self, pandas_obj):
+                self._obj = pandas_obj
+
+            def match(self, query, scorer="levenshtein", mode="full", process=True, threshold=0.0, top_n=-1, weights=None):
+                return rank(query, self._obj, scorer, mode, process, threshold, top_n, weights)
+    except (ImportError, AttributeError):
+        pass
+
+_register_pandas_accessor()
+
+__version__ = getattr(_fuzzybunny, "__version__", "dev")

fuzzybunny-0.2.1/src/fuzzybunny/benchmark.py

@@ -0,0 +1,49 @@
+import time
+import statistics
+
+def benchmark(query, candidates, scorers=None, n_runs=5):
+    """
+    Benchmark different scorers on a given query and set of candidates.
+    Returns a dictionary with timing results.
+    """
+    from . import rank
+    if scorers is None:
+        scorers = ["levenshtein", "jaccard", "token_sort"]
+    
+    results = {}
+    
+    for scorer in scorers:
+        times = []
+        for _ in range(n_runs):
+            start = time.perf_counter()
+            rank(query, candidates, scorer=scorer)
+            end = time.perf_counter()
+            times.append(end - start)
+        
+        results[scorer] = {
+            "mean": statistics.mean(times),
+            "stddev": statistics.stdev(times) if len(times) > 1 else 0,
+            "min": min(times),
+            "max": max(times)
+        }
+        
+    return results
+
+def benchmark_batch(queries, candidates, scorer="levenshtein", n_runs=3):
+    """
+    Benchmark batch_match performance.
+    """
+    from . import batch_match
+    times = []
+    for _ in range(n_runs):
+        start = time.perf_counter()
+        batch_match(queries, candidates, scorer=scorer)
+        end = time.perf_counter()
+        times.append(end - start)
+    
+    return {
+        "mean": statistics.mean(times),
+        "total_queries": len(queries),
+        "total_candidates": len(candidates),
+        "queries_per_second": len(queries) / statistics.mean(times)
+    }

fuzzybunny-0.2.1/src/fuzzybunny.egg-info/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: fuzzybunny
+Version: 0.2.1
+Summary: A fuzzy search tool for python written in C++
+Home-page: https://github.com/cachevector/fuzzybunny
+Project-URL: Bug Tracker, https://github.com/cachevector/fuzzybunny/issues
+Project-URL: Source Code, https://github.com/cachevector/fuzzybunny
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/cachevector/fuzzybunny/master/docs/assets/fuzzybunny.png" alt="FuzzyBunny Logo" width="150" />
+</p>
+
+<h1 align="center">FuzzyBunny</h1>
+
+<p align="center">
+  <b> A high-performance, lightweight Python library for fuzzy string matching and ranking, implemented in C++ with Pybind11. </b>
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/License-MIT-green" />
+  <img src="https://img.shields.io/badge/Language-C%2B%2B-00599C" />
+  <img src="https://img.shields.io/badge/Bindings-Pybind11-blue" />
+</p>
+
+## Features
+
+- **Blazing Fast**: C++ core for 2-5x speed improvement over pure Python alternatives.
+- **Multiple Scorers**: Support for Levenshtein, Jaccard, and Token Sort ratios.
+- **Partial Matching**: Find the best substring matches.
+- **Hybrid Scoring**: Combine multiple scorers with custom weights.
+- **Pandas & NumPy Integration**: Native support for Series and Arrays.
+- **Batch Processing**: Parallelized matching for large datasets using OpenMP.
+- **Unicode Support**: Handles international characters and normalization.
+- **Benchmarking Tools**: Built-in utilities to measure performance.
+
+## Installation
+
+```bash
+pip install fuzzybunny
+```
+
+## Quick Start
+
+```python
+import fuzzybunny
+
+# Basic matching
+score = fuzzybunny.levenshtein("kitten", "sitting")
+print(f"Similarity: {score:.2f}")
+
+# Ranking candidates
+candidates = ["apple", "apricot", "banana", "cherry"]
+results = fuzzybunny.rank("app", candidates, top_n=2)
+# [('apple', 0.6), ('apricot', 0.42)]
+```
+
+## Advanced Usage
+
+### Hybrid Scorer
+Combine different algorithms to get better results:
+
+```python
+results = fuzzybunny.rank(
+    "apple banana", 
+    ["banana apple"], 
+    scorer="hybrid", 
+    weights={"levenshtein": 0.3, "token_sort": 0.7}
+)
+```
+
+### Pandas Integration
+Use the specialized accessor for clean code:
+
+```python
+import pandas as pd
+import fuzzybunny
+
+df = pd.DataFrame({"names": ["apple pie", "banana bread", "cherry tart"]})
+results = df["names"].fuzzy.match("apple", mode="partial")
+```
+
+### Benchmarking
+Compare performance on your specific data:
+
+```python
+perf = fuzzybunny.benchmark("query", candidates)
+print(f"Levenshtein mean time: {perf['levenshtein']['mean']:.6f}s")
+```
+
+## License
+MIT

fuzzybunny-0.2.1/src/fuzzybunny.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+src/bindings.cpp
+src/scorers.cpp
+src/fuzzybunny/__init__.py
+src/fuzzybunny/benchmark.py
+src/fuzzybunny.egg-info/PKG-INFO
+src/fuzzybunny.egg-info/SOURCES.txt
+src/fuzzybunny.egg-info/dependency_links.txt
+src/fuzzybunny.egg-info/not-zip-safe
+src/fuzzybunny.egg-info/top_level.txt
+tests/test_basic.py
+tests/test_benchmark.py
+tests/test_hybrid.py
+tests/test_pandas.py

{fuzzybunny-0.1.2 → fuzzybunny-0.2.1}/src/scorers.cpp

@@ -17,13 +17,19 @@ std::u32string normalize(const std::u32string& s) {
     std::u32string result;
     result.reserve(s.size());
     for (char32_t c : s) {
-        // Lowercase and remove punctuation (basic ASCII range for now)
+        // Lowercase and remove punctuation
+        // Supporting basic Latin-1 range for better international support
         if (c < 128) {
             if (std::iswalnum(static_cast<wint_t>(c)) || std::iswspace(static_cast<wint_t>(c))) {
                 result.push_back(static_cast<char32_t>(std::towlower(static_cast<wint_t>(c))));
             }
+        } else if (c < 256) {
+            // Latin-1 Supplement
+            if (std::iswalpha(static_cast<wint_t>(c)) || std::iswspace(static_cast<wint_t>(c))) {
+                result.push_back(static_cast<char32_t>(std::towlower(static_cast<wint_t>(c))));
+            }
         } else {
-            // For non-ASCII, just pass through (proper unicode normalization is complex)
+            // For other non-ASCII, just pass through
             result.push_back(c);
         }
     }
@@ -205,7 +211,8 @@ std::vector<MatchResult> rank(
     const std::string& mode,
     bool process,
     double threshold,
-    int top_n
+    int top_n,
+    const std::map<std::string, double>& weights
 ) {
     if (query.empty() || candidates.empty()) return {};
 
@@ -233,8 +240,33 @@ std::vector<MatchResult> rank(
             score = jaccard_similarity(uQuery, uCand);
         } else if (scorer == "token_sort") {
             score = token_sort_ratio(uQuery, uCand);
+        } else if (scorer == "hybrid") {
+            double weighted_sum = 0.0;
+            double total_weight = 0.0;
+
+            for (const auto& [name, weight] : weights) {
+                double sub_score = 0.0;
+                if (name == "levenshtein") {
+                     if (mode == "partial") sub_score = partial_ratio(uQuery, uCand);
+                     else sub_score = levenshtein_ratio(uQuery, uCand);
+                } else if (name == "jaccard") {
+                    sub_score = jaccard_similarity(uQuery, uCand);
+                } else if (name == "token_sort") {
+                    sub_score = token_sort_ratio(uQuery, uCand);
+                }
+                // Ignore unknown scorers in weights for now, or could throw.
+                
+                weighted_sum += sub_score * weight;
+                total_weight += weight;
+            }
+
+            if (total_weight > 0.0) {
+                score = weighted_sum / total_weight;
+            } else {
+                score = 0.0;
+            }
         } else {
-             score = 0.0;
+             throw std::invalid_argument("Unknown scorer: " + scorer);
         }
 
         if (score >= threshold) {
@@ -260,13 +292,14 @@ std::vector<std::vector<MatchResult>> batch_match(
     const std::string& mode,
     bool process,
     double threshold,
-    int top_n
+    int top_n,
+    const std::map<std::string, double>& weights
 ) {
     std::vector<std::vector<MatchResult>> batch_results(queries.size());
 
     #pragma omp parallel for if(queries.size() > 10)
     for (int i = 0; i < static_cast<int>(queries.size()); ++i) {
-        batch_results[i] = rank(queries[i], candidates, scorer, mode, process, threshold, top_n);
+        batch_results[i] = rank(queries[i], candidates, scorer, mode, process, threshold, top_n, weights);
     }
     return batch_results;
 }

{fuzzybunny-0.1.2 → fuzzybunny-0.2.1}/tests/test_basic.py

@@ -41,6 +41,10 @@ def test_unicode():
     assert fuzzybunny.levenshtein(s1, s2) < 1.0
     assert fuzzybunny.levenshtein(s1, s1) == 1.0
     assert fuzzybunny.levenshtein("😊", "😊") == 1.0
+    
+    # Test normalization of international characters
+    res = fuzzybunny.rank("CAFÉ", ["café"], process=True)
+    assert res[0][1] == 1.0
 
 def test_rank():
     candidates = ["apple", "apricot", "banana", "cherry"]
@@ -61,5 +65,5 @@ def test_batch_match():
     assert results[1][0][0] == "banana bread"
 
 def test_invalid_scorer_rank():
-    results = fuzzybunny.rank("a", ["a"], scorer="unknown")
-    assert results[0][1] == 0.0
+    with pytest.raises(ValueError, match="Unknown scorer"):
+        fuzzybunny.rank("a", ["a"], scorer="unknown")

fuzzybunny-0.2.1/tests/test_benchmark.py

@@ -0,0 +1,18 @@
+import fuzzybunny
+
+def test_benchmark():
+    query = "apple"
+    candidates = ["apple", "banana", "cherry"]
+    results = fuzzybunny.benchmark(query, candidates, n_runs=2)
+    
+    assert "levenshtein" in results
+    assert "mean" in results["levenshtein"]
+    assert results["levenshtein"]["mean"] > 0
+
+def test_benchmark_batch():
+    queries = ["apple", "banana"]
+    candidates = ["apple pie", "banana bread"]
+    results = fuzzybunny.benchmark_batch(queries, candidates, n_runs=2)
+    
+    assert "queries_per_second" in results
+    assert results["total_queries"] == 2

fuzzybunny-0.2.1/tests/test_hybrid.py

@@ -0,0 +1,48 @@
+import pytest
+import fuzzybunny
+
+def test_hybrid_scorer():
+    # Setup: "apple" is the query
+    # "apple pie" matches partially well
+    # "banana" matches poorly
+    
+    candidates = ["apple pie", "banana"]
+    
+    # Weight only levenshtein
+    res_lev = fuzzybunny.rank("apple", candidates, scorer="hybrid", 
+                              weights={"levenshtein": 1.0})
+    # Should be equivalent to standard levenshtein
+    expected_lev = fuzzybunny.rank("apple", candidates, scorer="levenshtein")
+    assert abs(res_lev[0][1] - expected_lev[0][1]) < 0.001
+
+    # Hybrid: 50% Levenshtein, 50% Token Sort
+    # "apple pie" vs "apple"
+    # Levenshtein: ratio is low (length diff)
+    # Token Sort: "apple" vs "apple", "pie" -> ratio slightly better or same?
+    
+    # Let's test with a clearer case
+    # s1="apple banana", s2="banana apple"
+    # Levenshtein low (~0.5), Token Sort high (1.0)
+    
+    q = "apple banana"
+    c = ["banana apple"]
+    
+    score_lev = fuzzybunny.levenshtein(q, c[0])
+    score_ts = fuzzybunny.token_sort(q, c[0])
+    
+    res_hybrid = fuzzybunny.rank(q, c, scorer="hybrid", 
+                                 weights={"levenshtein": 0.5, "token_sort": 0.5})
+    
+    expected_score = (score_lev * 0.5 + score_ts * 0.5)
+    assert abs(res_hybrid[0][1] - expected_score) < 0.001
+
+def test_unknown_scorer_error():
+    with pytest.raises(ValueError, match="Unknown scorer"):
+        fuzzybunny.rank("a", ["b"], scorer="non_existent_scorer")
+
+def test_hybrid_empty_weights():
+    # If weights are empty or total weight is 0, score should be 0
+    res = fuzzybunny.rank("apple", ["apple"], scorer="hybrid", weights={})
+    # threshold 0.0 (default), score 0.0. 0.0 >= 0.0 is True.
+    assert len(res) == 1
+    assert res[0][1] == 0.0

fuzzybunny-0.2.1/tests/test_pandas.py

@@ -0,0 +1,29 @@
+import pytest
+import fuzzybunny
+try:
+    import pandas as pd
+    import numpy as np
+    HAS_PANDAS = True
+except ImportError:
+    HAS_PANDAS = False
+
+@pytest.mark.skipif(not HAS_PANDAS, reason="pandas not installed")
+def test_pandas_series_support():
+    s = pd.Series(["apple", "banana", "cherry"])
+    results = fuzzybunny.rank("app", s)
+    assert results[0][0] == "apple"
+    assert results[0][1] > 0.5
+
+@pytest.mark.skipif(not HAS_PANDAS, reason="pandas not installed")
+def test_pandas_accessor():
+    s = pd.Series(["apple pie", "banana bread", "cherry tart"])
+    # Test the accessor
+    results = s.fuzzy.match("apple", mode="partial")
+    assert results[0][0] == "apple pie"
+    assert results[0][1] == 1.0
+
+@pytest.mark.skipif(not HAS_PANDAS, reason="numpy not installed")
+def test_numpy_support():
+    arr = np.array(["apple", "banana", "cherry"])
+    results = fuzzybunny.rank("ban", arr)
+    assert results[0][0] == "banana"

fuzzybunny-0.1.2/PKG-INFO

@@ -1,114 +0,0 @@
-Metadata-Version: 2.4
-Name: fuzzybunny
-Version: 0.1.2
-Summary: A fuzzy search tool for python written in C++
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: license-file
-Dynamic: requires-python
-Dynamic: summary
-
-<p align="center">
-  <img src="./docs/assets/fuzzybunny.png" alt="FuzzyBunny Logo" width="150" />
-</p>
-
-<h1 align="center">FuzzyBunny</h1>
-
-<p align="center">
-  <b> A fuzzy search tool written in C++ with Python bindings </b>
-</p>
-
-<p align="center">
-  <img src="https://img.shields.io/badge/License-MIT-green" />
-  <img src="https://img.shields.io/badge/Language-C%2B%2B-00599C" />
-  <img src="https://img.shields.io/badge/Bindings-Pybind11-blue" />
-</p>
-
-## Overview
-
-FuzzyBunny is a lightweight, high-performance Python library for fuzzy string matching and ranking. It is implemented in C++ for speed and exposes a Pythonic API via Pybind11. It supports various scoring algorithms including Levenshtein, Jaccard, and Token Sort, along with partial matching capabilities.
-
-## Features
-
-- **Fast C++ Core**: Optimized string matching algorithms.
-- **Multiple Scorers**:
-  - `levenshtein`: Standard edit distance ratio.
-  - `jaccard`: Set-based similarity.
-  - `token_sort`: Sorts tokens before comparing (good for "Apple Banana" vs "Banana Apple").
-- **Ranking**: Efficiently rank a list of candidates against a query.
-- **Partial Matching**: Support for substring matching via `mode='partial'`.
-- **Unicode Support**: Correctly handles UTF-8 input.
-
-## Installation
-
-### Prerequisites
-- Python 3.8+
-- C++17 compatible compiler (GCC, Clang, MSVC)
-
-### Using uv (Recommended)
-
-```bash
-uv pip install .
-```
-
-### Using pip
-
-```bash
-pip install .
-```
-
-## Usage
-
-```python
-import fuzzybunny
-
-# Basic Levenshtein Ratio
-score = fuzzybunny.levenshtein("kitten", "sitting")
-print(f"Score: {score}")  # ~0.57
-
-# Partial Matching
-# "apple" is a perfect substring of "apple pie"
-score = fuzzybunny.partial_ratio("apple", "apple pie")
-print(f"Partial Score: {score}")  # 1.0
-
-# Ranking Candidates
-candidates = ["apple pie", "banana bread", "cherry tart", "apple crisp"]
-results = fuzzybunny.rank(
-    query="apple", 
-    candidates=candidates, 
-    scorer="levenshtein", 
-    mode="partial", 
-    top_n=2
-)
-
-for candidate, score in results:
-    print(f"{candidate}: {score}")
-# Output:
-# apple pie: 1.0
-# apple crisp: 1.0
-```
-
-## Development
-
-1. **Setup Environment**:
-   ```bash
-   uv venv
-   source .venv/bin/activate
-   ```
-
-2. **Install in Editable Mode**:
-   ```bash
-   uv pip install -e .
-   ```
-
-3. **Run Tests**:
-   ```bash
-   pytest
-   ```
-
-## License
-
-This project is licensed under the [MIT License](LICENSE).

fuzzybunny-0.1.2/README.md

@@ -1,101 +0,0 @@
-<p align="center">
-  <img src="./docs/assets/fuzzybunny.png" alt="FuzzyBunny Logo" width="150" />
-</p>
-
-<h1 align="center">FuzzyBunny</h1>
-
-<p align="center">
-  <b> A fuzzy search tool written in C++ with Python bindings </b>
-</p>
-
-<p align="center">
-  <img src="https://img.shields.io/badge/License-MIT-green" />
-  <img src="https://img.shields.io/badge/Language-C%2B%2B-00599C" />
-  <img src="https://img.shields.io/badge/Bindings-Pybind11-blue" />
-</p>
-
-## Overview
-
-FuzzyBunny is a lightweight, high-performance Python library for fuzzy string matching and ranking. It is implemented in C++ for speed and exposes a Pythonic API via Pybind11. It supports various scoring algorithms including Levenshtein, Jaccard, and Token Sort, along with partial matching capabilities.
-
-## Features
-
-- **Fast C++ Core**: Optimized string matching algorithms.
-- **Multiple Scorers**:
-  - `levenshtein`: Standard edit distance ratio.
-  - `jaccard`: Set-based similarity.
-  - `token_sort`: Sorts tokens before comparing (good for "Apple Banana" vs "Banana Apple").
-- **Ranking**: Efficiently rank a list of candidates against a query.
-- **Partial Matching**: Support for substring matching via `mode='partial'`.
-- **Unicode Support**: Correctly handles UTF-8 input.
-
-## Installation
-
-### Prerequisites
-- Python 3.8+
-- C++17 compatible compiler (GCC, Clang, MSVC)
-
-### Using uv (Recommended)
-
-```bash
-uv pip install .
-```
-
-### Using pip
-
-```bash
-pip install .
-```
-
-## Usage
-
-```python
-import fuzzybunny
-
-# Basic Levenshtein Ratio
-score = fuzzybunny.levenshtein("kitten", "sitting")
-print(f"Score: {score}")  # ~0.57
-
-# Partial Matching
-# "apple" is a perfect substring of "apple pie"
-score = fuzzybunny.partial_ratio("apple", "apple pie")
-print(f"Partial Score: {score}")  # 1.0
-
-# Ranking Candidates
-candidates = ["apple pie", "banana bread", "cherry tart", "apple crisp"]
-results = fuzzybunny.rank(
-    query="apple", 
-    candidates=candidates, 
-    scorer="levenshtein", 
-    mode="partial", 
-    top_n=2
-)
-
-for candidate, score in results:
-    print(f"{candidate}: {score}")
-# Output:
-# apple pie: 1.0
-# apple crisp: 1.0
-```
-
-## Development
-
-1. **Setup Environment**:
-   ```bash
-   uv venv
-   source .venv/bin/activate
-   ```
-
-2. **Install in Editable Mode**:
-   ```bash
-   uv pip install -e .
-   ```
-
-3. **Run Tests**:
-   ```bash
-   pytest
-   ```
-
-## License
-
-This project is licensed under the [MIT License](LICENSE).

fuzzybunny-0.1.2/fuzzybunny.egg-info/PKG-INFO

@@ -1,114 +0,0 @@
-Metadata-Version: 2.4
-Name: fuzzybunny
-Version: 0.1.2
-Summary: A fuzzy search tool for python written in C++
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: license-file
-Dynamic: requires-python
-Dynamic: summary
-
-<p align="center">
-  <img src="./docs/assets/fuzzybunny.png" alt="FuzzyBunny Logo" width="150" />
-</p>
-
-<h1 align="center">FuzzyBunny</h1>
-
-<p align="center">
-  <b> A fuzzy search tool written in C++ with Python bindings </b>
-</p>
-
-<p align="center">
-  <img src="https://img.shields.io/badge/License-MIT-green" />
-  <img src="https://img.shields.io/badge/Language-C%2B%2B-00599C" />
-  <img src="https://img.shields.io/badge/Bindings-Pybind11-blue" />
-</p>
-
-## Overview
-
-FuzzyBunny is a lightweight, high-performance Python library for fuzzy string matching and ranking. It is implemented in C++ for speed and exposes a Pythonic API via Pybind11. It supports various scoring algorithms including Levenshtein, Jaccard, and Token Sort, along with partial matching capabilities.
-
-## Features
-
-- **Fast C++ Core**: Optimized string matching algorithms.
-- **Multiple Scorers**:
-  - `levenshtein`: Standard edit distance ratio.
-  - `jaccard`: Set-based similarity.
-  - `token_sort`: Sorts tokens before comparing (good for "Apple Banana" vs "Banana Apple").
-- **Ranking**: Efficiently rank a list of candidates against a query.
-- **Partial Matching**: Support for substring matching via `mode='partial'`.
-- **Unicode Support**: Correctly handles UTF-8 input.
-
-## Installation
-
-### Prerequisites
-- Python 3.8+
-- C++17 compatible compiler (GCC, Clang, MSVC)
-
-### Using uv (Recommended)
-
-```bash
-uv pip install .
-```
-
-### Using pip
-
-```bash
-pip install .
-```
-
-## Usage
-
-```python
-import fuzzybunny
-
-# Basic Levenshtein Ratio
-score = fuzzybunny.levenshtein("kitten", "sitting")
-print(f"Score: {score}")  # ~0.57
-
-# Partial Matching
-# "apple" is a perfect substring of "apple pie"
-score = fuzzybunny.partial_ratio("apple", "apple pie")
-print(f"Partial Score: {score}")  # 1.0
-
-# Ranking Candidates
-candidates = ["apple pie", "banana bread", "cherry tart", "apple crisp"]
-results = fuzzybunny.rank(
-    query="apple", 
-    candidates=candidates, 
-    scorer="levenshtein", 
-    mode="partial", 
-    top_n=2
-)
-
-for candidate, score in results:
-    print(f"{candidate}: {score}")
-# Output:
-# apple pie: 1.0
-# apple crisp: 1.0
-```
-
-## Development
-
-1. **Setup Environment**:
-   ```bash
-   uv venv
-   source .venv/bin/activate
-   ```
-
-2. **Install in Editable Mode**:
-   ```bash
-   uv pip install -e .
-   ```
-
-3. **Run Tests**:
-   ```bash
-   pytest
-   ```
-
-## License
-
-This project is licensed under the [MIT License](LICENSE).

fuzzybunny-0.1.2/fuzzybunny.egg-info/SOURCES.txt

@@ -1,12 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-setup.py
-fuzzybunny.egg-info/PKG-INFO
-fuzzybunny.egg-info/SOURCES.txt
-fuzzybunny.egg-info/dependency_links.txt
-fuzzybunny.egg-info/not-zip-safe
-fuzzybunny.egg-info/top_level.txt
-src/bindings.cpp
-src/scorers.cpp
-tests/test_basic.py