xnhBddlmZddlmZmZddlmZmZddlm Z ddl m Z m Z dZdZdZd d d d d d Zd d d d d d Zd d d d d dZd d d d d dZdZd d ddZd d ddZy )) annotations) common_affixconv_sequences)is_none setupPandas)Indel_py)EditopEditopsct|}t|}|\}}}||z||zz}||k\rt|||z||z |zz}|St|||z||z |zz}|S)N)lenmin) s1s2weightslen1len2insertdeletereplacemax_dists b/var/www/html/profi_bot/bot/venv/lib/python3.12/site-packages/rapidfuzz/distance/Levenshtein_py.py_levenshtein_maximumr s r7D r7D%FFGf}tf},H t|x4$;&2H!HI Ox4$;&2H!HI Oc*t|}|\}}}ttd|dz|z|}|D]]}|d} |dxx|z cc<t|D];} | } || |k7rt|| |z|| dz|z| |z} || dz} | || dz<=_|dS)Nr)r listranger ) rrrrrrrcachech2tempixs r_uniform_genericr$s r7D%FFG q4!8v-v6 7EQx aFtAA!u|a6)5Q<&+@$.QQ>> 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 r5)rrr)rr4Indeldistancer$)rrrr6r7r8_dists rr<r<PsD A r] r] B #FB'Y. R( I ~~b"%B0 (DL,@4W|VWGWWrc|}|||}||}t||\}}|xsd}t|||}t|||}||z } || |k\r| 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 r5rr)rrr<) rrrr6r7r8r=maximumr>sims r similarityrCsx` A r] r] B #FB"G"2r73G BG ,D D.C'3,+>3FQFrc|}tt|s t|ry|||}||}t||\}}|xsd}t|||}t |||}|r||z nd} || |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 ?r5r@rr)rrrrr<) rrrr6r7r8r=rAr> norm_dists rnormalized_distancerGs^ AMr{gbk r] r] B #FB"G"2r73G BG ,D")wqI%-l1J9RQRRrc|}tt|s t|ry|||}||}t||\}}|xsd}t|||}d|z }|||k\r|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 gr5r@rEr)rrrrG) rrrr6r7r8r=rFnorm_sims rnormalized_similarityrJsN AMr{gbk r] r] B #FB"G#BG>> 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 rOr _src_len _dest_lenr _editops)rrr6r8r= prefix_len suffix_lenr>r(r)editops editop_listcolrows rrWrWsb^ A r] r] B #FB)"b1J JR:- .B JR:- .B2r?LD"bb!QG2w+j8GB*,z9G qy&4-K b'C b'C (sax cAg;!a. ) AID 1HC &xz1A3CS TK  1HC37 qS1W~6 $*8S:5EsZGW$X D!qc7bg%AID(.y# :JCR\L\(]K%' (sax* (   q"8S:-=sZ?OP D ( (   q"8S:-=sZ?OP D ( #G Nrc<t||||jS)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) rP)rW as_opcodes)rrr6r8s ropcodesr]sj 2rY: F Q Q SSr) __future__rrapidfuzz._common_pyrrrapidfuzz._utilsrrrapidfuzz.distancerr;!rapidfuzz.distance._initialize_pyr r rr$r4r<rCrGrJrOrWr]rrrds#=10= $!P OXl :GB =SH TQn&,Z dV 5Tr