})'
class Match(tuple):
""" Match(a, b, size) """
def _asdict(self): # reliably restored by inspect
""" Return a new dict which maps field names to their values. """
pass
@classmethod
def _make(cls, *args, **kwargs): # real signature unknown
""" Make a new Match object from a sequence or iterable """
pass
def _replace(self, **kwds): # reliably restored by inspect
""" Return a new Match object replacing specified fields with new values """
pass
def __getnewargs__(self): # reliably restored by inspect
""" Return self as a plain tuple. Used by copy and pickle. """
pass
def __init__(self, a, b, size): # real signature unknown; restored from __doc__
pass
@staticmethod # known case of __new__
def __new__(_cls, a, b, size): # reliably restored by inspect
""" Create new instance of Match(a, b, size) """
pass
def __replace__(self, **kwds): # reliably restored by inspect
""" Return a new Match object replacing specified fields with new values """
pass
def __repr__(self): # reliably restored by inspect
""" Return a nicely formatted representation string """
pass
a = _tuplegetter(0, 'Alias for field number 0')
b = _tuplegetter(1, 'Alias for field number 1')
size = _tuplegetter(2, 'Alias for field number 2')
_fields = (
'a',
'b',
'size',
)
_field_defaults = {}
__match_args__ = (
'a',
'b',
'size',
)
__slots__ = ()
class SequenceMatcher(object):
"""
SequenceMatcher is a flexible class for comparing pairs of sequences of
any type, so long as the sequence elements are hashable. The basic
algorithm predates, and is a little fancier than, an algorithm
published in the late 1980's by Ratcliff and Obershelp under the
hyperbolic name "gestalt pattern matching". The basic idea is to find
the longest contiguous matching subsequence that contains no "junk"
elements (R-O doesn't address junk). The same idea is then applied
recursively to the pieces of the sequences to the left and to the right
of the matching subsequence. This does not yield minimal edit
sequences, but does tend to yield matches that "look right" to people.
SequenceMatcher tries to compute a "human-friendly diff" between two
sequences. Unlike e.g. UNIX(tm) diff, the fundamental notion is the
longest *contiguous* & junk-free matching subsequence. That's what
catches peoples' eyes. The Windows(tm) windiff has another interesting
notion, pairing up elements that appear uniquely in each sequence.
That, and the method here, appear to yield more intuitive difference
reports than does diff. This method appears to be the least vulnerable
to syncing up on blocks of "junk lines", though (like blank lines in
ordinary text files, or maybe "" lines in HTML files). That may be
because this is the only method of the 3 that has a *concept* of
"junk" .
Example, comparing two strings, and considering blanks to be "junk":
>>> s = SequenceMatcher(lambda x: x == " ",
... "private Thread currentThread;",
... "private volatile Thread currentThread;")
>>>
.ratio() returns a float in [0, 1], measuring the "similarity" of the
sequences. As a rule of thumb, a .ratio() value over 0.6 means the
sequences are close matches:
>>> print(round(s.ratio(), 3))
0.866
>>>
If you're only interested in where the sequences match,
.get_matching_blocks() is handy:
>>> for block in s.get_matching_blocks():
... print("a[%d] and b[%d] match for %d elements" % block)
a[0] and b[0] match for 8 elements
a[8] and b[17] match for 21 elements
a[29] and b[38] match for 0 elements
Note that the last tuple returned by .get_matching_blocks() is always a
dummy, (len(a), len(b), 0), and this is the only case in which the last
tuple element (number of elements matched) is 0.
If you want to know how to change the first sequence into the second,
use .get_opcodes():
>>> for opcode in s.get_opcodes():
... print("%6s a[%d:%d] b[%d:%d]" % opcode)
equal a[0:8] b[0:8]
insert a[8:8] b[8:17]
equal a[8:29] b[17:38]
See the Differ class for a fancy human-friendly file differencer, which
uses SequenceMatcher both to compare sequences of lines, and to compare
sequences of characters within similar (near-matching) lines.
See also function get_close_matches() in this module, which shows how
simple code building on SequenceMatcher can be used to do useful work.
Timing: Basic R-O is cubic time worst case and quadratic time expected
case. SequenceMatcher is quadratic time for the worst case and has
expected-case behavior dependent in a complicated way on how many
elements the sequences have in common; best case time is linear.
"""
def get_grouped_opcodes(self): # real signature unknown; restored from __doc__
"""
Isolate change clusters by eliminating ranges with no changes.
Return a generator of groups with up to n lines of context.
Each group is in the same format as returned by get_opcodes().
>>> from pprint import pprint
>>> a = list(map(str, range(1,40)))
>>> b = a[:]
>>> b[8:8] = ['i'] # Make an insertion
>>> b[20] += 'x' # Make a replacement
>>> b[23:28] = [] # Make a deletion
>>> b[30] += 'y' # Make another replacement
>>> pprint(list(SequenceMatcher(None,a,b).get_grouped_opcodes()))
[[('equal', 5, 8, 5, 8), ('insert', 8, 8, 8, 9), ('equal', 8, 11, 9, 12)],
[('equal', 16, 19, 17, 20),
('replace', 19, 20, 20, 21),
('equal', 20, 22, 21, 23),
('delete', 22, 27, 23, 23),
('equal', 27, 30, 23, 26)],
[('equal', 31, 34, 27, 30),
('replace', 34, 35, 30, 31),
('equal', 35, 38, 31, 34)]]
"""
pass
def ratio(self): # real signature unknown; restored from __doc__
"""
Return a measure of the sequences' similarity (float in [0,1]).
Where T is the total number of elements in both sequences, and
M is the number of matches, this is 2.0*M / T.
Note that this is 1 if the sequences are identical, and 0 if
they have nothing in common.
.ratio() is expensive to compute if you haven't already computed
.get_matching_blocks() or .get_opcodes(), in which case you may
want to try .quick_ratio() or .real_quick_ratio() first to get an
upper bound.
>>> s = SequenceMatcher(None, "abcd", "bcde")
>>> s.ratio()
0.75
>>> s.quick_ratio()
0.75
>>> s.real_quick_ratio()
1.0
"""
pass
def set_seq1(self, bcde): # real signature unknown; restored from __doc__
"""
Set the first sequence to be compared.
The second sequence to be compared is not changed.
>>> s = SequenceMatcher(None, "abcd", "bcde")
>>> s.ratio()
0.75
>>> s.set_seq1("bcde")
>>> s.ratio()
1.0
>>>
SequenceMatcher computes and caches detailed information about the
second sequence, so if you want to compare one sequence S against
many sequences, use .set_seq2(S) once and call .set_seq1(x)
repeatedly for each of the other sequences.
See also set_seqs() and set_seq2().
"""
pass
def set_seq2(self, abcd): # real signature unknown; restored from __doc__
"""
Set the second sequence to be compared.
The first sequence to be compared is not changed.
>>> s = SequenceMatcher(None, "abcd", "bcde")
>>> s.ratio()
0.75
>>> s.set_seq2("abcd")
>>> s.ratio()
1.0
>>>
SequenceMatcher computes and caches detailed information about the
second sequence, so if you want to compare one sequence S against
many sequences, use .set_seq2(S) once and call .set_seq1(x)
repeatedly for each of the other sequences.
See also set_seqs() and set_seq1().
"""
pass
def set_seqs(self, abcd, bcde): # real signature unknown; restored from __doc__
"""
Set the two sequences to be compared.
>>> s = SequenceMatcher()
>>> s.set_seqs("abcd", "bcde")
>>> s.ratio()
0.75
"""
pass
def _SequenceMatcher__chain_b(self, *args, **kwargs): # real signature unknown
pass
@classmethod
def __class_getitem__(cls, *args, **kwargs): # real signature unknown
"""
Represent a PEP 585 generic type
E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
"""
pass
def __init__(self, *args, **kwargs): # real signature unknown
"""
Construct a SequenceMatcher.
Optional arg isjunk is None (the default), or a one-argument
function that takes a sequence element and returns true iff the
element is junk. None is equivalent to passing "lambda x: 0", i.e.
no elements are considered to be junk. For example, pass
lambda x: x in " \t"
if you're comparing lines as sequences of characters, and don't
want to synch up on blanks or hard tabs.
Optional arg a is the first of two sequences to be compared. By
default, an empty string. The elements of a must be hashable. See
also .set_seqs() and .set_seq1().
Optional arg b is the second of two sequences to be compared. By
default, an empty string. The elements of b must be hashable. See
also .set_seqs() and .set_seq2().
Optional arg autojunk should be set to False to disable the
"automatic junk heuristic" that treats popular elements as junk
(see module documentation for more information).
"""
pass
@staticmethod # known case of __new__
def __new__(*args, **kwargs): # real signature unknown
""" Create and return a new object. See help(type) for accurate signature. """
pass
def __reduce_cython__(self, *args, **kwargs): # real signature unknown
pass
def __reduce__(self, *args, **kwargs): # real signature unknown
pass
def __setstate_cython__(self, *args, **kwargs): # real signature unknown
pass
def __setstate__(self, *args, **kwargs): # real signature unknown
pass
a = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
b = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
__pyx_vtable__ = None # (!) real value is ''
# variables with complex values
__all__ = [
'get_close_matches',
'ndiff',
'restore',
'SequenceMatcher',
'Differ',
'IS_CHARACTER_JUNK',
'IS_LINE_JUNK',
'context_diff',
'unified_diff',
'diff_bytes',
'HtmlDiff',
'Match',
]
__loader__ = None # (!) real value is '<_frozen_importlib_external.ExtensionFileLoader object at 0x000001A68CCF6B50>'
__pyx_capi__ = {
'_calculate_ratio': None, # (!) real value is ''
}
__spec__ = None # (!) real value is "ModuleSpec(name='lxml.html._difflib', loader=<_frozen_importlib_external.ExtensionFileLoader object at 0x000001A68CCF6B50>, origin='C:\\\\Programs\\\\Python\\\\Python313\\\\Lib\\\\site-packages\\\\lxml\\\\html\\\\_difflib.cp313-win_amd64.pyd')"
__test__ = {
'Differ._fancy_replace (line 913)': '\n When replacing one block of lines with another, search the blocks\n for *similar* lines; the best-matching pair (if any) is used as a\n synch point, and intraline difference marking is done on the\n similar pair. Lots of work, but often worth it.\n\n Example:\n\n >>> d = Differ()\n >>> results = d._fancy_replace([\'abcDefghiJkl\\n\'], 0, 1,\n ... [\'abcdefGhijkl\\n\'], 0, 1)\n >>> print(\'\'.join(results), end="")\n - abcDefghiJkl\n ? ^ ^ ^\n + abcdefGhijkl\n ? ^ ^ ^\n ',
'Differ._qformat (line 1017)': '\n Format "?" output and deal with tabs.\n\n Example:\n\n >>> d = Differ()\n >>> results = d._qformat(\'\\tabcDefghiJkl\\n\', \'\\tabcdefGhijkl\\n\',\n ... \' ^ ^ ^ \', \' ^ ^ ^ \')\n >>> for line in results: print(repr(line))\n ...\n \'- \\tabcDefghiJkl\\n\'\n \'? \\t ^ ^ ^\\n\'\n \'+ \\tabcdefGhijkl\\n\'\n \'? \\t ^ ^ ^\\n\'\n ',
'Differ.compare (line 853)': '\n Compare two sequences of lines; generate the resulting delta.\n\n Each sequence must contain individual single-line strings ending with\n newlines. Such sequences can be obtained from the `readlines()` method\n of file-like objects. The delta generated also consists of newline-\n terminated strings, ready to be printed as-is via the writelines()\n method of a file-like object.\n\n Example:\n\n >>> print(\'\'.join(Differ().compare(\'one\\ntwo\\nthree\\n\'.splitlines(True),\n ... \'ore\\ntree\\nemu\\n\'.splitlines(True))),\n ... end="")\n - one\n ? ^\n + ore\n ? ^\n - two\n - three\n ? -\n + tree\n + emu\n ',
'IS_CHARACTER_JUNK (line 1082)': "\n Return True for ignorable character: iff `ch` is a space or tab.\n\n Examples:\n\n >>> IS_CHARACTER_JUNK(' ')\n True\n >>> IS_CHARACTER_JUNK('\\t')\n True\n >>> IS_CHARACTER_JUNK('\\n')\n False\n >>> IS_CHARACTER_JUNK('x')\n False\n ",
'IS_LINE_JUNK (line 1061)': "\n Return True for ignorable line: if `line` is blank or contains a single '#'.\n\n Examples:\n\n >>> IS_LINE_JUNK('\\n')\n True\n >>> IS_LINE_JUNK(' # \\n')\n True\n >>> IS_LINE_JUNK('hello\\n')\n False\n ",
'SequenceMatcher.get_grouped_opcodes (line 564)': " Isolate change clusters by eliminating ranges with no changes.\n\n Return a generator of groups with up to n lines of context.\n Each group is in the same format as returned by get_opcodes().\n\n >>> from pprint import pprint\n >>> a = list(map(str, range(1,40)))\n >>> b = a[:]\n >>> b[8:8] = ['i'] # Make an insertion\n >>> b[20] += 'x' # Make a replacement\n >>> b[23:28] = [] # Make a deletion\n >>> b[30] += 'y' # Make another replacement\n >>> pprint(list(SequenceMatcher(None,a,b).get_grouped_opcodes()))\n [[('equal', 5, 8, 5, 8), ('insert', 8, 8, 8, 9), ('equal', 8, 11, 9, 12)],\n [('equal', 16, 19, 17, 20),\n ('replace', 19, 20, 20, 21),\n ('equal', 20, 22, 21, 23),\n ('delete', 22, 27, 23, 23),\n ('equal', 27, 30, 23, 26)],\n [('equal', 31, 34, 27, 30),\n ('replace', 34, 35, 30, 31),\n ('equal', 35, 38, 31, 34)]]\n ",
'SequenceMatcher.ratio (line 614)': 'Return a measure of the sequences\' similarity (float in [0,1]).\n\n Where T is the total number of elements in both sequences, and\n M is the number of matches, this is 2.0*M / T.\n Note that this is 1 if the sequences are identical, and 0 if\n they have nothing in common.\n\n .ratio() is expensive to compute if you haven\'t already computed\n .get_matching_blocks() or .get_opcodes(), in which case you may\n want to try .quick_ratio() or .real_quick_ratio() first to get an\n upper bound.\n\n >>> s = SequenceMatcher(None, "abcd", "bcde")\n >>> s.ratio()\n 0.75\n >>> s.quick_ratio()\n 0.75\n >>> s.real_quick_ratio()\n 1.0\n ',
'SequenceMatcher.set_seq1 (line 215)': 'Set the first sequence to be compared.\n\n The second sequence to be compared is not changed.\n\n >>> s = SequenceMatcher(None, "abcd", "bcde")\n >>> s.ratio()\n 0.75\n >>> s.set_seq1("bcde")\n >>> s.ratio()\n 1.0\n >>>\n\n SequenceMatcher computes and caches detailed information about the\n second sequence, so if you want to compare one sequence S against\n many sequences, use .set_seq2(S) once and call .set_seq1(x)\n repeatedly for each of the other sequences.\n\n See also set_seqs() and set_seq2().\n ',
'SequenceMatcher.set_seq2 (line 241)': 'Set the second sequence to be compared.\n\n The first sequence to be compared is not changed.\n\n >>> s = SequenceMatcher(None, "abcd", "bcde")\n >>> s.ratio()\n 0.75\n >>> s.set_seq2("abcd")\n >>> s.ratio()\n 1.0\n >>>\n\n SequenceMatcher computes and caches detailed information about the\n second sequence, so if you want to compare one sequence S against\n many sequences, use .set_seq2(S) once and call .set_seq1(x)\n repeatedly for each of the other sequences.\n\n See also set_seqs() and set_seq1().\n ',
'SequenceMatcher.set_seqs (line 203)': 'Set the two sequences to be compared.\n\n >>> s = SequenceMatcher()\n >>> s.set_seqs("abcd", "bcde")\n >>> s.ratio()\n 0.75\n ',
'context_diff (line 1201)': '\n Compare two sequences of lines; generate the delta as a context diff.\n\n Context diffs are a compact way of showing line changes and a few\n lines of context. The number of context lines is set by \'n\' which\n defaults to three.\n\n By default, the diff control lines (those with *** or ---) are\n created with a trailing newline. This is helpful so that inputs\n created from file.readlines() result in diffs that are suitable for\n file.writelines() since both the inputs and outputs have trailing\n newlines.\n\n For inputs that do not have trailing newlines, set the lineterm\n argument to "" so that the output will be uniformly newline free.\n\n The context diff format normally has a header for filenames and\n modification times. Any or all of these may be specified using\n strings for \'fromfile\', \'tofile\', \'fromfiledate\', and \'tofiledate\'.\n The modification times are normally expressed in the ISO 8601 format.\n If not specified, the strings default to blanks.\n\n Example:\n\n >>> print(\'\'.join(context_diff(\'one\\ntwo\\nthree\\nfour\\n\'.splitlines(True),\n ... \'zero\\none\\ntree\\nfour\\n\'.splitlines(True), \'Original\', \'Current\')),\n ... end="")\n *** Original\n --- Current\n ***************\n *** 1,4 ****\n one\n ! two\n ! three\n four\n --- 1,4 ----\n + zero\n one\n ! tree\n four\n ',
'get_close_matches (line 686)': 'Use SequenceMatcher to return list of the best "good enough" matches.\n\n word is a sequence for which close matches are desired (typically a\n string).\n\n possibilities is a list of sequences against which to match word\n (typically a list of strings).\n\n Optional arg n (default 3) is the maximum number of close matches to\n return. n must be > 0.\n\n Optional arg cutoff (default 0.6) is a float in [0, 1]. Possibilities\n that don\'t score at least that similar to word are ignored.\n\n The best (no more than n) matches among the possibilities are returned\n in a list, sorted by similarity score, most similar first.\n\n >>> get_close_matches("appel", ["ape", "apple", "peach", "puppy"])\n [\'apple\', \'ape\']\n >>> import keyword as _keyword\n >>> get_close_matches("wheel", _keyword.kwlist)\n [\'while\']\n >>> get_close_matches("Apple", _keyword.kwlist)\n []\n >>> get_close_matches("accept", _keyword.kwlist)\n [\'except\']\n ',
'ndiff (line 1330)': '\n Compare `a` and `b` (lists of strings); return a `Differ`-style delta.\n\n Optional keyword parameters `linejunk` and `charjunk` are for filter\n functions, or can be None:\n\n - linejunk: A function that should accept a single string argument and\n return true iff the string is junk. The default is None, and is\n recommended; the underlying SequenceMatcher class has an adaptive\n notion of "noise" lines.\n\n - charjunk: A function that accepts a character (string of length\n 1), and returns true iff the character is junk. The default is\n the module-level function IS_CHARACTER_JUNK, which filters out\n whitespace characters (a blank or tab; note: it\'s a bad idea to\n include newline in this!).\n\n Tools/scripts/ndiff.py is a command-line front-end to this function.\n\n Example:\n\n >>> diff = ndiff(\'one\\ntwo\\nthree\\n\'.splitlines(keepends=True),\n ... \'ore\\ntree\\nemu\\n\'.splitlines(keepends=True))\n >>> print(\'\'.join(diff), end="")\n - one\n ? ^\n + ore\n ? ^\n - two\n - three\n ? -\n + tree\n + emu\n ',
'restore (line 2076)': '\n Generate one of the two sequences that generated a delta.\n\n Given a `delta` produced by `Differ.compare()` or `ndiff()`, extract\n lines originating from file 1 or 2 (parameter `which`), stripping off line\n prefixes.\n\n Examples:\n\n >>> diff = ndiff(\'one\\ntwo\\nthree\\n\'.splitlines(keepends=True),\n ... \'ore\\ntree\\nemu\\n\'.splitlines(keepends=True))\n >>> diff = list(diff)\n >>> print(\'\'.join(restore(diff, 1)), end="")\n one\n two\n three\n >>> print(\'\'.join(restore(diff, 2)), end="")\n ore\n tree\n emu\n ',
'unified_diff (line 1116)': '\n Compare two sequences of lines; generate the delta as a unified diff.\n\n Unified diffs are a compact way of showing line changes and a few\n lines of context. The number of context lines is set by \'n\' which\n defaults to three.\n\n By default, the diff control lines (those with ---, +++, or @@) are\n created with a trailing newline. This is helpful so that inputs\n created from file.readlines() result in diffs that are suitable for\n file.writelines() since both the inputs and outputs have trailing\n newlines.\n\n For inputs that do not have trailing newlines, set the lineterm\n argument to "" so that the output will be uniformly newline free.\n\n The unidiff format normally has a header for filenames and modification\n times. Any or all of these may be specified using strings for\n \'fromfile\', \'tofile\', \'fromfiledate\', and \'tofiledate\'.\n The modification times are normally expressed in the ISO 8601 format.\n\n Example:\n\n >>> for line in unified_diff(\'one two three four\'.split(),\n ... \'zero one tree four\'.split(), \'Original\', \'Current\',\n ... \'2005-01-26 23:30:50\', \'2010-04-02 10:20:52\',\n ... lineterm=\'\'):\n ... print(line) # doctest: +NORMALIZE_WHITESPACE\n --- Original 2005-01-26 23:30:50\n +++ Current 2010-04-02 10:20:52\n @@ -1,4 +1,4 @@\n +zero\n one\n -two\n -three\n +tree\n four\n ',
}