fuzzybunny 0.1.2__cp312-cp312-win32.whl → 0.2.1__cp312-cp312-win32.whl

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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,8 @@
+fuzzybunny/__init__.py,sha256=P2QxF06r8iOSnRKnLiJ0Uq2HBm7BoFthZ7rWGs252k0,2470
+fuzzybunny/_fuzzybunny.cp312-win32.pyd,sha256=gZsUtjxIhw7RYVDBxwJr4oP6WHPhWm5Jy4yDhB8iwts,167424
+fuzzybunny/benchmark.py,sha256=Qmg4-CBnB3RXDBHBY4zI5648isWcmT99EbRcEeID9-4,1481
+fuzzybunny-0.2.1.dist-info/licenses/LICENSE,sha256=hvCYI5G-uZ41pxcDhQFHZHyMLk6BxmI_a27L1656lpo,1093
+fuzzybunny-0.2.1.dist-info/METADATA,sha256=t69ot_el7SSGHpAjU_vP9D3OsW5WB5eA7WsSccLiXs8,2927
+fuzzybunny-0.2.1.dist-info/WHEEL,sha256=8cyM5EMLFqzYwxLDPOphhpRdliCRv1Z8mqm6Nh-cHpI,98
+fuzzybunny-0.2.1.dist-info/top_level.txt,sha256=rBIGqLOrlMo_aY9-MDE05n-7FuenH7CnsVNydAlCa_E,11
+fuzzybunny-0.2.1.dist-info/RECORD,,

{fuzzybunny-0.1.2.dist-info → fuzzybunny-0.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: false
 Tag: cp312-cp312-win32
 

fuzzybunny-0.1.2.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -1,6 +0,0 @@
-fuzzybunny.cp312-win32.pyd,sha256=jh-fKoCr181kTVV1uqWgAT092s99yadKs1qO6owkhvw,159232
-fuzzybunny-0.1.2.dist-info/licenses/LICENSE,sha256=hvCYI5G-uZ41pxcDhQFHZHyMLk6BxmI_a27L1656lpo,1093
-fuzzybunny-0.1.2.dist-info/METADATA,sha256=OQ0NXmpf02e-_BydnDa3skOYRQmAAOhvUov2kzSD5mA,2838
-fuzzybunny-0.1.2.dist-info/WHEEL,sha256=LwxTQZ0gyDP_uaeNCLm-ZIktY9hv6x0e22Q-hgFd-po,97
-fuzzybunny-0.1.2.dist-info/top_level.txt,sha256=rBIGqLOrlMo_aY9-MDE05n-7FuenH7CnsVNydAlCa_E,11
-fuzzybunny-0.1.2.dist-info/RECORD,,