9i*ddlmZddlmZmZmZddlmZddlm Z ddl m Z m Z ddl mZddl mZddl mZdd l mZd d d  dd Z d dd Zd d d  ddZd d d  ddZ d ddZd d d  ddZ d ddZd d ddZd d ddZy )) annotations)CallableHashableSequence)conv_sequences)is_none)EditopsOpcodes)_block_similarity)editops)opcodes) similarityN) processor score_cutoffc|||}||}t||\}}t|t|z}t||}|d|zz }|||kr|S|dzS)a Calculates the minimum number of insertions and deletions required to change one sequence into the other. This is equivalent to the Levenshtein distance with a substitution weight of 2. 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 : 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. Returns ------- distance : int distance between s1 and s2 Examples -------- Find the Indel distance between two strings: >>> from rapidfuzz.distance import Indel >>> Indel.distance("lewenstein", "levenshtein") 3 Setting a maximum distance allows the implementation to select a more efficient implementation: >>> Indel.distance("lewenstein", "levenshtein", score_cutoff=1) 2 )rlenlcs_seq_similarity)s1s2rrmaximumlcs_simdists e/var/www/html/backtest/airagagent/rag_env/lib/python3.12/site-packages/rapidfuzz/distance/Indel_py.pydistancersv^ r] r] B #FB"gBG R(G Q[ D (DL,@4W|VWGWWcvt|t|z}t|||}|d|zz }|||kr|S|dzS)Nrr)rlcs_seq_block_similarity)blockrrrrrrs r_block_distancer!KsO "gBG&ub"5G Q[ D (DL,@4W|VWGWWrc|||}||}t||\}}t|t|z}t||}||z }|||k\r|SdS)a Calculates the Indel similarity in the range [max, 0]. This is calculated as ``(len1 + len2) - 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 : 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. Returns ------- similarity : int similarity between s1 and s2 r)rrr)rrrrrrsims rrrWsk@ r] r] B #FB"gBG B D D.C'3,+>3FQFrct|s t|ry|||}||}t||\}}t|t|z}t||}|r||z nd}|||kr|SdS)a8 Calculates a normalized levenshtein similarity in the range [1, 0]. This is calculated as ``distance / (len1 + len2)``. 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 1.0. For norm_dist > score_cutoff 1.0 is returned instead. Default is 1.0, which deactivates this behaviour. Returns ------- norm_dist : float normalized distance between s1 and s2 as a float between 0 and 1.0 ?rr)rrrr)rrrrrr norm_dists rnormalized_distancer's>r{gbk r] r] B #FB"gBG B D")wqI%-l1J9RQRRrcrt|t|z}t|||}|r||z nd}|||kr|SdS)Nrr)rr!)r rrrrrr&s r_block_normalized_distancer)sI "gBG 5"b )D")wqI%-l1J9RQRRrct|s t|ry|||}||}t||\}}t||}d|z }|||k\r|SdS)a Calculates a normalized indel similarity in the range [0, 1]. This is calculated as ``1 - normalized_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 1.0. For norm_sim < score_cutoff 0 is returned instead. Default is 0, which deactivates this behaviour. Returns ------- norm_sim : float normalized similarity between s1 and s2 as a float between 0 and 1.0 Examples -------- Find the normalized Indel similarity between two strings: >>> from rapidfuzz.distance import Indel >>> Indel.normalized_similarity("lewenstein", "levenshtein") 0.85714285714285 Setting a score_cutoff allows the implementation to select a more efficient implementation: >>> Indel.normalized_similarity("lewenstein", "levenshtein", score_cutoff=0.9) 0.0 When a different processor is used s1 and s2 do not have to be strings >>> Indel.normalized_similarity(["lewenstein"], ["levenshtein"], processor=lambda s: s[0]) 0.8571428571428572 gr%r)rrr')rrrrr&norm_sims rnormalized_similarityr,sidr{gbk r] r] B #FB#B+IYH$,L0H8PqPrc<t|||}d|z }|||k\r|SdS)Nr%r)r))r rrrr&r+s r_block_normalized_similarityr.s2 +5"b9IYH$,L0H8PqPrrct|||S)ua 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. 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 [6]_. It has a time complexity and memory usage of ``O([N/64] * M)``. References ---------- .. [6] Hyyrö, Heikki. "A Note on Bit-Parallel Alignment Computation." Stringology (2004). Examples -------- >>> from rapidfuzz.distance import Indel >>> for tag, src_pos, dest_pos in Indel.editops("qabxcd", "abycdf"): ... print(("%7s s1[%d] s2[%d]" % (tag, src_pos, dest_pos))) delete s1[0] s2[0] delete s1[3] s2[2] insert s1[4] s2[2] insert s1[6] s2[5] r/)lcs_seq_editopsrrrs rr r sX 2rY 77rct|||S)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. 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 [7]_. It has a time complexity and memory usage of ``O([N/64] * M)``. References ---------- .. [7] Hyyrö, Heikki. "A Note on Bit-Parallel Alignment Computation." Stringology (2004). Examples -------- >>> from rapidfuzz.distance import Indel >>> a = "qabxcd" >>> b = "abycdf" >>> for tag, i1, i2, j1, j2 in Indel.opcodes(a, b): ... 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) delete a[3:4] (x) b[2:2] () insert a[4:4] () b[2:3] (y) equal a[4:6] (cd) b[3:5] (cd) insert a[6:6] () b[5:6] (f) r/)lcs_seq_opcodesr2s rr r 4sd 2rY 77r) rSequence[Hashable]rr5r(Callable[..., Sequence[Hashable]] | Noner int | Nonereturnint)N) r dict[Hashable, int]rr5rr5rr7r8r9) rr5rr5rr6r float | Noner8float) r r:rr5rr5rr;r8r<)rr5rr5rr6r8r )rr5rr5rr6r8r ) __future__rtypingrrrrapidfuzz._common_pyrrapidfuzz._utilsr!rapidfuzz.distance._initialize_pyr r rapidfuzz.distance.LCSseq_pyr rr r1r r4rrrr!r'r)r,r.rrrDsD#///$>VCCI;?# 7X7X7X8 7X  7X  7X| $ X  X X  X X  X ;?# (G(G(G8 (G  (G  (G^;?!% *S*S*S8 *S  *S  *Sb"& S  S S  S S  S ;?!% <Q<Q<Q8 <Q  <Q  <QF"& Q QQ Q Q  Q;? ,8,8,88 ,8  ,8f;? 2828288 28  28r