Ng,ddlmZddlmZmZddlmZmZddlm Z m Z ddddZ ddZ dddd Z dddd Zdddd Zd Zdd dZdd dZdS)) annotations) common_affixconv_sequences)is_none setupPandas)EditopEditopsN) processor score_cutoffc|||}||}|sdSt||\}}dt|zdz }i}|j}d}|D]}||d|z||<|dz}|D]} || d} || z} || z|| z z}t|t| dd} || |kr| ndS)a Calculates the length of the longest common subsequence 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 Nr0)rlengetbincount) s1s2r r Sblock block_getxch1ch2Matchesuress X/var/www/html/ai-engine/env/lib/python3.11/site-packages/rapidfuzz/distance/LCSseq_py.py similarityr s< Yr]] Yr]] q B # #FB c"ggA E I AYsA&&*c  a)C## K Uq1u  a&&#b''  " "3 ' 'C'3,+>+>33QFc |sdSdt|zdz }|j}|D]}||d}||z}||z||z z}t|t| dd} || |kr| ndSNrr r)rrrr) rrrr rrrrrrs r_block_similarityr#Bs q c"ggA I)C## K Uq1u  a&&#b''  " "3 ' 'C'3,+>+>33QFr c|||}||}t||\}}tt|t|}t||}||z }|||kr|n|dzS)a Calculates the LCS distance in the range [0, max]. This is calculated as ``max(len1, len2) - 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 : 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 LCS distance between two strings: >>> from rapidfuzz.distance import LCSseq >>> LCSseq.distance("lewenstein", "levenshtein") 2 Setting a maximum distance allows the implementation to select a more efficient implementation: >>> LCSseq.distance("lewenstein", "levenshtein", score_cutoff=1) 2 Nr )rmaxrr)rrr r maximumsimdists rdistancer)Xs^ Yr]] Yr]] B # #FB#b''3r77##G R  C S=D (DL,@,@44|VWGWWr cRtt|st|rdS|||}||}|r|sdSt||\}}tt |t |}t |||z }|||kr|ndS)a2 Calculates a normalized LCS similarity in the range [1, 0]. This is calculated as ``distance / max(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 ?Nrr )rrrr%rr))rrr r r&norm_sims rnormalized_distancer-s>MMMr{{gbkks Yr]] Yr]] Rq B # #FB#b''3r77##GB')H$,L0H0H88qPr ctt|st|rdS|||}||}dt||z }|||kr|ndS)a Calculates a normalized LCS 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 LCS similarity between two strings: >>> from rapidfuzz.distance import LCSseq >>> LCSseq.normalized_similarity("lewenstein", "levenshtein") 0.8181818181818181 Setting a score_cutoff allows the implementation to select a more efficient implementation: >>> LCSseq.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 >>> LCSseq.normalized_similarity(["lewenstein"], ["levenshtein"], processor=lambda s: s[0]) 0.81818181818181 gNr+r)rrr-)rrr r r,s rnormalized_similarityr/s|dMMMr{{gbkks Yr]] Yr]](R000H$,L0H0H88qPr cn|sdgfSdt|zdz }i}|j}d}|D]}||d|z||<|dz}g}|D]3}||d} || z} || z|| z z}||4t|t| dd} | |fSr")rrappendrr) rrrrrrrmatrixrrrr's r_matrixr3s 2w c"ggA E I AYsA&&*c  a F)C## K Uq1u  a a&&#b''  " "3 ' 'C =r r c,|||}||}t||\}}t||\}}||t||z }||t||z }t||\}}t gdd}t||z|z|_t||z|z|_t|t|zd|zz }|dkr|Sdg|z} t|} t|} | dkr| dkr|| dz d| dz zzr%|dz}| dz} td| |z| |z| |<n@| dz} | r4|| dz d| dz zzs |dz}td| |z| |z| |<n| dz} | dkr| dk| dkr*|dz}| dz} td| |z| |z| |<| dk*| dkr*|dz}| dz} td| |z| |z| |<| dk*| |_|S)uf 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 in [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 LCSseq >>> for tag, src_pos, dest_pos in LCSseq.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] Nrr deleteinsert) rrrr3r _src_len _dest_lenr_editops) rrr prefix_len suffix_lenr'r2editopsr( editop_listcolrows rr>r>sX Yr]] Yr]] B # #FB)"b11J JR:- - .B JR:- - .B"b//KCb!QG2ww+j8GB*,z9G r77SWW q3w &D qyy&4-K b''C b''C ((saxx #'?aC!Gn -  AID 1HC &xz1A3CS T TK   1HC F37OqS1W~>  $*8S:5EsZGW$X$X D!!q ((saxx" ((   q"8S:-=sZ?OPP D (( ((   q"8S:-=sZ?OPP D (( #G Nr cJt|||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 in [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 LCSseq >>> a = "qabxcd" >>> b = "abycdf" >>> for tag, i1, i2, j1, j2 in LCSseq.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) r4)r> as_opcodes)rrr s ropcodesrDxs&d 2rY / / / : : < <rDr rrJsu#"""""========11111111======== 5G5G5G5G5Gx GGGG4 7X7X7X7X7X| -Q-Q-Q-Q-Qh ;Q;Q;Q;Q;Q|8 ]]]]]H 2=2=2=2=2=2=2=r