k*idSSKJr SSKJr SSKJr SSKJrJrJ r J r SSK J r SSK JrJrJr SrS\0rS rS rS rS S S .SjrSrS S S .SjrS S S .SjrS S S .SjrS S S .SjrS S S .SjrS S S .Sjr S S S .Sjr!S S S .Sjr"S S S .Sjr#S S S .Sjr$\"\\5 \"\\5 \"\\5 \"\\5 \"\\5 \"\ \5 \"\!\5 \"\"\5 \"\#\5 \"\$\5 g )) annotations)ceil)conv_sequences) ScorerFlagadd_scorer_attrsis_none setupPandas)ScoreAlignment)_block_normalized_similaritydistancenormalized_similarityc LSS[R[R-S.$)Ndr) optimal_score worst_scoreflags)r RESULT_F64 SYMMETRIC)_kwargss Q/var/www/html/land-doc-ocr/venv/lib/python3.13/site-packages/rapidfuzz/fuzz_py.pyget_scorer_flags_fuzzrs&&&)=)== get_scorer_flagsc<U(a SSU-U- - OSnX2:aU$S$)Nrr)distlensum score_cutoffscores r_norm_distancer s)+1S3:& &sE)50q0rc~[U[[45(aUR5$//nUHan[U[5(aUO [ U5nUR 5(aUR /5 MMUSR U5 Mc UVs/sHo"(dM [U5PM sn$s snf)N) isinstancestrbytessplitchrisspaceappendtuple)seq splitted_seqxchs r_split_sequencer/!s#U|$$yy{4L Q$$Q#a& ::<<    #   # #A & + 0laHE!Hl 00 0s  B:(B:c8U(dg[[[U55[5(aSR U5$[[[U55[ 5(aSR U5$/nUHnX- nU[ S5/- nM USS$)N  r")r#nextiterr$joinr%ord)seq_listjoinedr+s r_join_splitted_sequencer:0s $tH~&,,xx!!$tH~&..yy"" F 3s8* #2;rN processorrc[5 [U5(d[U5(agUbUS-n[XX#S9nUS-$)aj Calculates the normalized Indel 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 : float, optional Optional argument for a score threshold as a float between 0 and 100. For ratio < score_cutoff 0 is returned instead. Default is 0, which deactivates this behaviour. Returns ------- similarity : float similarity between s1 and s2 as a float between 0 and 100 See Also -------- rapidfuzz.distance.Indel.normalized_similarity : Normalized Indel similarity Notes ----- .. image:: img/ratio.svg Examples -------- >>> fuzz.ratio("this is a test", "this is a test!") 96.55171966552734 rrr;)r rindel_normalized_similarity)s1s2r<rrs rratiorA?sDTMr{{gbkk ') _E 3;rc [U5n[U5n[U5n[SSUSU5n0nURnSn UHn U"U S5U -Xz'U S-n M [ SU5Han XS- n X;aM[ XpUSU US9n XR :dM0U =UlnSUlXlUR S:XdMXSUlUs $ [ XT- 5Hgn XU-S- n X;aM[ XpXX-US9n XR :dM4U =UlnXlX-UlUR S:XdM^SUlUs $ [ XT- U5H\n XnX;aM[ XpXSUS9n XR :dM,U =UlnXlXVlUR S:XdMSSUlUs $ U=R S-slU$)zC implementation of partial_ratio. This assumes len(s1) <= len(s2). rNrr) setlenr getrange!indel_block_normalized_similarityr dest_startdest_end)r?r@r s1_char_setlen1len2resblock block_getr-ch1i substr_lastls_ratio substr_firsts r_partial_ratio_implrWtsb'K r7D r7D AtQ -C E I AsA&*  a1d^Qi  ) 5U2AUab ii '/ /CI CNLyyA~  4; TA&  ) 5Uqx@P_kl ii '/ /CI N8CLyyA~   4; %u  * 5U2Uab ii '/ /CI NLyyA~  &III Jrc6[XX#S9nUcgUR$)u% Searches for the optimal alignment of the shorter string in the longer string and returns the fuzz.ratio for this alignment. 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 100. For ratio < score_cutoff 0 is returned instead. Default is 0, which deactivates this behaviour. Returns ------- similarity : float similarity between s1 and s2 as a float between 0 and 100 Notes ----- Depending on the length of the needle (shorter string) different implementations are used to improve the performance. short needle (length ≤ 64): When using a short needle length the fuzz.ratio is calculated for all alignments that could result in an optimal alignment. It is guaranteed to find the optimal alignment. For short needles this is very fast, since for them fuzz.ratio runs in ``O(N)`` time. This results in a worst case performance of ``O(NM)``. .. image:: img/partial_ratio_short_needle.svg long needle (length > 64): For long needles a similar implementation to FuzzyWuzzy is used. This implementation only considers alignments which start at one of the longest common substrings. This results in a worst case performance of ``O(N[N/64]M)``. However usually most of the alignments can be skipped. The following Python code shows the concept: .. code-block:: python blocks = SequenceMatcher(None, needle, longer, False).get_matching_blocks() score = 0 for block in blocks: long_start = block[1] - block[0] if (block[1] - block[0]) > 0 else 0 long_end = long_start + len(shorter) long_substr = longer[long_start:long_end] score = max(score, fuzz.ratio(needle, long_substr)) This is a lot faster than checking all possible alignments. However it only finds one of the best alignments and not necessarily the optimal one. .. image:: img/partial_ratio_long_needle.svg Examples -------- >>> fuzz.partial_ratio("this is a test", "this is a test!") 100.0 r;r)partial_ratio_alignmentr)r?r@r<r alignments r partial_ratior[s$N()_I ??rc[5 [U5(d[U5(agUbU"U5nU"U5nUcSnU(dU(d[SSSSS5$[X5up[ U5n[ U5nXE::aUnUnOUnUn[ XgUS- 5nUR S:waXE:Xa[X8R 5n[ XvUS- 5n U R UR :aA[U R U RU RU RU R5nUR U:agXE::aU$[UR URURURUR5$)a Searches for the optimal alignment of the shorter string in the longer string and returns the fuzz.ratio and the corresponding alignment. Parameters ---------- s1 : str | bytes First string to compare. s2 : str | bytes 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 100. For ratio < score_cutoff None is returned instead. Default is 0, which deactivates this behaviour. Returns ------- alignment : ScoreAlignment, optional alignment between s1 and s2 with the score as a float between 0 and 100 Examples -------- >>> s1 = "a certain string" >>> s2 = "cetain" >>> res = fuzz.partial_ratio_alignment(s1, s2) >>> res ScoreAlignment(score=83.33333333333334, src_start=2, src_end=8, dest_start=0, dest_end=6) Using the alignment information it is possible to calculate the same fuzz.ratio >>> fuzz.ratio(s1[res.src_start:res.src_end], s2[res.dest_start:res.dest_end]) 83.33333333333334 NrgY@r) r rr rrFrWrmaxrJrK src_startsrc_end) r?r@r<rrMrNshorterlongerrOres2s rrYrYsLXMr{{gbkk r] r] beQ1a00 B #FB r7D r7D | g|c/A BC yyCDL<3 "6L34FG :: ! T__dmmT^^]a]i]ijC yy< | #))S^^S\\3==RUR]R] ^^rc [5 [U5(d[U5(agUbU"U5nU"U5n[X5up[[ [ U555n[[ [ U555n[ XEUS9$)a# Sorts the words in the strings and calculates the fuzz.ratio between them Parameters ---------- s1 : str First string to compare. s2 : str 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 100. For ratio < score_cutoff 0 is returned instead. Default is 0, which deactivates this behaviour. Returns ------- similarity : float similarity between s1 and s2 as a float between 0 and 100 Notes ----- .. image:: img/token_sort_ratio.svg Examples -------- >>> fuzz.token_sort_ratio("fuzzy wuzzy was a bear", "wuzzy fuzzy was a bear") 100.0 rrD)r rrr:sortedr/rAr?r@r<r sorted_s1 sorted_s2s rtoken_sort_ratiorhWswLMr{{gbkk r] r] B #FB'r/B(CDI'r/B(CDI L AArcd[5 [U5(d[U5(agUbU"U5nU"U5nUcSn[X5up[[ U55n[[ U55nU(aU(dgUR U5nUR U5nUR U5nU(aU(aU(dg[[U55n [[U55n [U 5n [U 5n [[U55n XS:g-U -nXS:g-U -nSn[X-SUS- - -5n[XUS9nUU::a[UX-U5nU (dU$U S:gU -n[UX-U5nU S:gU -n[UX-U5n[UUU5$)a Compares the words in the strings based on unique and common words between them using fuzz.ratio Parameters ---------- s1 : str First string to compare. s2 : str 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 100. For ratio < score_cutoff 0 is returned instead. Default is 0, which deactivates this behaviour. Returns ------- similarity : float similarity between s1 and s2 as a float between 0 and 100 Notes ----- .. image:: img/token_set_ratio.svg Examples -------- >>> fuzz.token_sort_ratio("fuzzy was a bear", "fuzzy fuzzy was a bear") 83.8709716796875 >>> fuzz.token_set_ratio("fuzzy was a bear", "fuzzy fuzzy was a bear") 100.0 # Returns 100.0 if one string is a subset of the other, regardless of extra content in the longer string >>> fuzz.token_set_ratio("fuzzy was a bear but not a dog", "fuzzy was a bear") 100.0 # Score is reduced only when there is explicit disagreement in the two strings >>> fuzz.token_set_ratio("fuzzy was a bear but not a dog", "fuzzy was a bear but not a cat") 92.3076923076923 rrgrCrD)r rrrEr/ intersection differencer:rdrFrindel_distancer r])r?r@r<rtokens_atokens_b intersectdiff_abdiff_badiff_ab_joineddiff_ba_joinedab_lenba_lensect_len sect_ab_len sect_ba_lenresultcutoff_distancer sect_ab_dist sect_ab_ratio sect_ba_dist sect_ba_ratios rtoken_set_ratiors^Mr{{gbkk r] r] B #FB?2&'H?2&'H 8%%h/I!!(+G!!(+G',VG_=N,VG_=N  F  F*956H!m,v5K!m,v5K FK5!lS>P:PQRO . WD k&?N  MV+L"<1GVMMV+L"<1GVM v}m 44rc [5 [U5(d[U5(agUbU"U5nU"U5n[[XSUS9[ XSUS95$)a Helper method that returns the maximum of fuzz.token_set_ratio and fuzz.token_sort_ratio (faster than manually executing the two functions) Parameters ---------- s1 : str First string to compare. s2 : str 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 100. For ratio < score_cutoff 0 is returned instead. Default is 0, which deactivates this behaviour. Returns ------- similarity : float similarity between s1 and s2 as a float between 0 and 100 Notes ----- .. image:: img/token_ratio.svg rNr;)r rr]rrhr?r@r<rs r token_ratiors]DMr{{gbkk r] r] $\J4lK rc [5 [U5(d[U5(agUbU"U5nU"U5n[X5up[[ [ U555n[[ [ U555n[ XEUS9$)a sorts the words in the strings and calculates the fuzz.partial_ratio between them Parameters ---------- s1 : str First string to compare. s2 : str 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 100. For ratio < score_cutoff 0 is returned instead. Default is 0, which deactivates this behaviour. Returns ------- similarity : float similarity between s1 and s2 as a float between 0 and 100 Notes ----- .. image:: img/partial_token_sort_ratio.svg rrD)r rrr:rdr/r[res rpartial_token_sort_ratior+swBMr{{gbkk r] r] B #FB'r/B(CDI'r/B(CDI L IIrc[5 [U5(d[U5(agUbU"U5nU"U5n[X5up[[ U55n[[ U55nU(aU(dgUR U5(ag[ [URU555n[ [URU555n[XgUS9$)a Compares the words in the strings based on unique and common words between them using fuzz.partial_ratio Parameters ---------- s1 : str First string to compare. s2 : str 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 100. For ratio < score_cutoff 0 is returned instead. Default is 0, which deactivates this behaviour. Returns ------- similarity : float similarity between s1 and s2 as a float between 0 and 100 Notes ----- .. image:: img/partial_token_set_ratio.svg rrrD) r rrrEr/rjr:rdrkr[)r?r@r<rrmrnrprqs rpartial_token_set_ratiorZsDMr{{gbkk r] r] B #FB?2&'H?2&'H 8X&&%fX-@-@-J&KLG%fX-@-@-J&KLG  EErc [5 [U5(d[U5(agUbU"U5nU"U5nUcSn[X5up[U5n[U5n[ U5n[ U5nUR U5(agUR U5nUR U5n [[[U55[[U55US9n [U5[U5:Xa[U5[U 5:XaU $[X:5n[U [[[U55[[U 55US95$)a Helper method that returns the maximum of fuzz.partial_token_set_ratio and fuzz.partial_token_sort_ratio (faster than manually executing the two functions) Parameters ---------- s1 : str First string to compare. s2 : str 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 100. For ratio < score_cutoff 0 is returned instead. Default is 0, which deactivates this behaviour. Returns ------- similarity : float similarity between s1 and s2 as a float between 0 and 100 Notes ----- .. image:: img/partial_token_ratio.svg rrrD) r rrr/rErjrkr[r:rdrFr]) r?r@r<rtokens_split_atokens_split_brmrnrprqrys rpartial_token_ratiors7DMr{{gbkk r] r] B #FB$R(N$R(N>"H>"HX&&!!(+G!!(+G ~ 67~ 67!F >c'l*s>/Bc'l/R |,L  #F7O 4 #F7O 4%  rc  [5 [U5(d[U5(agSnUbU"U5nU"U5nU(aU(dgUcSn[U5n[U5nXV:aXV- OXe- n[XUS9nUS:a&[ X85U- n[ U[ XUSS9U-5$US::aSOS n [ X85U - n[ U[ XUS9U -5n[ X85U- n[ U[XUSS9U-U -5$) a Calculates a weighted ratio based on the other ratio algorithms Parameters ---------- s1 : str First string to compare. s2 : str 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 100. For ratio < score_cutoff 0 is returned instead. Default is 0, which deactivates this behaviour. Returns ------- similarity : float similarity between s1 and s2 as a float between 0 and 100 Notes ----- .. image:: img/WRatio.svg rgffffff?NrDg?)rr<g @g?g333333?)r rrFrAr]rr[r) r?r@r<r UNBASE_SCALErMrN len_ratio end_ratio PARTIAL_SCALEs rWRatiors#BMr{{gbkkL r] r] R r7D r7D#{  Ib<8I3<3lB   \T J\ Y  %+CM|/-?LI}R,OR__`I|/,>L BNQ]]`mm rc[5 [U5(d[U5(agUbU"U5nU"U5nU(aU(dg[XUS9$)ao Calculates a quick ratio between two strings using fuzz.ratio. Since v3.0 this behaves similar to fuzz.ratio with the exception that this returns 0 when comparing two empty strings 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 100. For ratio < score_cutoff 0 is returned instead. Default is 0, which deactivates this behaviour. Returns ------- similarity : float similarity between s1 and s2 as a float between 0 and 100 Examples -------- >>> fuzz.QRatio("this is a test", "this is a test!") 96.55171966552734 rrD)r rrArs rQRatior0sMJMr{{gbkk r] r] R l 33r)% __future__rmathrrapidfuzz._common_pyrrapidfuzz._utilsrrrr rapidfuzz.distancer rapidfuzz.distance.Indel_pyr rIr rlr r>rfuzz_attributer r/r:rArWr[rYrhrrrrrrrrrrrsW#/OO-%&;<1 1 & 2j?L Kd P_n 1Bp l5f .j ,Jf 9F@ Mh G\ 14h'/!>2.1n-)>:(.9$n5((r