o U 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 Csnt|}t|}|\}}}||||}||kr(t||||||}|St||||||}|S)N)lenmin) s1s2weightslen1len2insertdeletereplacemax_distru/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/rapidfuzz/distance/Levenshtein_py.py_levenshtein_maximum s rc Cst|}|\}}}ttd|d||}|D];}|d} |d|7<t|D](} | } || |krEt|| ||| d|| |} || d} | || d<q)q|dS)Nr)r listranger ) r r rrrrrcachech2tempixrrr_uniform_generics   $ r!cCs|st|Sdt|>d}d}t|}dt|d>}i}|j}d}|D]} || d|B|| <|dK}q%|D]E} || d} | } | |@||A| B|B} || |BB}| |@}|||@dk7}|||@dk8}|d>dB}|d>}|| |BB}|| @}q7|SNrr)r get)r r VPVNcurrDistmaskblock block_getr ch1rPM_jXD0HPHNrrr_uniform_distance,s2    r0rrrN)r processor score_cutoff score_hintcCs|}|dur||}||}t||\}}|dus|dkr#t||}n|dkr.t||}nt|||}|dus<||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 Nr1)rrr)rr0Indeldistancer!)r r rr2r3r4_distrrrr7PsB  r7c Csl|}|dur||}||}t||\}}|pd}t|||}t|||d}||} |dus2| |kr4| 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 Nr1rr)rrr7) r r rr2r3r4r8maximumr9simrrr similaritys0 r=c Cs|}tt|s t|rdS|dur||}||}t||\}}|p%d}t|||}t|||d}|r9||nd} |dusC| |krE| 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 ?Nr1r:rr)rrrrr7) r r rr2r3r4r8r;r9 norm_distrrrnormalized_distances/ r@c Csz|}tt|s t|rdS|dur||}||}t||\}}|p%d}t|||d}d|}|dus9||kr;|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 gNr1r:r>r)rrrr@) r r rr2r3r4r8r?norm_simrrrnormalized_similaritysGrBcCs&|s t|ggfSdt|>d}d}t|}dt|d>}i}|j}d}|D]} || d|B|| <|dK}q(g} g} |D]O} || d} | }||@||A|B|B}|||BB}||@}|||@dk7}|||@dk8}|d>dB}|d>}|||BB}||@}| || |q>|| | fSr")r r#append)r r r$r%r&r'r(r)r r* matrix_VP matrix_VNrr+r,r-r.r/rrr_matrixvs:      rFr2r4cCs"|}|dur||}||}t||\}}t||\}}||t||}||t||}t||\}}} tgdd} t|||| _t|||| _|dkrV| Sdg|} t|} t|} | dkr| dkr|| dd| d>@r|d8}| d8} td| || || |<n?| d8} | r| | dd| d>@r|d8}td| || || |<n| d8} || || kr|d8}td| || || |<| dkr| dksk| dkr|d8}| d8} td| || || |<| dks| dkr |d8}| d8} td| || || |<| dks| | _| 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 rFr _src_len _dest_lenr_editops)r r r2r4r8 prefix_len suffix_lenr9r$r%editops editop_listcolrowrrrrMsV/   rMcCst||||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) rG)rM as_opcodes)r r r2r4rrropcodess5rR) __future__rrapidfuzz._common_pyrrrapidfuzz._utilsrrrapidfuzz.distancerr6!rapidfuzz.distance._initialize_pyrr rr!r0r7r=r@rBrFrMrRrrrrsF  ( V A D W- k