Ni F%SrSSKJr SrS\S'SrS\S'SrS\S 'SS KJs J r SS K Js J r SS KJs Jr SS KJs Jr SS KJs Jr SS KJr SS KJr SS KJrJrJrJ r J!r!J"r" /SQr#SS S S S.SjrS S S.Sjr$SS S S.Sjr%S S S.S"Sjjr&SS S S.S"Sjjr'\\l(\$\$l(\%\%l(\&\&l(\'\'l(\RRR\l)\ RTRR\$l)\ RRR\%l)\RVRR\&l)\RVRR\'l)\,"\RS5(a\RRZ\l-\,"\ RTS5(a\ RTRZ\$l-\,"\ RS5(a\ RRZ\%l-\,"\RVS5(a\RVRZ\&l-\,"\RVS5(a\RVRZ\'l-Sr.Sr/Sr0Sr1S r2S!r3g )#a A C extension module for fast computation of: - Levenshtein (edit) distance and edit sequence manipulation - string similarity - approximate median strings, and generally string averaging - string sequence and set similarity Levenshtein has a some overlap with difflib (SequenceMatcher). It supports only strings, not arbitrary sequence types, but on the other hand it's much faster. It supports both normal and Unicode strings, but can't mix them, all arguments to a function (method) have to be of the same type (or its subclasses). ) annotationsz Max Bachmannstr __author__GPL __license__z0.27.3 __version__N)Editops)Opcodes)medianmedian_improve quickmedianseqratio setmediansetratio)r r r rrrdistanceratiohammingjaro jaro_winklereditopsopcodesmatching_blocks apply_edit subtract_editinverse)rrweights processor score_cutoff score_hintc 4[R"UUUUUUS9$)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 Levenshtein import distance >>> distance("lewenstein", "levenshtein") 2 Setting a maximum distance allows the implementation to select a more efficient implementation: >>> distance("lewenstein", "levenshtein", score_cutoff=1) 2 It is possible to select different weights by passing a `weight` tuple. >>> distance("lewenstein", "levenshtein", weights=(1,1,2)) 3 r) _Levenshteinr)s1s2rrr r!s S/var/www/html/land-tabula/venv/lib/python3.13/site-packages/Levenshtein/__init__.pyrrAs*t    !  rr c,[R"XX#S9$)aD Calculates a normalized indel similarity in the range [0, 1]. The indel distance calculates the minimum number of insertions and deletions required to change one sequence into the other. This is calculated as ``1 - (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_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 Levenshtein import ratio >>> ratio("lewenstein", "levenshtein") 0.85714285714285 Setting a score_cutoff allows the implementation to select a more efficient implementation: >>> ratio("lewenstein", "levenshtein", score_cutoff=0.9) 0.0 When a different processor is used s1 and s2 do not have to be strings >>> ratio(["lewenstein"], ["levenshtein"], processor=lambda s: s[0]) 0.8571428571428572 r()_Indelnormalized_similarityr$r%rr s r&rrs\  ' ') __r'Tpadrr c.[R"XX#US9$)aK Calculates the Hamming distance between two strings. The hamming distance is defined as the number of positions where the two strings differ. It describes the minimum amount of substitutions required to transform s1 into s2. Parameters ---------- s1 : Sequence[Hashable] First string to compare. s2 : Sequence[Hashable] Second string to compare. pad : bool, optional should strings be padded if there is a length difference. If pad is False and strings have a different length a ValueError is thrown instead. Default is True. 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 or None, 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 Raises ------ ValueError If s1 and s2 have a different length r-)_Hammingr)r$r%r.rr s r&rrsH   RP\ ]]r'c,[R"XX#S9$)a Calculates the jaro 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 1.0. For ratio < score_cutoff 0 is returned instead. Default is None, which deactivates this behaviour. Returns ------- similarity : float similarity between s1 and s2 as a float between 0 and 1.0 r()_Jaro similarityr,s r&rrs.   Bi SSr'g? prefix_weightrr c2[R"UUUUUS9$)aO Calculates the jaro winkler similarity Parameters ---------- s1 : Sequence[Hashable] First string to compare. s2 : Sequence[Hashable] Second string to compare. prefix_weight : float, optional Weight used for the common prefix of the two strings. Has to be between 0 and 0.25. Default is 0.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 ratio < score_cutoff 0 is returned instead. Default is None, which deactivates this behaviour. Returns ------- similarity : float similarity between s1 and s2 as a float between 0 and 1.0 Raises ------ ValueError If prefix_weight is invalid r4) _JaroWinklerr3)r$r%r5rr s r&rrs&>  " "  #!  r' _RF_Scorerc6[U5S:XacUupn[U[5(aUO [U5n[U[5(aUO [U5n[XU5R 5$Uup[ R "X5R 5$)ak Find sequence of edit operations transforming one string to another. editops(source_string, destination_string) editops(edit_operations, source_length, destination_length) The result is a list of triples (operation, spos, dpos), where operation is one of 'equal', 'replace', 'insert', or 'delete'; spos and dpos are position of characters in the first (source) and the second (destination) strings. These are operations on single characters. In fact the returned list doesn't contain the 'equal', but all the related functions accept both lists with and without 'equal's. Examples -------- >>> editops('spam', 'park') [('delete', 0, 0), ('insert', 3, 2), ('replace', 3, 3)] The alternate form editops(opcodes, source_string, destination_string) can be used for conversion from opcodes (5-tuples) to editops (you can pass strings or their lengths, it doesn't matter). )len isinstanceint_Editopsas_listr#rargsarg1arg2arg3len1len2s r&rr:s2 4yA~D!$,,t#d)!$,,t#d)D)1133JD    + 3 3 55r'c6[U5S:XacUupn[U[5(aUO [U5n[U[5(aUO [U5n[XU5R 5$Uup[ R "X5R 5$)a Find sequence of edit operations transforming one string to another. opcodes(source_string, destination_string) opcodes(edit_operations, source_length, destination_length) The result is a list of 5-tuples with the same meaning as in SequenceMatcher's get_opcodes() output. But since the algorithms differ, the actual sequences from Levenshtein and SequenceMatcher may differ too. Examples -------- >>> for x in opcodes('spam', 'park'): ... print(x) ... ('delete', 0, 1, 0, 0) ('equal', 1, 3, 0, 2) ('insert', 3, 3, 2, 3) ('replace', 3, 4, 3, 4) The alternate form opcodes(editops, source_string, destination_string) can be used for conversion from editops (triples) to opcodes (you can pass strings or their lengths, it doesn't matter). r:)r;r<r=_Opcodesr?r#rr@s r&rr^s6 4yA~D!$,,t#d)!$,,t#d)D)1133JD    + 3 3 55r'c$[U[5(aUO [U5n[U[5(aUO [U5nU(a[US5S:Xa[XU5R 5$[ XU5R 5$)a Find identical blocks in two strings. Parameters ---------- edit_operations : list[] editops or opcodes created for the source and destination string source_string : str | int source string or the length of the source string destination_string : str | int destination string or the length of the destination string Returns ------- matching_blocks : list[] List of triples with the same meaning as in SequenceMatcher's get_matching_blocks() output. Examples -------- >>> a, b = 'spam', 'park' >>> matching_blocks(editops(a, b), a, b) [(1, 0, 2), (4, 4, 0)] >>> matching_blocks(editops(a, b), len(a), len(b)) [(1, 0, 2), (4, 4, 0)] The last zero-length block is not an error, but it's there for compatibility with difflib which always emits it. One can join the matching blocks to get two identical strings: >>> a, b = 'dog kennels', 'mattresses' >>> mb = matching_blocks(editops(a,b), a, b) >>> ''.join([a[x[0]:x[0]+x[2]] for x in mb]) 'ees' >>> ''.join([b[x[1]:x[1]+x[2]] for x in mb]) 'ees' rr:)r<r=r;r>as_matching_blocksrHedit_operations source_stringdestination_stringrErFs r&rrsxN'}c::=M@RD!+,>!D!D #N`JaD c/!"45:t4GGII O4 0 C C EEr'c[U5S:XaU$[U5n[U5n[US5S:Xa[XU5RX5$[XU5RX5$)aF Apply a sequence of edit operations to a string. apply_edit(edit_operations, source_string, destination_string) In the case of editops, the sequence can be arbitrary ordered subset of the edit sequence transforming source_string to destination_string. Examples -------- >>> e = editops('man', 'scotsman') >>> apply_edit(e, 'man', 'scotsman') 'scotsman' >>> apply_edit(e[:3], 'man', 'scotsman') 'scoman' The other form of edit operations, opcodes, is not very suitable for such a tricks, because it has to always span over complete strings, subsets can be created by carefully replacing blocks with 'equal' blocks, or by enlarging 'equal' block at the expense of other blocks and adjusting the other blocks accordingly. >>> a, b = 'spam and eggs', 'foo and bar' >>> e = opcodes(a, b) >>> apply_edit(inverse(e), b, a) 'spam and eggs' rr:)r;r>applyrHrKs r&rrsn8 ?q  } D ! "D ?1 !#t4::=]] O4 0 6 6} YYr'clSn[XU5R[XU55R5$)a| Subtract an edit subsequence from a sequence. subtract_edit(edit_operations, subsequence) The result is equivalent to editops(apply_edit(subsequence, s1, s2), s2), except that is constructed directly from the edit operations. That is, if you apply it to the result of subsequence application, you get the same final string as from application complete edit_operations. It may be not identical, though (in amibuous cases, like insertion of a character next to the same character). The subtracted subsequence must be an ordered subset of edit_operations. Note this function does not accept difflib-style opcodes as no one in his right mind wants to create subsequences from them. Examples -------- >>> e = editops('man', 'scotsman') >>> e1 = e[:3] >>> bastard = apply_edit(e1, 'man', 'scotsman') >>> bastard 'scoman' >>> apply_edit(subtract_edit(e, e1), bastard, 'scotsman') 'scotsman' l)r>remove_subsequencer?)rL subsequencestr_lens r&rrs1<G73  H[7C D r'c4[U5S:Xa/$[US5S:Xa>USSS-nUSSS-n[XU5R5R5$USSnUSSn[ XU5R5R5$)a3 Invert the sense of an edit operation sequence. In other words, it returns a list of edit operations transforming the second (destination) string to the first (source). It can be used with both editops and opcodes. Parameters ---------- edit_operations : list[] edit operations to invert Returns ------- edit_operations : list[] inverted edit operations Examples -------- >>> editops('spam', 'park') [('delete', 0, 0), ('insert', 3, 2), ('replace', 3, 3)] >>> inverse(editops('spam', 'park')) [('insert', 0, 0), ('delete', 2, 3), ('replace', 3, 3)] rr:r)r;r>rr?rH)rLrErFs r&rrs2 ?q   ?1 !#r"1%)r"1%)t4<<>FFHH 2 q !D 2 q !D O4 0 8 8 : B B DDr')returnfloat)4__doc__ __future__rr__annotations__rrrapidfuzz.distance.HammingrHammingr0rapidfuzz.distance.IndelIndelr*rapidfuzz.distance.JaroJaror2rapidfuzz.distance.JaroWinkler JaroWinklerr7rapidfuzz.distance.Levenshtein Levenshteinr#rapidfuzz.distancer r>r rHLevenshtein.levenshtein_cppr r r rrr__all__rrrr_RF_OriginalScorer _RF_ScorerPyr+r3hasattrr8rrrrrrr'r&ros) # C  S S--))''5555 *!*TY]AH $$.`b 4d$^N#T4+.D%V' $". $--::11>>((55$$11(33@@  < ,//&//::H 6 ' '6633>>E 8  l++!**55G 5  \**&&11DO < " "L11*55@@L!6H#6L-F`%ZP#L$Er'