d4ddlmZddlZddlmZmZmZddlmZm Z m Z m Z m Z dddddd$dZ ddd%dZddddd&dZddddd'dZdddd(dZdddd(dZd ddd!d)d#ZdS)*) annotationsN)CallableHashableSequence)EditopHammingJaro JaroWinkler Levenshtein)r r )weights processormax score_cutoffs1Sequence[Hashable]s2r tuple[int, int, int] | Noner(Callable[..., Sequence[Hashable]] | Noner int | Nonerreturnintcttjdtd|p|}tj|||||S)a[ Calculates the minimum number of insertions, deletions, and substitutions required to change one sequence into the other according to Levenshtein with custom costs for insertion, deletion and substitution Parameters ---------- s1 : Sequence[Hashable] First string to compare. s2 : Sequence[Hashable] Second string to compare. weights : Tuple[int, int, int] or None, optional The weights for the three operations in the form (insertion, deletion, substitution). Default is (1, 1, 1), which gives all three operations a weight of 1. processor: callable, optional Optional callable that is used to preprocess the strings before comparing them. Default is None, which deactivates this behaviour. max : int or None, optional Maximum distance between s1 and s2, that is considered as a result. If the distance is bigger than max, max + 1 is returned instead. Default is None, which deactivates this behaviour. Returns ------- distance : int distance between s1 and s2 Raises ------ ValueError If unsupported weights are provided a ValueError is thrown .. deprecated:: 2.0.0 Use :func:`rapidfuzz.distance.Levenshtein.distance` instead. This function will be removed in v3.0.0. Examples -------- Find the Levenshtein distance between two strings: >>> from rapidfuzz.string_metric import levenshtein >>> levenshtein("lewenstein", "levenshtein") 2 Setting a maximum distance allows the implementation to select a more efficient implementation: >>> levenshtein("lewenstein", "levenshtein", max=1) 2 It is possible to select different weights by passing a `weight` tuple. >>> levenshtein("lewenstein", "levenshtein", weights=(1,1,2)) 3 z\This function will be remove in v3.0.0. Use rapidfuzz.distance.Levenshtein.distance instead. stacklevelr rr)warningswarnDeprecationWarningr distance)rrr rrrs [/home/feoh/.local/pipx/venvs/poetry/lib/python3.11/site-packages/rapidfuzz/string_metric.py levenshteinr# sXF Mf  &3L   B9<   r list[Editop]ctjdtdtj|||S)a Return list of 3-tuples describing how to turn s1 into s2. Each tuple is of the form (tag, src_pos, dest_pos). The tags are strings, with these meanings: 'replace': s1[src_pos] should be replaced by s2[dest_pos] 'delete': s1[src_pos] should be deleted. 'insert': s2[dest_pos] should be inserted at s1[src_pos]. Parameters ---------- s1 : Sequence[Hashable] First string to compare. s2 : Sequence[Hashable] Second string to compare. processor: callable, optional Optional callable that is used to preprocess the strings before comparing them. Default is None, which deactivates this behaviour. Returns ------- editops : list[] edit operations required to turn s1 into s2 .. deprecated:: 2.0.0 Use :func:`rapidfuzz.distance.Levenshtein.editops` instead. This function will be removed in v3.0.0. Examples -------- >>> from rapidfuzz.string_metric import levenshtein_editops >>> for tag, src_pos, dest_pos in levenshtein_editops("qabxcd", "abycdf"): ... print(("%7s s1[%d] s2[%d]" % (tag, src_pos, dest_pos))) delete s1[1] s2[0] replace s1[3] s2[2] insert s1[6] s2[5] z[This function will be remove in v3.0.0. Use rapidfuzz.distance.Levenshtein.editops instead.rrr%)rrr r editopsas_list)rrrs r"levenshtein_editopsr*ZsMV Me  r2 ; ; ; C C E EEr$r float | Nonefloatcrtjdtdtj|||||dzS)al Calculates a normalized levenshtein distance using custom costs for insertion, deletion and substitution. Parameters ---------- s1 : Sequence[Hashable] First string to compare. s2 : Sequence[Hashable] Second string to compare. weights : Tuple[int, int, int] or None, optional The weights for the three operations in the form (insertion, deletion, substitution). Default is (1, 1, 1), which gives all three operations a weight of 1. processor: callable, optional Optional callable that is used to preprocess the strings before comparing them. Default is None, which deactivates this behaviour. score_cutoff : float, optional Optional argument for a score threshold as a float between 0 and 100. For ratio < score_cutoff 0 is returned instead. Default is 0, which deactivates this behaviour. Returns ------- similarity : float similarity between s1 and s2 as a float between 0 and 100 Raises ------ ValueError If unsupported weights are provided a ValueError is thrown .. deprecated:: 2.0.0 Use :func:`rapidfuzz.distance.Levenshtein.normalized_similarity` instead. This function will be removed in v3.0.0. See Also -------- levenshtein : Levenshtein distance Examples -------- Find the normalized Levenshtein distance between two strings: >>> from rapidfuzz.string_metric import normalized_levenshtein >>> normalized_levenshtein("lewenstein", "levenshtein") 81.81818181818181 Setting a score_cutoff allows the implementation to select a more efficient implementation: >>> normalized_levenshtein("lewenstein", "levenshtein", score_cutoff=85) 0.0 It is possible to select different weights by passing a `weight` tuple. >>> normalized_levenshtein("lewenstein", "levenshtein", weights=(1,1,2)) 85.71428571428571 When a different processor is used s1 and s2 do not have to be strings >>> normalized_levenshtein(["lewenstein"], ["levenshtein"], processor=lambda s: s[0]) 81.81818181818181 ziThis function will be remove in v3.0.0. Use rapidfuzz.distance.Levenshtein.normalized_similarity instead.rrrd)rrr r normalized_similarity)rrr rrs r"normalized_levenshteinr0sXR Ms ) Gy|     r$)rrrcrtjdtd|p|}tj||||S)al Calculates the Hamming distance between two strings. The hamming distance is defined as the number of positions where the two strings differ. It describes the minimum amount of substitutions required to transform s1 into s2. Parameters ---------- s1 : Sequence[Hashable] First string to compare. s2 : Sequence[Hashable] Second string to compare. processor: callable, optional Optional callable that is used to preprocess the strings before comparing them. Default is None, which deactivates this behaviour. max : int or None, optional Maximum distance between s1 and s2, that is considered as a result. If the distance is bigger than max, max + 1 is returned instead. Default is None, which deactivates this behaviour. Returns ------- distance : int distance between s1 and s2 Raises ------ ValueError If s1 and s2 have a different length .. deprecated:: 2.0.0 Use :func:`rapidfuzz.distance.Hamming.distance` instead. This function will be removed in v3.0.0. zXThis function will be remove in v3.0.0. Use rapidfuzz.distance.Hamming.distance instead.rrrr)rrr rr!)rrrrrs r"hammingr3sMV Mb  &3L  Bil S S SSr$r2cptjdtdtj||||dzS)a Calculates a normalized hamming distance Parameters ---------- s1 : Sequence[Hashable] First string to compare. s2 : Sequence[Hashable] Second string to compare. processor: callable, optional Optional callable that is used to preprocess the strings before comparing them. Default is None, which deactivates this behaviour. score_cutoff : float, optional Optional argument for a score threshold as a float between 0 and 100. For ratio < score_cutoff 0 is returned instead. Default is 0, which deactivates this behaviour. Returns ------- similarity : float similarity between s1 and s2 as a float between 0 and 100 Raises ------ ValueError If s1 and s2 have a different length See Also -------- hamming : Hamming distance .. deprecated:: 2.0.0 Use :func:`rapidfuzz.distance.Hamming.normalized_similarity` instead. This function will be removed in v3.0.0. zeThis function will be remove in v3.0.0. Use rapidfuzz.distance.Hamming.normalized_similarity instead.rrr2r.)rrr rr/rrrrs r"normalized_hammingr6sVT Mo % il     r$cptjdtdtj||||dzS)aV Calculates the jaro similarity Parameters ---------- s1 : Sequence[Hashable] First string to compare. s2 : Sequence[Hashable] Second string to compare. processor: callable, optional Optional callable that is used to preprocess the strings before comparing them. Default is None, which deactivates this behaviour. score_cutoff : float, optional Optional argument for a score threshold as a float between 0 and 100. For ratio < score_cutoff 0 is returned instead. Default is 0, which deactivates this behaviour. Returns ------- similarity : float similarity between s1 and s2 as a float between 0 and 100 .. deprecated:: 2.0.0 Use :func:`rapidfuzz.distance.Jaro.similarity` instead. This function will be removed in v3.0.0. zWThis function will be remove in v3.0.0. Use rapidfuzz.distance.Jaro.similarity instead.rrr2r.)rrr r similarityr5s r"jaro_similarityr9NsHB Ma ?2rY\ R R RUX XXr$g? prefix_weightrrr;crtjdtdtj|||||dzS)aG Calculates the jaro winkler similarity Parameters ---------- s1 : Sequence[Hashable] First string to compare. s2 : Sequence[Hashable] Second string to compare. prefix_weight : float, optional Weight used for the common prefix of the two strings. Has to be between 0 and 0.25. Default is 0.1. processor: callable, optional Optional callable that is used to preprocess the strings before comparing them. Default is None, which deactivates this behaviour. score_cutoff : float, optional Optional argument for a score threshold as a float between 0 and 100. For ratio < score_cutoff 0 is returned instead. Default is 0, which deactivates this behaviour. Returns ------- similarity : float similarity between s1 and s2 as a float between 0 and 100 Raises ------ ValueError If prefix_weight is invalid .. deprecated:: 2.0.0 Use :func:`rapidfuzz.distance.JaroWinkler.similarity` instead. This function will be removed in v3.0.0. z^This function will be remove in v3.0.0. Use rapidfuzz.distance.JaroWinkler.similarity instead.rrr:r.)rrr r r8)rrr;rrs r"jaro_winkler_similarityr=ws\T Mh   '%       r$)rrrrr rrrrrrrrr)rrrrrrrr&) rrrrr rrrrr+rr,) rrrrrrrrrrrr) rrrrrrrr+rr,) rrrrr;r,rrrr+rr,) __future__rrtypingrrrrapidfuzz.distancerrr r r r#r*r0r3r6r9r=r$r"rBs#"""""//////////NNNNNNNNNNNNNN,5:>#KKKKKKd;? 0F0F0F0F0F0Fn,5:>!% SSSSSSt;?# 1T1T1T1T1T1Tp;?!% 444444v;?!% &Y&Y&Y&Y&Y&YZ:>!% 88888888r$