a y hB@sddlmZddlmZmZddlmZmZddlm Z ddl m Z m Z ddZdd Zd d Zd d d d dddZd d d d dddZd d d d dddZd d d d dddZddZd d dddZd d dddZd S)) annotations) common_affixconv_sequences)is_none setupPandas)Indel_py)EditopEditopsc Cslt|}t|}|\}}}||||}||krNt||||||}nt||||||}|S)N)lenmin) s1s2weightslen1Zlen2insertdeletereplaceZmax_distr]/var/www/html/assistant/venv/lib/python3.9/site-packages/rapidfuzz/distance/Levenshtein_py.py_levenshtein_maximum s rc Cst|}|\}}}ttd|d||}|D]v}|d} |d|7<t|D]P} | } || |krt|| ||| d|| |} || d} | || d<qRq.|dS)Nr)r listranger ) r r rrrrrcachech2tempixrrr_uniform_generics   $ rcCs|s t|Sdt|>d}d}t|}dt|d>}i}|j}d}|D]} || d|B|| <|dK}qJ|D]} || d} | } | |@||A| B|B} || |BB}| |@}|||@dk7}|||@dk8}|d>dB}|d>}|| |BB}|| @}qn|SNrr)r get)r r VPVNcurrDistmaskblock block_getrch1rPM_jXD0HPHNrrr_uniform_distance,s2    r.rrrN)r processor score_cutoff score_hintcCs|}|dur||}||}t||\}}|dus:|dkrFt||}n"|dkr\t||}n t|||}|dusx||kr||S|dS)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. score_cutoff : int, optional Maximum distance between s1 and s2, that is considered as a result. If the distance is bigger than score_cutoff, score_cutoff + 1 is returned instead. Default is None, which deactivates this behaviour. score_hint : int, optional Expected distance between s1 and s2. This is used to select a faster implementation. 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 Examples -------- Find the Levenshtein distance between two strings: >>> from rapidfuzz.distance import Levenshtein >>> Levenshtein.distance("lewenstein", "levenshtein") 2 Setting a maximum distance allows the implementation to select a more efficient implementation: >>> Levenshtein.distance("lewenstein", "levenshtein", score_cutoff=1) 2 It is possible to select different weights by passing a `weight` tuple. >>> Levenshtein.distance("lewenstein", "levenshtein", weights=(1,1,2)) 3 Nr/)rrr)rr.Indeldistancer)r r rr0r1r2_distrrrr5PsB  r5c Csl|}|dur||}||}t||\}}|p0d}t|||}t|||d}||} |dusd| |krh| SdS)a Calculates the levenshtein similarity in the range [max, 0] using custom costs for insertion, deletion and substitution. This is calculated as ``max - distance``, where max is the maximal possible Levenshtein distance given the lengths of the sequences s1/s2 and the weights. 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 : int, optional Maximum distance between s1 and s2, that is considered as a result. If the similarity is smaller than score_cutoff, 0 is returned instead. Default is None, which deactivates this behaviour. score_hint : int, optional Expected similarity between s1 and s2. This is used to select a faster implementation. Default is None, which deactivates this behaviour. Returns ------- similarity : int similarity between s1 and s2 Raises ------ ValueError If unsupported weights are provided a ValueError is thrown Nr/rr)rrr5) r r rr0r1r2r6maximumr7simrrr similaritys0 r;c Cs|}tt|st|rdS|dur6||}||}t||\}}|pJd}t|||}t|||d}|rr||nd} |dus| |kr| SdS)a Calculates a normalized levenshtein distance in the range [1, 0] using custom costs for insertion, deletion and substitution. This is calculated as ``distance / max``, where max is the maximal possible Levenshtein distance given the lengths of the sequences s1/s2 and the weights. 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 1.0. For norm_dist > score_cutoff 1.0 is returned instead. Default is None, which deactivates this behaviour. score_hint : float, optional Expected normalized distance between s1 and s2. This is used to select a faster implementation. Default is None, which deactivates this behaviour. Returns ------- norm_dist : float normalized distance between s1 and s2 as a float between 1.0 and 0.0 Raises ------ ValueError If unsupported weights are provided a ValueError is thrown ?Nr/r8rr)rrrrr5) r r rr0r1r2r6r9r7 norm_distrrrnormalized_distances/ r>c Csz|}tt|st|rdS|dur6||}||}t||\}}|pJd}t|||d}d|}|dusr||krv|SdS)a Calculates a normalized levenshtein similarity in the range [0, 1] using custom costs for insertion, deletion and substitution. This is calculated as ``1 - normalized_distance`` 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 1.0. For norm_sim < score_cutoff 0 is returned instead. Default is None, which deactivates this behaviour. score_hint : int, optional Expected normalized similarity between s1 and s2. This is used to select a faster implementation. Default is None, which deactivates this behaviour. Returns ------- norm_sim : float normalized similarity between s1 and s2 as a float between 0 and 1.0 Raises ------ ValueError If unsupported weights are provided a ValueError is thrown Examples -------- Find the normalized Levenshtein similarity between two strings: >>> from rapidfuzz.distance import Levenshtein >>> Levenshtein.normalized_similarity("lewenstein", "levenshtein") 0.81818181818181 Setting a score_cutoff allows the implementation to select a more efficient implementation: >>> Levenshtein.normalized_similarity("lewenstein", "levenshtein", score_cutoff=0.85) 0.0 It is possible to select different weights by passing a `weight` tuple. >>> Levenshtein.normalized_similarity("lewenstein", "levenshtein", weights=(1,1,2)) 0.85714285714285 When a different processor is used s1 and s2 do not have to be strings >>> Levenshtein.normalized_similarity(["lewenstein"], ["levenshtein"], processor=lambda s: s[0]) 0.81818181818181 gNr/r8r<r)rrrr>) r r rr0r1r2r6r=Znorm_simrrrnormalized_similaritysGr?cCs&|st|ggfSdt|>d}d}t|}dt|d>}i}|j}d}|D]} || d|B|| <|dK}qPg} g} |D]} || d} | }||@||A|B|B}|||BB}||@}|||@dk7}|||@dk8}|d>dB}|d>}|||BB}||@}| || |q||| | fSr )r r!append)r r r"r#r$r%r&r'rr(Z matrix_VPZ matrix_VNrr)r*r+r,r-rrr_matrixvs:     rAr0r2cCs|}|dur||}||}t||\}}t||\}}||t||}||t||}t||\}}} tgdd} t|||| _t|||| _|dkr| Sdg|} t|} t|} | dkr| dkr|| dd| d>@r|d8}| d8} td| || || |<q| d8} | rh| | dd| d>@rh|d8}td| || || |<q| d8} || || kr|d8}td| || || |<q| dkr|d8}| d8} td| || || |<q| dkr|d8}| d8} td| || || |<q| | _| S)u  Return Editops describing how to turn 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. score_hint : int, optional Expected distance between s1 and s2. This is used to select a faster implementation. Default is None, which deactivates this behaviour. Returns ------- editops : Editops edit operations required to turn s1 into s2 Notes ----- The alignment is calculated using an algorithm of Heikki Hyyrö, which is described [8]_. It has a time complexity and memory usage of ``O([N/64] * M)``. References ---------- .. [8] Hyyrö, Heikki. "A Note on Bit-Parallel Alignment Computation." Stringology (2004). Examples -------- >>> from rapidfuzz.distance import Levenshtein >>> 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] Nrrrrr) rrr rAr Z_src_lenZ _dest_lenrZ_editops)r r r0r2r6 prefix_lenZ suffix_lenr7r"r#editopsZ editop_listcolrowrrrrDsP/     rDcCst||||dS)u Return Opcodes describing how to turn 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. score_hint : int, optional Expected distance between s1 and s2. This is used to select a faster implementation. Default is None, which deactivates this behaviour. Returns ------- opcodes : Opcodes edit operations required to turn s1 into s2 Notes ----- The alignment is calculated using an algorithm of Heikki Hyyrö, which is described [9]_. It has a time complexity and memory usage of ``O([N/64] * M)``. References ---------- .. [9] Hyyrö, Heikki. "A Note on Bit-Parallel Alignment Computation." Stringology (2004). Examples -------- >>> from rapidfuzz.distance import Levenshtein >>> a = "qabxcd" >>> b = "abycdf" >>> for tag, i1, i2, j1, j2 in Levenshtein.opcodes("qabxcd", "abycdf"): ... print(("%7s a[%d:%d] (%s) b[%d:%d] (%s)" % ... (tag, i1, i2, a[i1:i2], j1, j2, b[j1:j2]))) delete a[0:1] (q) b[0:0] () equal a[1:3] (ab) b[0:2] (ab) replace a[3:4] (x) b[2:3] (y) equal a[4:6] (cd) b[3:5] (cd) insert a[6:6] () b[5:6] (f) rB)rDZ as_opcodes)r r r0r2rrropcodess5rG) __future__rZrapidfuzz._common_pyrrZrapidfuzz._utilsrrZrapidfuzz.distancerr4Z!rapidfuzz.distance._initialize_pyrr rrr.r5r;r>r?rArDrGrrrrsD  ( V A D W- k