difflib-fast 0.1.1

Fast, byte-for-byte exact difflib Ratcliff–Obershelp (gestalt) similarity ratio + single-linkage clustering, via a suffix automaton.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

"""difflib-fast — fast, byte-for-byte exact difflib Ratcliff-Obershelp similarity + clustering.

A drop-in for ``difflib.SequenceMatcher(None, a, b, autojunk=False).ratio()``, computed with a suffix
automaton (Rust), plus exact single-linkage clustering of a corpus.

``ratio`` is overloaded: two strings → one float; a list of ``(a, b)`` pairs → a list of floats,
computed across all cores inside Rust (rayon, GIL released) — the contention-free way to score a batch.
"""

from typing import overload

from ._difflib_fast import (
    cluster_canonicals,
    cluster_canonicals_lsh,
    ratio as _ratio,
    ratio_many as _ratio_many,
)

__all__ = ["ratio", "cluster_canonicals", "cluster_canonicals_lsh"]


@overload
def ratio(a: str, b: str, /) -> float: ...
@overload
def ratio(pairs: list[tuple[str, str]], /) -> list[float]: ...
def ratio(a, b=None, /):
    """Exact ``difflib.SequenceMatcher(None, a, b, autojunk=False).ratio()`` — byte-for-byte.

    - ``ratio(a, b)`` → one float for the pair.
    - ``ratio(pairs)`` → one float per ``(a, b)`` pair, computed in parallel across all cores inside
      Rust (the GIL is released), so a batch saturates every core with no ``ThreadPoolExecutor`` and no
      per-call overhead. ``ratio(pairs)[i] == ratio(*pairs[i])``, in order.
    """
    if b is None:
        return _ratio_many(a)
    return _ratio(a, b)