U -e0@s*ddlmZddlmZmZmZddlmZmZddl m Z ddl m Z m Z mZdddddd d d d d dZd'dddd d dddZdddddd d d d ddZdddddd ddd ddZdddddd ddd ddZddddddZddddd d d!d"d#Zddddd d$d!d%d&ZdS)() annotations)CallableHashableSequence) common_affixconv_sequences)is_none)EditopEditopsOpcodesN) processor score_cutoffzSequence[Hashable]z(Callable[..., Sequence[Hashable]] | Nonez int | Noneint)s1s2r r returnc Cs|dk r||}||}|s dSt||\}}dt|>d}i}|j}d}|D]}||d|B||<|dK}qP|D]&} || d} || @} || || B}qtt|t| dd} |dks| |kr| SdS)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) rrr r Sblock block_getxch1ch2Matchesuresr!]/var/www/html/Darija-Ai-Train/env/lib/python3.8/site-packages/rapidfuzz/distance/LCSseq_py.py similarity s&  r#zdict[Hashable, int])rrrr rc Cs~|sdSdt|>d}|j}|D]&}||d}||@}||||B}q"t|t| dd} |dksv| |krz| SdSNrrr)rrrr) rrrr rrrrrr r!r!r"_block_similarityEs r%cCsf|dk r||}||}t||\}}tt|t|}t||}||}|dksZ||kr^|S|dS)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 maximumsimdistr!r!r"distance[s/ r*z float | NonefloatcCs~t|st|rdS|dk r,||}||}|r4|s8dSt||\}}tt|t|}t|||}|dksv||krz|SdS)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)rrr&rr*)rrr r r'norm_simr!r!r"normalized_distancesr.cCsRt|st|rdS|dk r,||}||}dt||}|dksJ||krN|SdS)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)rr.)rrr r r-r!r!r"normalized_similaritys2r/z ([int], int))rrrc Cs|s dgfSdt|>d}i}|j}d}|D]}||d|B||<|dK}q.g}|D]0}||d} || @} || || B}||qVt|t| dd} | |fSr$)rrappendrr) rrrrrrrmatrixrrrr(r!r!r"_matrixs"   r2r r )rrr rc Cs|dk r||}||}t||\}}t||\}}||t||}||t||}t||\}}tgdd}t||||_t||||_t|t|d|}|dkr|Sdg|} t|} t|} | dkr| dkr|| dd| d>@r0|d8}| d8} td| || || |<q| d8} | rz|| dd| d>@sz|d8}td| || || |<q| d8} q| dkr|d8}| d8} td| || || |<q| dkr|d8}| d8} td| || || |<q| |_|S)uc 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 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] Nrrdeleteinsert) rrrr2r Z_src_lenZ _dest_lenr Z_editops) rrr prefix_lenZ suffix_lenr(r1editopsr)Z editop_listcolrowr!r!r"r8sJ,      r8r cCst|||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. 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 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) r3)r8Z as_opcodes)rrr r!r!r"opcodesys2r;)N) __future__rtypingrrrZrapidfuzz._common_pyrrZrapidfuzz._utilsrZ!rapidfuzz.distance._initialize_pyr r r r#r%r*r.r/r2r8r;r!r!r!r"s.  <>3=d