fuzzybunny 0.1.0__tar.gz

fuzzybunny-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Aftaab Siddiqui
+
+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.

fuzzybunny-0.1.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: fuzzybunny
+Version: 0.1.0
+Summary: A fuzzy search tool written in python (actually 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.0/README.md

@@ -0,0 +1,101 @@
+<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.0/fuzzybunny.egg-info/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: fuzzybunny
+Version: 0.1.0
+Summary: A fuzzy search tool written in python (actually 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.0/fuzzybunny.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+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

fuzzybunny-0.1.0/fuzzybunny.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fuzzybunny-0.1.0/fuzzybunny.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

fuzzybunny-0.1.0/fuzzybunny.egg-info/top_level.txt

@@ -0,0 +1 @@
+fuzzybunny

fuzzybunny-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel", "pybind11>=2.10.0"]
+build-backend = "setuptools.build_meta"

fuzzybunny-0.1.0/setup.cfg

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

fuzzybunny-0.1.0/setup.py

@@ -0,0 +1,46 @@
+import sys
+from setuptools import setup, Extension
+from setuptools.command.build_ext import build_ext
+import pybind11
+
+class PybindBuildExt(build_ext):
+    """Custom build_ext to ensure specific compiler flags."""
+    def build_extensions(self):
+        ct = self.compiler.compiler_type
+        opts = []
+        if ct == 'unix':
+            opts.append('-DVERSION_INFO="%s"' % self.distribution.get_version())
+            opts.append('-std=c++17')
+            opts.append('-fvisibility=hidden')
+        elif ct == 'msvc':
+            opts.append('/DVERSION_INFO=\"%s\"' % self.distribution.get_version())
+            opts.append('/std:c++17')
+        
+        for ext in self.extensions:
+            ext.extra_compile_args = opts
+        
+        build_ext.build_extensions(self)
+
+ext_modules = [
+    Extension(
+        "fuzzybunny",
+        ["src/bindings.cpp", "src/scorers.cpp"],
+        include_dirs=[
+            pybind11.get_include(),
+            "src"
+        ],
+        language="c++"
+    ),
+]
+
+setup(
+    name="fuzzybunny",
+    version="0.1.0",
+    description="A fuzzy search tool written in python (actually C++)",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    ext_modules=ext_modules,
+    cmdclass={"build_ext": PybindBuildExt},
+    zip_safe=False,
+    python_requires=">=3.8",
+)

fuzzybunny-0.1.0/src/bindings.cpp

@@ -0,0 +1,60 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include "scorers.hpp"
+
+namespace py = pybind11;
+using namespace fuzzybunny;
+
+PYBIND11_MODULE(fuzzybunny, m) {
+    m.doc() = R"pbdoc(
+        FuzzyBunny: A fast fuzzy string matching library
+        ------------------------------------------------
+        .. currentmodule:: fuzzybunny
+        .. autosummary::
+           :toctree: _generate
+           levenshtein
+           jaccard
+           token_sort
+           rank
+    )pbdoc";
+
+    m.def("levenshtein", [](const std::string& s1, const std::string& s2) {
+        return levenshtein_ratio(utf8_to_u32(s1), utf8_to_u32(s2));
+    }, py::arg("s1"), py::arg("s2"), "Calculate Levenshtein ratio (0.0 - 1.0)");
+
+    m.def("partial_ratio", [](const std::string& s1, const std::string& s2) {
+        return partial_ratio(utf8_to_u32(s1), utf8_to_u32(s2));
+    }, py::arg("s1"), py::arg("s2"), "Calculate Partial Levenshtein ratio (0.0 - 1.0)");
+
+    m.def("jaccard", [](const std::string& s1, const std::string& s2) {
+        return jaccard_similarity(utf8_to_u32(s1), utf8_to_u32(s2));
+    }, py::arg("s1"), py::arg("s2"), "Calculate Jaccard similarity (0.0 - 1.0)");
+
+    m.def("token_sort", [](const std::string& s1, const std::string& s2) {
+        return token_sort_ratio(utf8_to_u32(s1), utf8_to_u32(s2));
+    }, py::arg("s1"), py::arg("s2"), "Calculate Token Sort ratio (0.0 - 1.0)");
+
+    m.def("rank", &rank,
+          py::arg("query"),
+          py::arg("candidates"),
+          py::arg("scorer") = "levenshtein",
+          py::arg("mode") = "full",
+          py::arg("threshold") = 0.0,
+          py::arg("top_n") = -1,
+          "Rank candidates against a query string. Returns list of (string, score) tuples.");
+
+    m.def("batch_match", &batch_match,
+          py::arg("queries"),
+          py::arg("candidates"),
+          py::arg("scorer") = "levenshtein",
+          py::arg("mode") = "full",
+          py::arg("threshold") = 0.0,
+          py::arg("top_n") = -1,
+          "Batch match multiple queries against candidates.");
+
+#ifdef VERSION_INFO
+    m.attr("__version__") = VERSION_INFO;
+#else
+    m.attr("__version__") = "dev";
+#endif
+}

fuzzybunny-0.1.0/src/scorers.cpp

@@ -0,0 +1,250 @@
+#include "scorers.hpp"
+#include <algorithm>
+#include <vector>
+#include <set>
+#include <sstream>
+#include <cmath>
+#include <map>
+#include <iostream>
+#include <cstdint>
+
+namespace fuzzybunny {
+
+// --- Unicode Helper ---
+
+// Converting manually because std::codecvt is deprecated in C++17
+// and we want to avoid external dependencies like ICU for this lightweight lib.
+std::u32string utf8_to_u32(const std::string& s) {
+    std::u32string result;
+    result.reserve(s.size()); 
+
+    for (size_t i = 0; i < s.length(); ) {
+        unsigned char c = static_cast<unsigned char>(s[i]);
+        uint32_t code_point = 0;
+        int seq_len = 0;
+
+        if (c < 0x80) {
+            code_point = c;
+            seq_len = 1;
+        } else if ((c & 0xE0) == 0xC0) {
+            code_point = c & 0x1F;
+            seq_len = 2;
+        } else if ((c & 0xF0) == 0xE0) {
+            code_point = c & 0x0F;
+            seq_len = 3;
+        } else if ((c & 0xF8) == 0xF0) {
+            code_point = c & 0x07;
+            seq_len = 4;
+        } else {
+            // Skip invalid start bytes to prevent decoding errors
+            i++;
+            continue;
+        }
+
+        if (i + seq_len > s.length()) break; 
+
+        bool valid = true;
+        for (int k = 1; k < seq_len; ++k) {
+            unsigned char next = static_cast<unsigned char>(s[i + k]);
+            if ((next & 0xC0) != 0x80) {
+                valid = false;
+                break;
+            }
+            code_point = (code_point << 6) | (next & 0x3F);
+        }
+
+        if (valid) {
+            result.push_back(code_point);
+            i += seq_len;
+        } else {
+            i++; 
+        }
+    }
+    return result;
+}
+
+// --- Internal Utils ---
+
+std::vector<std::u32string> tokenize(const std::u32string& s) {
+    std::vector<std::u32string> tokens;
+    std::u32string current;
+    for (char32_t c : s) {
+        if (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
+            if (!current.empty()) {
+                tokens.push_back(current);
+                current.clear();
+            }
+        } else {
+            current.push_back(c);
+        }
+    }
+    if (!current.empty()) tokens.push_back(current);
+    return tokens;
+}
+
+// --- Scorers ---
+
+double levenshtein_ratio(const std::u32string& s1, const std::u32string& s2) {
+    size_t len1 = s1.size();
+    size_t len2 = s2.size();
+
+    if (len1 == 0 && len2 == 0) return 1.0;
+    if (len1 == 0 || len2 == 0) return 0.0;
+
+    std::vector<size_t> prev(len2 + 1);
+    std::vector<size_t> curr(len2 + 1);
+
+    for (size_t j = 0; j <= len2; ++j) prev[j] = j;
+
+    for (size_t i = 1; i <= len1; ++i) {
+        curr[0] = i;
+        for (size_t j = 1; j <= len2; ++j) {
+            size_t cost = (s1[i - 1] == s2[j - 1]) ? 0 : 1;
+            curr[j] = std::min({
+                prev[j] + 1,       
+                curr[j - 1] + 1,   
+                prev[j - 1] + cost 
+            });
+        }
+        prev = curr;
+    }
+
+    size_t dist = prev[len2];
+    size_t max_len = std::max(len1, len2);
+    
+    return 1.0 - (static_cast<double>(dist) / static_cast<double>(max_len));
+}
+
+double partial_ratio(const std::u32string& s1, const std::u32string& s2) {
+    if (s1.empty() && s2.empty()) return 1.0;
+    if (s1.empty() || s2.empty()) return 0.0;
+
+    const auto& shorter = (s1.size() <= s2.size()) ? s1 : s2;
+    const auto& longer = (s1.size() > s2.size()) ? s1 : s2;
+
+    double max_ratio = 0.0;
+    size_t k = shorter.size();
+    
+    // Sliding window over the longer string to find the best matching substring
+    for (size_t i = 0; i <= longer.size() - k; ++i) {
+        std::u32string sub = longer.substr(i, k);
+        double ratio = levenshtein_ratio(shorter, sub);
+        if (ratio > max_ratio) max_ratio = ratio;
+    }
+    return max_ratio;
+}
+
+double jaccard_similarity(const std::u32string& s1, const std::u32string& s2) {
+    std::vector<std::u32string> tokens1 = tokenize(s1);
+    std::vector<std::u32string> tokens2 = tokenize(s2);
+
+    if (tokens1.empty() && tokens2.empty()) return 1.0;
+    if (tokens1.empty() || tokens2.empty()) return 0.0;
+
+    std::set<std::u32string> set1(tokens1.begin(), tokens1.end());
+    std::set<std::u32string> set2(tokens2.begin(), tokens2.end());
+
+    std::vector<std::u32string> intersection;
+    std::set_intersection(set1.begin(), set1.end(),
+                          set2.begin(), set2.end(),
+                          std::back_inserter(intersection));
+
+    std::vector<std::u32string> union_set;
+    std::set_union(set1.begin(), set1.end(),
+                   set2.begin(), set2.end(),
+                   std::back_inserter(union_set));
+
+    if (union_set.empty()) return 0.0;
+    return static_cast<double>(intersection.size()) / static_cast<double>(union_set.size());
+}
+
+double token_sort_ratio(const std::u32string& s1, const std::u32string& s2) {
+    auto t1 = tokenize(s1);
+    auto t2 = tokenize(s2);
+    
+    std::sort(t1.begin(), t1.end());
+    std::sort(t2.begin(), t2.end());
+
+    std::u32string joined1, joined2;
+    for (size_t i = 0; i < t1.size(); ++i) {
+        joined1 += t1[i];
+        if (i < t1.size() - 1) joined1 += ' ';
+    }
+    for (size_t i = 0; i < t2.size(); ++i) {
+        joined2 += t2[i];
+        if (i < t2.size() - 1) joined2 += ' ';
+    }
+
+    return levenshtein_ratio(joined1, joined2);
+}
+
+// --- Ranking ---
+
+std::vector<MatchResult> rank(
+    const std::string& query,
+    const std::vector<std::string>& candidates,
+    const std::string& scorer,
+    const std::string& mode,
+    double threshold,
+    int top_n
+) {
+    std::u32string uQuery = utf8_to_u32(query);
+    std::vector<MatchResult> results;
+    results.reserve(candidates.size());
+
+    for (const auto& cand : candidates) {
+        std::u32string uCand = utf8_to_u32(cand);
+        double score = 0.0;
+
+        if (scorer == "levenshtein") {
+            if (mode == "partial") {
+                score = partial_ratio(uQuery, uCand);
+            } else {
+                score = levenshtein_ratio(uQuery, uCand);
+            }
+        } else if (scorer == "jaccard") {
+             // Jaccard is inherently set-based, so partial matching on substrings
+             // doesn't align with the standard definition. 
+            score = jaccard_similarity(uQuery, uCand);
+        } else if (scorer == "token_sort") {
+            score = token_sort_ratio(uQuery, uCand);
+        } else {
+             score = 0.0;
+        }
+
+        if (score >= threshold) {
+            results.push_back({cand, score});
+        }
+    }
+
+    std::sort(results.begin(), results.end(), [](const MatchResult& a, const MatchResult& b) {
+        return a.second > b.second;
+    });
+
+    if (top_n > 0 && static_cast<size_t>(top_n) < results.size()) {
+        results.resize(top_n);
+    }
+
+    return results;
+}
+
+std::vector<std::vector<MatchResult>> batch_match(
+    const std::vector<std::string>& queries,
+    const std::vector<std::string>& candidates,
+    const std::string& scorer,
+    const std::string& mode,
+    double threshold,
+    int top_n
+) {
+    std::vector<std::vector<MatchResult>> batch_results;
+    batch_results.reserve(queries.size());
+
+    // Simple sequential processing for now. 
+    // Future optimization: OpenMP #pragma omp parallel for
+    for (const auto& query : queries) {
+        batch_results.push_back(rank(query, candidates, scorer, mode, threshold, top_n));
+    }
+    return batch_results;
+}
+
+} // namespace fuzzybunny

fuzzybunny-0.1.0/tests/test_basic.py

@@ -0,0 +1,70 @@
+import pytest
+import fuzzybunny
+
+def test_levenshtein():
+    assert fuzzybunny.levenshtein("kitten", "sitting") > 0.5
+    assert fuzzybunny.levenshtein("apple", "apple") == 1.0
+    assert fuzzybunny.levenshtein("abc", "def") == 0.0  # Actually 0.0 because len=3, dist=3, 1 - 3/3 = 0
+    assert fuzzybunny.levenshtein("", "") == 1.0
+
+def test_partial():
+    # "apple" is inside "apple pie"
+    assert fuzzybunny.partial_ratio("apple", "apple pie") == 1.0
+    # "pie" is inside "apple pie"
+    assert fuzzybunny.partial_ratio("pie", "apple pie") == 1.0
+    # "xyz" is not in "apple pie"
+    assert fuzzybunny.partial_ratio("xyz", "apple pie") == 0.0
+    
+    # rank with mode='partial'
+    cands = ["apple pie", "banana split", "cherry tart"]
+    results = fuzzybunny.rank("apple", cands, scorer="levenshtein", mode="partial")
+    assert results[0][0] == "apple pie"
+    assert results[0][1] == 1.0
+
+def test_jaccard():
+    assert fuzzybunny.jaccard("apple banana", "banana apple") == 1.0
+    assert fuzzybunny.jaccard("apple", "banana") == 0.0
+    assert fuzzybunny.jaccard("a b c", "a c") > 0.5
+
+def test_token_sort():
+    assert fuzzybunny.token_sort("apple banana", "banana apple") == 1.0
+    assert fuzzybunny.token_sort("fuzzy bunny", "bunny fuzzy") == 1.0
+
+def test_unicode():
+    # 'café' vs 'cafe' (levenshtein should catch diff)
+    s1 = "café"
+    s2 = "cafe"
+    assert fuzzybunny.levenshtein(s1, s2) < 1.0
+    assert fuzzybunny.levenshtein(s1, s1) == 1.0
+    
+    # Emoji
+    assert fuzzybunny.levenshtein("😊", "😊") == 1.0
+    assert fuzzybunny.levenshtein("😊", "😂") < 1.0
+
+def test_rank():
+    candidates = ["apple", "apricot", "banana", "cherry"]
+    results = fuzzybunny.rank("app", candidates, scorer="levenshtein", top_n=2)
+    assert len(results) == 2
+    assert results[0][0] == "apple"
+    
+    results_empty = fuzzybunny.rank("xyz", candidates, threshold=0.9)
+    assert len(results_empty) == 0
+
+def test_batch_match():
+    queries = ["apple", "banana"]
+    candidates = ["apple pie", "banana bread", "cherry tart"]
+    results = fuzzybunny.batch_match(queries, candidates, mode="partial")
+    
+    assert len(results) == 2
+    # First query "apple" matches "apple pie"
+    assert results[0][0][0] == "apple pie"
+    assert results[0][0][1] == 1.0
+    
+    # Second query "banana" matches "banana bread"
+    assert results[1][0][0] == "banana bread"
+    assert results[1][0][1] == 1.0
+
+def test_invalid_scorer_rank():
+    # Should default to 0.0 or handle gracefully
+    results = fuzzybunny.rank("a", ["a"], scorer="unknown")
+    assert results[0][1] == 0.0