ó
|
L\¬Qc @ s¥ d Z d d d d d d d d d d
|
d g Z d d l Z d d l m Z d d l m Z e d d Z d Z d f d YZ
|
d d d Z d Z d f d YZ d d l Z e j d j d Z d d Z d Z d d d d d d d Z d Z d d d d d d d! Z e e d" Z e e e d# Z d$ Z d% Z d& Z d' Z d
|
e f d( YZ [ d) Z d* Z! e" d+ k r¡e! n d S(, se
|
Module difflib -- helpers for computing deltas between objects.
|
|
Function get_close_matches(word, possibilities, n=3, cutoff=0.6):
|
Use SequenceMatcher to return list of the best "good enough" matches.
|
|
Function context_diff(a, b):
|
For two lists of strings, return a delta in context diff format.
|
|
Function ndiff(a, b):
|
Return a delta: the difference between `a` and `b` (lists of strings).
|
|
Function restore(delta, which):
|
Return one of the two sequences that generated an ndiff delta.
|
|
Function unified_diff(a, b):
|
For two lists of strings, return a delta in unified diff format.
|
|
Class SequenceMatcher:
|
A flexible class for comparing pairs of sequences of any type.
|
|
Class Differ:
|
For producing human-readable deltas from sequences of lines of text.
|
|
Class HtmlDiff:
|
For producing HTML side by side comparison with change highlights.
|
t get_close_matchest ndifft restoret SequenceMatchert Differt IS_CHARACTER_JUNKt IS_LINE_JUNKt context_difft unified_difft HtmlDifft MatchiÿÿÿÿN( t
|
namedtuple( t reduces a b sizec C s | r d | | Sd S( Ng @g ð?( ( t matchest length( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt _calculate_ratio) s c B s e Z d Z d d d e d Z d Z d Z d Z d Z d Z
|
d Z d Z d
|
d Z d Z d Z d Z RS( s
|
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 synching up on blocks of "junk lines", though (like blank lines in
|
ordinary text files, or maybe "<P>" lines in HTML files). That may be
|
because this is the only method of the 3 that has a *concept* of
|
"junk" <wink>.
|
|
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.
|
|
Methods:
|
|
__init__(isjunk=None, a='', b='')
|
Construct a SequenceMatcher.
|
|
set_seqs(a, b)
|
Set the two sequences to be compared.
|
|
set_seq1(a)
|
Set the first sequence to be compared.
|
|
set_seq2(b)
|
Set the second sequence to be compared.
|
|
find_longest_match(alo, ahi, blo, bhi)
|
Find longest matching block in a[alo:ahi] and b[blo:bhi].
|
|
get_matching_blocks()
|
Return list of triples describing matching subsequences.
|
|
get_opcodes()
|
Return list of 5-tuples describing how to turn a into b.
|
|
ratio()
|
Return a measure of the sequences' similarity (float in [0,1]).
|
|
quick_ratio()
|
Return an upper bound on .ratio() relatively quickly.
|
|
real_quick_ratio()
|
Return an upper bound on ratio() very quickly.
|
t c C s6 | | _ d | _ | _ | | _ | j | | d S( s! 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).
|
N( t isjunkt Nonet at bt autojunkt set_seqs( t selfR R R R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt __init__ s @ c C s | j | | j | d S( s Set the two sequences to be compared.
|
|
>>> s = SequenceMatcher()
|
>>> s.set_seqs("abcd", "bcde")
|
>>> s.ratio()
|
0.75
|
N( t set_seq1t set_seq2( R R R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR ß s c C s0 | | j k r d S| | _ d | _ | _ d S( sM 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().
|
N( R R t matching_blockst opcodes( R R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR ë s c C sC | | j k r d S| | _ d | _ | _ d | _ | j d S( sM 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().
|
N( R R R R t
|
fullbcountt _SequenceMatcher__chain_b( R R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR s c C sP | j } i | _ } x9 t | D]+ \ } } | j | g } | j | q# Wt } | j } | r x@ t | j D]) } | | r} | j | | | =q} q} Wn t } t
|
| } | j r4| d k r4| d d }
|
xL t | j D]5 \ } } t
|
| |
|
k rø | j | | | =qø qø Wn | j | _ | j | _ d S( NiÈ id i ( R t b2jt enumeratet
|
setdefaultt appendt setR t listt keyst addt lenR t itemst __contains__t isbjunkt
|
isbpopular( R R R t it eltt indicest junkR t populart nt ntestt idxs( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt __chain_b2 s, c C sÀ | j | j | j | j f \ } } } } | | d } }
|
} i } g } xÁ t | | D]° } | j } i } x | j | | | D]z } | | k r q n | | k r® Pn | | d d d } | | <| | k r | | d | | d | } }
|
} q q W| } qZ Wxm | | k r}|
|
| k r}| | |
|
d r}| | d | |
|
d k r}| d |
|
d | d } }
|
} qWx_ | | | k rß|
|
| | k rß| | |
|
| rß| | | | |
|
| k rß| d 7} qWxl | | k rN|
|
| k rN| | |
|
d rN| | d | |
|
d k rN| d |
|
d | d } }
|
} qãWx^ | | | k r¯|
|
| | k r¯| | |
|
| r¯| | | | |
|
| k r¯| d } qRWt | |
|
| S( sò Find longest matching block in a[alo:ahi] and b[blo:bhi].
|
|
If isjunk is not defined:
|
|
Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where
|
alo <= i <= i+k <= ahi
|
blo <= j <= j+k <= bhi
|
and for all (i',j',k') meeting those conditions,
|
k >= k'
|
i <= i'
|
and if i == i', j <= j'
|
|
In other words, of all maximal matching blocks, return one that
|
starts earliest in a, and of all those maximal matching blocks that
|
start earliest in a, return the one that starts earliest in b.
|
|
>>> s = SequenceMatcher(None, " abcd", "abcd abcd")
|
>>> s.find_longest_match(0, 5, 0, 9)
|
Match(a=0, b=4, size=5)
|
|
If isjunk is defined, first the longest matching block is
|
determined as above, but with the additional restriction that no
|
junk element appears in the block. Then that block is extended as
|
far as possible by matching (only) junk elements on both sides. So
|
the resulting block never matches on junk except as identical junk
|
happens to be adjacent to an "interesting" match.
|
|
Here's the same example as before, but considering blanks to be
|
junk. That prevents " abcd" from matching the " abcd" at the tail
|
end of the second sequence directly. Instead only the "abcd" can
|
match, and matches the leftmost "abcd" in the second sequence:
|
|
>>> s = SequenceMatcher(lambda x: x==" ", " abcd", "abcd abcd")
|
>>> s.find_longest_match(0, 5, 0, 9)
|
Match(a=1, b=0, size=4)
|
|
If no blocks match, return (alo, blo, 0).
|
|
>>> s = SequenceMatcher(None, "ab", "c")
|
>>> s.find_longest_match(0, 2, 0, 1)
|
Match(a=0, b=0, size=0)
|
i i ( R R R R* t xranget getR
|
( R t alot ahit blot bhiR R R R* t bestit bestjt bestsizet j2lent nothingR, t j2lengett newj2lent jt k( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt find_longest_match^ sB 8* +
|
$# $# c C s | j d k r | j St | j t | j } } d | d | f g } g } xÕ | r'| j \ } } } } | j | | | | \ } }
|
} } | rS | j | | | k rÝ | |
|
k rÝ | j | | | |
|
f n | | | k r$|
|
| | k r$| j | | | |
|
| | f q$qS qS W| j d } } } g } xw | D]o \ } } } | | | k r| | | k r| | 7} qM| r¨| j | | | f n | | | } } } qMW| rß| j | | | f n | j | | d f | | _ t t
|
j | j S( s Return list of triples describing matching subsequences.
|
|
Each triple is of the form (i, j, n), and means that
|
a[i:i+n] == b[j:j+n]. The triples are monotonically increasing in
|
i and in j. New in Python 2.5, it's also guaranteed that if
|
(i, j, n) and (i', j', n') are adjacent triples in the list, and
|
the second is not the last triple in the list, then i+n != i' or
|
j+n != j'. IOW, adjacent triples never describe adjacent equal
|
blocks.
|
|
The last triple is a dummy, (len(a), len(b), 0), and is the only
|
triple with n==0.
|
|
>>> s = SequenceMatcher(None, "abxcd", "abcd")
|
>>> s.get_matching_blocks()
|
[Match(a=0, b=0, size=2), Match(a=3, b=2, size=2), Match(a=5, b=4, size=0)]
|
i N( R R R' R R t popRD R" t sortt mapR
|
t _make( R t lat lbt queueR R7 R8 R9 R: R, RB RC t xt i1t j1t k1t non_adjacentt i2t j2t k2( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt get_matching_blocksÌ s8 % +
|
c C s | j d k r | j Sd } } g | _ } xÍ | j D]¿ \ } } } d } | | k rp | | k rp d } n* | | k r
d } n | | k r d } n | r¿ | j | | | | | f n | | | | } } | r: | j d | | | | f q: q: W| S( sZ Return list of 5-tuples describing how to turn a into b.
|
|
Each tuple is of the form (tag, i1, i2, j1, j2). The first tuple
|
has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the
|
tuple preceding it, and likewise for j1 == the previous j2.
|
|
The tags are strings, with these meanings:
|
|
'replace': a[i1:i2] should be replaced by b[j1:j2]
|
'delete': a[i1:i2] should be deleted.
|
Note that j1==j2 in this case.
|
'insert': b[j1:j2] should be inserted at a[i1:i1].
|
Note that i1==i2 in this case.
|
'equal': a[i1:i2] == b[j1:j2]
|
|
>>> a = "qabxcd"
|
>>> b = "abycdf"
|
>>> s = SequenceMatcher(None, a, b)
|
>>> for tag, i1, i2, j1, j2 in s.get_opcodes():
|
... 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)
|
replace a[3:4] (x) b[2:3] (y)
|
equal a[4:6] (cd) b[3:5] (cd)
|
insert a[6:6] () b[5:6] (f)
|
i R t replacet deletet insertt equalN( R R RT R" ( R R, RB t answert ait bjt sizet tag( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt get_opcodes s$
|
#i c
|
c sð | j } | s d g } n | d d d k r | d \ } } } } } | t | | | | t | | | | f | d <n | d d d k rä | d \ } } } } } | | t | | | | t | | | f | d <n | | } g } xÀ | D]¸ \ } } } } } | d k r| | | k r| j | | t | | | | t | | | f | Vg } t | | | t | | | } } n | j | | | | | f qû W| rìt | d k oà| d d d k rì| Vn d S( sÓ Isolate change clusters by eliminating ranges with no changes.
|
|
Return a generator of groups with upto n lines of context.
|
Each group is in the same format as returned by get_opcodes().
|
|
>>> from pprint import pprint
|
>>> a = 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)]]
|
RX i i iÿÿÿÿN( s equali i i i ( R^ t maxt minR" R' (
|
R R1 t codesR] RM RQ RN RR t nnt group( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt get_grouped_opcodesJ s( 66
|
6* -c C s> t d | j d } t | t | j t | j S( sÒ 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
|
c S s | | d S( Niÿÿÿÿ( ( t sumt triple( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt <lambda> s i ( R RT R R' R R ( R R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt ratio| s c C sõ | j d k rM i | _ } x. | j D] } | j | d d | | <q& Wn | j } i } | j d } } xc | j D]X } | | r | | } n | j | d } | d | | <| d k rv | d } qv qv Wt | t | j t | j S( s© Return an upper bound on ratio() relatively quickly.
|
|
This isn't defined beyond that it is an upper bound on .ratio(), and
|
is faster to compute.
|
i i N( R R R R6 R) R R R' ( R R R- t availt availhasR t numb( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt quick_ratio s
|
! c C s9 t | j t | j } } t t | | | | S( sÊ Return an upper bound on ratio() very quickly.
|
|
This isn't defined beyond that it is an upper bound on .ratio(), and
|
is faster to compute than either .ratio() or .quick_ratio().
|
( R' R R R R` ( R RI RJ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt real_quick_ratio³ s N( t __name__t
|
__module__t __doc__R t TrueR R R R R RD RT R^ Rd Rh Rl Rm ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR . s jE - , n G 7 2 i g333333ã?c C s | d k s" t d | f n d | k o9 d k n sT t d | f n g } t } | j | xm | D]e } | j | | j | k rw | j | k rw | j | k rw | j | j | f qw qw Wt j | | } g | D] \ } } | ^ qù S( sÇ Use SequenceMatcher to return list of the best "good enough" matches.
|
|
word is a sequence for which close matches are desired (typically a
|
string).
|
|
possibilities is a list of sequences against which to match word
|
(typically a list of strings).
|
|
Optional arg n (default 3) is the maximum number of close matches to
|
return. n must be > 0.
|
|
Optional arg cutoff (default 0.6) is a float in [0, 1]. Possibilities
|
that don't score at least that similar to word are ignored.
|
|
The best (no more than n) matches among the possibilities are returned
|
in a list, sorted by similarity score, most similar first.
|
|
>>> get_close_matches("appel", ["ape", "apple", "peach", "puppy"])
|
['apple', 'ape']
|
>>> import keyword as _keyword
|
>>> get_close_matches("wheel", _keyword.kwlist)
|
['while']
|
>>> get_close_matches("apple", _keyword.kwlist)
|
[]
|
>>> get_close_matches("accept", _keyword.kwlist)
|
['except']
|
i s n must be > 0: %rg g ð?s cutoff must be in [0.0, 1.0]: %r(
|
t
|
ValueErrorR R R Rm Rl Rh R" t heapqt nlargest( t wordt possibilitiesR1 t cutofft resultt sRL t score( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR ¿ s c C sD d t | } } x* | | k r? | | | k r? | d 7} q W| S( s}
|
Return number of `ch` characters at the start of `line`.
|
|
Example:
|
|
>>> _count_leading(' abc', ' ')
|
3
|
i i ( R' ( t linet chR, R1 ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt _count_leadingï s
|
c B sS e Z d Z d d d Z d Z d Z d Z d Z d Z d Z
|
RS( se
|
Differ is a class for comparing sequences of lines of text, and
|
producing human-readable differences or deltas. Differ uses
|
SequenceMatcher both to compare sequences of lines, and to compare
|
sequences of characters within similar (near-matching) lines.
|
|
Each line of a Differ delta begins with a two-letter code:
|
|
'- ' line unique to sequence 1
|
'+ ' line unique to sequence 2
|
' ' line common to both sequences
|
'? ' line not present in either input sequence
|
|
Lines beginning with '? ' attempt to guide the eye to intraline
|
differences, and were not present in either input sequence. These lines
|
can be confusing if the sequences contain tab characters.
|
|
Note that Differ makes no claim to produce a *minimal* diff. To the
|
contrary, minimal diffs are often counter-intuitive, because they synch
|
up anywhere possible, sometimes accidental matches 100 pages apart.
|
Restricting synch points to contiguous matches preserves some notion of
|
locality, at the occasional cost of producing a longer diff.
|
|
Example: Comparing two texts.
|
|
First we set up the texts, sequences of individual single-line strings
|
ending with newlines (such sequences can also be obtained from the
|
`readlines()` method of file-like objects):
|
|
>>> text1 = ''' 1. Beautiful is better than ugly.
|
... 2. Explicit is better than implicit.
|
... 3. Simple is better than complex.
|
... 4. Complex is better than complicated.
|
... '''.splitlines(1)
|
>>> len(text1)
|
4
|
>>> text1[0][-1]
|
'\n'
|
>>> text2 = ''' 1. Beautiful is better than ugly.
|
... 3. Simple is better than complex.
|
... 4. Complicated is better than complex.
|
... 5. Flat is better than nested.
|
... '''.splitlines(1)
|
|
Next we instantiate a Differ object:
|
|
>>> d = Differ()
|
|
Note that when instantiating a Differ object we may pass functions to
|
filter out line and character 'junk'. See Differ.__init__ for details.
|
|
Finally, we compare the two:
|
|
>>> result = list(d.compare(text1, text2))
|
|
'result' is a list of strings, so let's pretty-print it:
|
|
>>> from pprint import pprint as _pprint
|
>>> _pprint(result)
|
[' 1. Beautiful is better than ugly.\n',
|
'- 2. Explicit is better than implicit.\n',
|
'- 3. Simple is better than complex.\n',
|
'+ 3. Simple is better than complex.\n',
|
'? ++\n',
|
'- 4. Complex is better than complicated.\n',
|
'? ^ ---- ^\n',
|
'+ 4. Complicated is better than complex.\n',
|
'? ++++ ^ ^\n',
|
'+ 5. Flat is better than nested.\n']
|
|
As a single multi-line string it looks like this:
|
|
>>> print ''.join(result),
|
1. Beautiful is better than ugly.
|
- 2. Explicit is better than implicit.
|
- 3. Simple is better than complex.
|
+ 3. Simple is better than complex.
|
? ++
|
- 4. Complex is better than complicated.
|
? ^ ---- ^
|
+ 4. Complicated is better than complex.
|
? ++++ ^ ^
|
+ 5. Flat is better than nested.
|
|
Methods:
|
|
__init__(linejunk=None, charjunk=None)
|
Construct a text differencer, with optional filters.
|
|
compare(a, b)
|
Compare two sequences of lines; generate the resulting delta.
|
c C s | | _ | | _ d S( sç
|
Construct a text differencer, with optional filters.
|
|
The two optional keyword parameters are for filter functions:
|
|
- `linejunk`: A function that should accept a single string argument,
|
and return true iff the string is junk. The module-level function
|
`IS_LINE_JUNK` may be used to filter out lines without visible
|
characters, except for at most one splat ('#'). It is recommended
|
to leave linejunk None; as of Python 2.3, the underlying
|
SequenceMatcher class has grown an adaptive notion of "noise" lines
|
that's better than any static definition the author has ever been
|
able to craft.
|
|
- `charjunk`: A function that should accept a string of length 1. The
|
module-level function `IS_CHARACTER_JUNK` may be used to filter out
|
whitespace characters (a blank or tab; **note**: bad idea to include
|
newline in this!). Use of IS_CHARACTER_JUNK is recommended.
|
N( t linejunkt charjunk( R R~ R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR \ s c c s t | j | | } xë | j D]Ý \ } } } } } | d k rd | j | | | | | | } n
| d k r | j d | | | } n^ | d k r² | j d | | | } n7 | d k rÙ | j d | | | } n t d | f x | D] }
|
|
|
Vqð Wq" Wd S(
|
sØ
|
Compare two sequences of lines; generate the resulting delta.
|
|
Each sequence must contain individual single-line strings ending with
|
newlines. Such sequences can be obtained from the `readlines()` method
|
of file-like objects. The delta generated also consists of newline-
|
terminated strings, ready to be printed as-is via the writeline()
|
method of a file-like object.
|
|
Example:
|
|
>>> print ''.join(Differ().compare('one\ntwo\nthree\n'.splitlines(1),
|
... 'ore\ntree\nemu\n'.splitlines(1))),
|
- one
|
? ^
|
+ ore
|
? ^
|
- two
|
- three
|
? -
|
+ tree
|
+ emu
|
RU RV t -RW t +RX t s unknown tag %rN( R R~ R^ t _fancy_replacet _dumpRr ( R R R t cruncherR] R7 R8 R9 R: t gR{ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt comparet s " ! c c s1 x* t | | D] } d | | | f Vq Wd S( s4 Generate comparison results for a same-tagged range.s %s %sN( R5 ( R R] RL t lot hiR, ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR s c c sÆ | | k r | | k s t | | | | k re | j d | | | } | j d | | | } n0 | j d | | | } | j d | | | } x* | | f D] } x | D] }
|
|
|
Vq¯ Wq¢ Wd S( NR R ( t AssertionErrorR ( R R R7 R8 R R9 R: t firstt secondR R{ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt _plain_replace¢ s c c s# d \ } } t | j } d \ }
|
} xà t | | D]Ï } | | } | j | x¯ t | | D] } | | } | | k r¢ |
|
d k rd | | }
|
} qd qd n | j | | j | k rd | j | k rd | j | k rd | j | | } } } qd qd Wq7 W| | k rk|
|
d k rTx+ | j | | | | | | D] } | VqAWd S|
|
| d } } } n d }
|
x+ | j
|
| | | | | | D] } | VqW| | | | } } |
|
d k ràd } } | j | | xØ | j D]Ê \ } } } } } | | | | } } | d k r<| d | 7} | d | 7} qç| d k rY| d | 7} qç| d
|
k rv| d | 7} qç| d k r¡| d | 7} | d | 7} qçt d | f qçWx1 | j | | | | D] } | VqÎWn d | Vx3 | j
|
| | d | | | d | D] } | VqWd S( sD
|
When replacing one block of lines with another, search the blocks
|
for *similar* lines; the best-matching pair (if any) is used as a
|
synch point, and intraline difference marking is done on the
|
similar pair. Lots of work, but often worth it.
|
|
Example:
|
|
>>> d = Differ()
|
>>> results = d._fancy_replace(['abcDefghiJkl\n'], 0, 1,
|
... ['abcdefGhijkl\n'], 0, 1)
|
>>> print ''.join(results),
|
- abcDefghiJkl
|
? ^ ^ ^
|
+ abcdefGhijkl
|
? ^ ^ ^
|
g®Gáz®ç?g è?Ng ð?R RU t ^RV R RW R RX R s unknown tag %rs i ( g®Gáz®ç?g è?( NN( R R R R5 R R Rm Rl Rh R t _fancy_helperR R^ Rr t _qformat( R R R7 R8 R R9 R: t
|
best_ratioRw R
t eqit eqjRB R[ R, RZ t best_it best_jR{ t aeltt beltt atagst btagsR] t ai1t ai2t bj1t bj2RI RJ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR ± s`
|
|
% % %
|
" -c c s g } | | k rZ | | k r? | j | | | | | | } q | j d | | | } n' | | k r | j d | | | } n x | D] } | Vq Wd S( NR R ( R R ( R R R7 R8 R R9 R: R R{ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR s ! c c sÇ t t | d t | d } t | t | | d } t | t | | d } | | j } | | j } d | V| r d d | | f Vn d | V| rà d d | | f Vn d S( s¡
|
Format "?" output and deal with leading tabs.
|
|
Example:
|
|
>>> d = Differ()
|
>>> results = d._qformat('\tabcDefghiJkl\n', '\tabcdefGhijkl\n',
|
... ' ^ ^ ^ ', ' ^ ^ ^ ')
|
>>> for line in results: print repr(line)
|
...
|
'- \tabcDefghiJkl\n'
|
'? \t ^ ^ ^\n'
|
'+ \tabcdefGhijkl\n'
|
'? \t ^ ^ ^\n'
|
s R s - s ? %s%s
|
s + N( R` R} t rstrip( R t alinet blineR R t common( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR s N( Rn Ro Rp R R R R R R R R ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR þ s \ ) b s \s*#?\s*$c C s | | d k S( sÜ
|
Return 1 for ignorable line: iff `line` is blank or contains a single '#'.
|
|
Examples:
|
|
>>> IS_LINE_JUNK('\n')
|
True
|
>>> IS_LINE_JUNK(' # \n')
|
True
|
>>> IS_LINE_JUNK('hello\n')
|
False
|
N( R ( R{ t pat( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR T s s c C s
|
| | k S( sû
|
Return 1 for ignorable character: iff `ch` is a space or tab.
|
|
Examples:
|
|
>>> IS_CHARACTER_JUNK(' ')
|
True
|
>>> IS_CHARACTER_JUNK('\t')
|
True
|
>>> IS_CHARACTER_JUNK('\n')
|
False
|
>>> IS_CHARACTER_JUNK('x')
|
False
|
( ( R| t ws( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR d s c C sP | d } | | } | d k r- d j | S| s@ | d 8} n d j | | S( s Convert range to the "ed" formati s {}s {},{}( t format( t startt stopt beginningR ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt _format_range_unified{ s
|
|
R s
|
c c s§ t } xt d | | j | D]}} | s t } | rI d j | n d }
|
| rd d j | n d } d j | |
|
| Vd j | | | Vn | d | d } } t | d | d } t | d | d
|
} d j | | | Vx° | D]¨ \ } } } } } | d k r;x | | | !D] } d | Vq"Wqó n | d k rkx! | | | !D] } d | VqUWn | d k ró x! | | | !D] } d | Vq
Wqó qó Wq" Wd S( sª
|
Compare two sequences of lines; generate the delta as a unified diff.
|
|
Unified diffs are a compact way of showing line changes and a few
|
lines of context. The number of context lines is set by 'n' which
|
defaults to three.
|
|
By default, the diff control lines (those with ---, +++, or @@) are
|
created with a trailing newline. This is helpful so that inputs
|
created from file.readlines() result in diffs that are suitable for
|
file.writelines() since both the inputs and outputs have trailing
|
newlines.
|
|
For inputs that do not have trailing newlines, set the lineterm
|
argument to "" so that the output will be uniformly newline free.
|
|
The unidiff format normally has a header for filenames and modification
|
times. Any or all of these may be specified using strings for
|
'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
|
The modification times are normally expressed in the ISO 8601 format.
|
|
Example:
|
|
>>> for line in unified_diff('one two three four'.split(),
|
... 'zero one tree four'.split(), 'Original', 'Current',
|
... '2005-01-26 23:30:50', '2010-04-02 10:20:52',
|
... lineterm=''):
|
... print line # doctest: +NORMALIZE_WHITESPACE
|
--- Original 2005-01-26 23:30:50
|
+++ Current 2010-04-02 10:20:52
|
@@ -1,4 +1,4 @@
|
+zero
|
one
|
-two
|
-three
|
+tree
|
four
|
s {}R s
|
--- {}{}{}s
|
+++ {}{}{}i iÿÿÿÿi i i i s @@ -{} +{} @@{}RX R RU RV R RW R N( s replaces delete( s replaces insert( t FalseR R Rd Rq R¤ R¨ ( R R t fromfilet tofilet fromfiledatet
|
tofiledateR1 t linetermt startedRc t fromdatet todateR t lastt file1_ranget file2_rangeR] RM RQ RN RR R{ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR s. )" c C sX | d } | | } | s' | d 8} n | d k r@ d j | Sd j | | | d S( s Convert range to the "ed" formati s {}s {},{}( R¤ ( R¥ R¦ R§ R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt _format_range_contextÎ s
|
|
c c s t d d d d d d d d } t } xØt d | | j | D]»}
|
| s¶ t } | rj d j | n d
|
} | r
d j | n d
|
} d j | | | Vd j | | | Vn |
|
d |
|
d } } d | Vt | d | d } d j | | Vt d |
|
D rixT |
|
D]I \ } } } } } | d k rx% | | | !D] } | | | VqHWqqWn t | d | d } d j | | Vt d |
|
D rC xT |
|
D]I \ } } } } } | d k r®x% | | | !D] } | | | VqÝWq®q®WqC qC Wd S( sL
|
Compare two sequences of lines; generate the delta as a context diff.
|
|
Context diffs are a compact way of showing line changes and a few
|
lines of context. The number of context lines is set by 'n' which
|
defaults to three.
|
|
By default, the diff control lines (those with *** or ---) are
|
created with a trailing newline. This is helpful so that inputs
|
created from file.readlines() result in diffs that are suitable for
|
file.writelines() since both the inputs and outputs have trailing
|
newlines.
|
|
For inputs that do not have trailing newlines, set the lineterm
|
argument to "" so that the output will be uniformly newline free.
|
|
The context diff format normally has a header for filenames and
|
modification times. Any or all of these may be specified using
|
strings for 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
|
The modification times are normally expressed in the ISO 8601 format.
|
If not specified, the strings default to blanks.
|
|
Example:
|
|
>>> print ''.join(context_diff('one\ntwo\nthree\nfour\n'.splitlines(1),
|
... 'zero\none\ntree\nfour\n'.splitlines(1), 'Original', 'Current')),
|
*** Original
|
--- Current
|
***************
|
*** 1,4 ****
|
one
|
! two
|
! three
|
four
|
--- 1,4 ----
|
+ zero
|
one
|
! tree
|
four
|
RW s + RV s - RU s ! RX s s {}R s
|
*** {}{}{}s
|
--- {}{}{}i iÿÿÿÿs ***************i i s *** {} ****{}c s s* | ] \ } } } } } | d k Vq d S( RU RV N( s replaces delete( ( t .0R] t _( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pys <genexpr> s i i s --- {} ----{}c s s* | ] \ } } } } } | d k Vq d S( RU RW N( s replaces insert( ( R¶ R] R· ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pys <genexpr> s N( t dictR© R R Rd Rq R¤ Rµ t any( R R Rª R« R¬ R R1 R® t prefixR¯ Rc R° R± R R² R³ R] RM RQ R· R{ R´ RN RR ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR Ú s2 +!" c C s t | | j | | S( só
|
Compare `a` and `b` (lists of strings); return a `Differ`-style delta.
|
|
Optional keyword parameters `linejunk` and `charjunk` are for filter
|
functions (or None):
|
|
- linejunk: A function that should accept a single string argument, and
|
return true iff the string is junk. The default is None, and is
|
recommended; as of Python 2.3, an adaptive notion of "noise" lines is
|
used that does a good job on its own.
|
|
- charjunk: A function that should accept a string of length 1. The
|
default is module-level function IS_CHARACTER_JUNK, which filters out
|
whitespace characters (a blank or tab; note: bad idea to include newline
|
in this!).
|
|
Tools/scripts/ndiff.py is a command-line front-end to this function.
|
|
Example:
|
|
>>> diff = ndiff('one\ntwo\nthree\n'.splitlines(1),
|
... 'ore\ntree\nemu\n'.splitlines(1))
|
>>> print ''.join(diff),
|
- one
|
? ^
|
+ ore
|
? ^
|
- two
|
- three
|
? -
|
+ tree
|
+ emu
|
( R R ( R R R~ R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR $ s "c # sÔ d d l } | j d t | | | | d d g f d f d f d } | } | d k r xOt r | j Vq Wn7| d 7} d } x$t rÏd d g | } }
|
t } xL | t k r| j \ } } } | | } | | | f |
|
| <| d 7} qÏ W| | k r5d V| } n | } d } x1 | rt| | } | d 7} |
|
| V| d 8} qDW| d } xJ | rË| j \ } } } | r°| d } n
|
| d 8} | | | f VqWq¬ Wd S(
|
sà Returns generator yielding marked up from/to side by side differences.
|
|
Arguments:
|
fromlines -- list of text lines to compared to tolines
|
tolines -- list of text lines to be compared to fromlines
|
context -- number of context lines to display on each side of difference,
|
if None, all from/to text lines will be generated.
|
linejunk -- passed on to ndiff (see ndiff documentation)
|
charjunk -- passed on to ndiff (see ndiff documentation)
|
|
This function returns an interator which returns a tuple:
|
(from line tuple, to line tuple, boolean flag)
|
|
from/to line tuple -- (line num, line text)
|
line num -- integer or None (to indicate a context separation)
|
line text -- original line text with following markers inserted:
|
'\0+' -- marks start of added text
|
'\0-' -- marks start of deleted text
|
'\0^' -- marks start of changed text
|
'\1' -- marks end of added/deleted/changed text
|
|
boolean flag -- None indicates context separation, True indicates
|
either "from" or "to" line contains a change, otherwise False.
|
|
This function/iterator was originally developed to generate side by side
|
file difference for making HTML pages (see HtmlDiff class for example
|
usage).
|
|
Note, this function utilizes the ndiff function to generate the side by
|
side difference markup. Optional ndiff arguments may be passed to this
|
function and they in turn will be passed to ndiff.
|
iÿÿÿÿNs (\++|\-+|\^+)i c s) | | c d 7<| d k r7 | | | j d d f S| d k rç | j d | j d } } g } | d } j | | xS | d d d
D]> \ } \ } }
|
| d | !d | | | |
|
!d | |
|
} q W| d } n4 | j d d } | s d
|
} n d | | d } | | | f S( s Returns line of text with user's change markup and line formatting.
|
|
lines -- list of lines from the ndiff generator to produce a line of
|
text from. When producing the line of text to return, the
|
lines used are removed from this list.
|
format_key -- '+' return first line in list with "add" markup around
|
the entire line.
|
'-' return first line in list with "delete" markup around
|
the entire line.
|
'?' return first line in list with add/delete/change
|
intraline markup (indices obtained from second line)
|
None return first line in list with no markup
|
side -- indice into the num_lines list (0=from,1=to)
|
num_lines -- from/to current line number. This is NOT intended to be a
|
passed parameter. It is present as a keyword argument to
|
maintain memory of the current line numbers between calls
|
of this function.
|
|
Note, this function is purposefully not defined at the module scope so
|
that data it needs from its parent function (within whose context it
|
is defined) does not need to be of module scope.
|
i i i t ?c S s3 | j | j d d | j g | j d S( Ni i ( R" Rc t span( t match_objectt sub_info( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt record_sub_info s &Niÿÿÿÿt s R ( R RE t sub( t linest
|
format_keyt sidet num_linest textt markersR¾ R¿ t keyt begint end( t change_re( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt
|
_make_liner s &0 c 3 sw g } d \ } } x^t rrxN t | d k rk y | j j Wq t k
|
rg | j d q Xq Wd j g | D] } | d ^ qy } | j d rª | } nI| j d rå | d d | d d t f Vq n| j d r | d 8} | d d d t f Vq nÕ| j d rZ | d d d } } | d d } } n| j d r | d d | d d t f Vq n^| j d rÐ | d d | d d t f Vq n#| j d r | d 8} | d d d t f Vq nê | j d rB| d 7} d | d d t f Vq n± | j d r~d | d d } } | d d } } nu | j d r·| d 7} d | d d t f Vq n< | j d ró | d d | d d t f Vq n x( | d k r | d 7} d d t f VqöWx( | d k rH| d 8} d d t f Vq!W| j d rat q | | t f Vq Wd S( s¡ Yields from/to lines of text with a change indication.
|
|
This function is an iterator. It itself pulls lines from a
|
differencing iterator, processes them and yields them. When it can
|
it yields both a "from" and a "to" line, otherwise it will yield one
|
or the other. In addition to yielding the lines of from/to text, a
|
boolean flag is yielded to indicate if the text line(s) have
|
differences in them.
|
|
Note, this function is purposefully not defined at the module scope so
|
that data it needs from its parent function (within whose context it
|
is defined) does not need to be of module scope.
|
i i t XR s -?+?R» i s --++R s --?+s --+s - s -+?s -?+s +--R s + s +-R s
|
N( i i ( s --?+s --+s - ( s + s +-( R s
|
( R s
|
( Rq R' R" t nextt StopIterationt joint
|
startswithR R© ( RÂ t num_blanks_pendingt num_blanks_to_yieldR{ Ry t from_linet to_line( RÌ t diff_lines_iterator( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt _line_iteratorª sl & &
|
&&
|
|
|
'
|
|
c 3 sé } g g } } xÌ t rä x t | d k sF t | d k r¢ | j \ } } } | d k r} | j | | f n | d k r" | j | | f q" q" W| j d \ } } | j d \ } } | | | pÜ | f Vq Wd S( st Yields from/to lines of text with a change indication.
|
|
This function is an iterator. It itself pulls lines from the line
|
iterator. Its difference from that iterator is that this function
|
always yields a pair of from/to text lines (with the change
|
indication). If necessary it will collect single from/to lines
|
until it has a matching pair from/to pair to yield.
|
|
Note, this function is purposefully not defined at the module scope so
|
that data it needs from its parent function (within whose context it
|
is defined) does not need to be of module scope.
|
i N( Rq R' RÎ R R" RE ( t line_iteratort fromlinest tolinesRÔ RÕ t
|
found_difft fromDifft to_diff( R× ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt _line_pair_iterator s ' i ( NNN( t ret compileR R Rq RÎ R© ( RÙ RÚ t contextR~ R Rß RÞ t line_pair_iteratort lines_to_writet indext contextLinesRÛ RÔ RÕ R, ( ( R× RÌ RË RÖ sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt _mdiffH sJ " 8[
|
|
|
|
|
|
sm
|
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
|
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
|
|
<html>
|
|
<head>
|
<meta http-equiv="Content-Type"
|
content="text/html; charset=ISO-8859-1" />
|
<title></title>
|
<style type="text/css">%(styles)s
|
</style>
|
</head>
|
|
<body>
|
%(table)s%(legend)s
|
</body>
|
|
</html>sH
|
table.diff {font-family:Courier; border:medium;}
|
.diff_header {background-color:#e0e0e0}
|
td.diff_header {text-align:right}
|
.diff_next {background-color:#c0c0c0}
|
.diff_add {background-color:#aaffaa}
|
.diff_chg {background-color:#ffff77}
|
.diff_sub {background-color:#ffaaaa}sZ
|
<table class="diff" id="difflib_chg_%(prefix)s_top"
|
cellspacing="0" cellpadding="0" rules="groups" >
|
<colgroup></colgroup> <colgroup></colgroup> <colgroup></colgroup>
|
<colgroup></colgroup> <colgroup></colgroup> <colgroup></colgroup>
|
%(header_row)s
|
<tbody>
|
%(data_rows)s </tbody>
|
</table>sõ
|
<table class="diff" summary="Legends">
|
<tr> <th colspan="2"> Legends </th> </tr>
|
<tr> <td> <table border="" summary="Colors">
|
<tr><th> Colors </th> </tr>
|
<tr><td class="diff_add"> Added </td></tr>
|
<tr><td class="diff_chg">Changed</td> </tr>
|
<tr><td class="diff_sub">Deleted</td> </tr>
|
</table></td>
|
<td> <table border="" summary="Links">
|
<tr><th colspan="2"> Links </th> </tr>
|
<tr><td>(f)irst change</td> </tr>
|
<tr><td>(n)ext change</td> </tr>
|
<tr><td>(t)op</td> </tr>
|
</table></td> </tr>
|
</table>c B sª e Z d Z e Z e Z e Z e Z d Z d d d e d Z
|
d d e d d Z d Z d Z d Z d
|
Z d Z d Z d Z d d e d d Z RS( s{ For producing HTML side by side comparison with change highlights.
|
|
This class can be used to create an HTML table (or a complete HTML file
|
containing the table) showing a side by side, line by line comparison
|
of text with inter-line and intra-line change highlights. The table can
|
be generated in either full or contextual difference mode.
|
|
The following methods are provided for HTML generation:
|
|
make_table -- generates HTML for a single side by side table
|
make_file -- generates complete HTML file with a single side by side table
|
|
See tools/scripts/diff.py for an example usage of this class.
|
i i c C s( | | _ | | _ | | _ | | _ d S( sÛ HtmlDiff instance initializer
|
|
Arguments:
|
tabsize -- tab stop spacing, defaults to 8.
|
wrapcolumn -- column number where lines are broken and wrapped,
|
defaults to None where lines are not wrapped.
|
linejunk,charjunk -- keyword arguments passed into ndiff() (used to by
|
HtmlDiff() to generate the side by side HTML differences). See
|
ndiff() documentation for argument default values and descriptions.
|
N( t _tabsizet _wrapcolumnt _linejunkt _charjunk( R t tabsizet
|
wrapcolumnR~ R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR s R i c C sD | j t d | j d | j d | j | | | | d | d | S( sí Returns HTML file of side by side comparison with change highlights
|
|
Arguments:
|
fromlines -- list of "from" lines
|
tolines -- list of "to" lines
|
fromdesc -- "from" file column header string
|
todesc -- "to" file column header string
|
context -- set to True for contextual differences (defaults to False
|
which shows full differences).
|
numlines -- number of context lines. When context is set True,
|
controls number of lines displayed before and after the change.
|
When context is False, controls the number of lines to place
|
the "next" link anchors before the next change (so click of
|
"next" link jumps to just before the change).
|
t stylest legendt tableRá t numlines( t _file_templateR¸ t _stylest _legendt
|
make_table( R RÙ RÚ t fromdesct todescRá Rð ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt make_file¯ s
|
c sW f d } g | D] } | | ^ q } g | D] } | | ^ q5 } | | f S( s Returns from/to line lists with tabs expanded and newlines removed.
|
|
Instead of tab characters being replaced by the number of spaces
|
needed to fill in to the next tab stop, this function will fill
|
the space with tab characters. This is done so that the difference
|
algorithms can identify changes in a file when tabs are replaced by
|
spaces and vice versa. At the end of the HTML generation, the tab
|
characters will be replaced with a nonbreakable space.
|
c sO | j d d } | j j } | j d d } | j d d j d S( NR RÀ s s
|
( RU t
|
expandtabsRç R ( R{ ( R ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt expand_tabsÑ s ( ( R RÙ RÚ Rù R{ ( ( R sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt _tab_newline_replaceÇ s
|
c C sj | s | j | | f d St | } | j } | | k s[ | | j d d | k rr | j | | f d Sd } d } d } x | | k r
|
| | k r
|
| | d k rÐ | d 7} | | } | d 7} q | | d k ró | d 7} d } q | d 7} | d 7} q W| | } | | }
|
| r@| d } d | |
|
}
|
n | j | | f | j | d |
|
d S( s¤ Builds list of text lines by splitting text lines at wrap point
|
|
This function will determine if the input text line needs to be
|
wrapped (split) into separate lines. If so, the first wrap point
|
will be determined and the first line appended to the output
|
text line list. This function is used recursively to handle
|
the second part of the split line to further split it.
|
NRÀ i i R i s t >( R" R' Rè t countt _split_line( R t data_listt line_numRÆ R\ R_ R, R1 t markt line1t line2( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyRý Þ s8
|
)
|
|
|
|
|
|
|
c c sç xà | D]Ø \ } } } | d k r6 | | | f Vq n | | \ } } \ } } g g } }
|
| j | | | | j |
|
| | xZ | s |
|
rÞ | r© | j d } n d } |
|
rÇ |
|
j d } n d } | | | f Vq
Wq Wd S( s5 Returns iterator that splits (wraps) mdiff text linesi R R N( R R ( R R ( R Rý RE ( R t diffst fromdatat todatat flagt fromlinet fromtextt tolinet totextt fromlistt tolist( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt _line_wrapper s c C s² g g g } } } x | D] \ } } } y< | j | j d | | | j | j d | | Wn+ t k
|
r | j d | j d n X| j | q W| | | f S( s³ Collects mdiff output into separate lists
|
|
Before storing the mdiff from/to data into a list, it is converted
|
into a single line of text with HTML markup.
|
i i N( R" t _format_linet TypeErrorR ( R R R R t flaglistR R R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt _collect_lines1 s c C s y% d | } d | j | | f } Wn t k
|
r> d } n X| j d d j d d j d d } | j d
|
d j } d | | | f S( s Returns HTML markup of "from" / "to" text lines
|
|
side -- 0 or 1 indicating "from" or "to" text
|
flag -- indicates if difference on line
|
linenum -- line number (used for line number column)
|
text -- line text to be marked up
|
s %ds
|
id="%s%s"R t &s &Rû s >t <s <R s s< <td class="diff_header"%s>%s</td><td nowrap="nowrap">%s</td>( t _prefixR RU R ( R RÄ R t linenumRÆ t id( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR F s
|
|
*c C s< d t j } d t j } t j d 7_ | | g | _ d S( s Create unique anchor prefixess from%d_s to%d_i N( R t _default_prefixR ( R t
|
fromprefixt toprefix( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt _make_prefix] s c C sZ | j d } d g t | } d g t | } d t } }
|
d } x t | D]x \ } } | rÅ |
|
sË t }
|
| } t d | | g } d | | f | | <| d 7} d | | f | | <qË qS t }
|
qS W| s t g } d g } d g } d } | rd g } | } q d g } } n | d s9d | | d <n d | | | <| | | | | f S(
|
s Makes list of "next" linksi R i s id="difflib_chg_%s_%d"s" <a href="#difflib_chg_%s_%d">n</a>s2 <td></td><td> No Differences Found </td>s( <td></td><td> Empty File </td>s! <a href="#difflib_chg_%s_0">f</a>s# <a href="#difflib_chg_%s_top">t</a>( R R' R© R Rq R_ ( R R R R Rá Rð R t next_idt next_hreft num_chgt in_changeR² R, R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt _convert_flagsh s:
|
|
|
c
|
C sí | j | j | | \ } } | r1 | } n d } t | | | d | j d | j } | j rv | j | } n | j | \ } }
|
} | j | |
|
| | | \ } }
|
} } } g } d d } x} t
|
t | D]i } | | d k r| d k rD| j d qDqÛ | j | | | | | | | | | |
|
| f qÛ W| sT| rud d d | d d | f } n d
|
} | j t d d
|
j | d | d | j d } | j d d j d d j d d j d d j d d S( sî Returns HTML table of side by side comparison with change highlights
|
|
Arguments:
|
fromlines -- list of "from" lines
|
tolines -- list of "to" lines
|
fromdesc -- "from" file column header string
|
todesc -- "to" file column header string
|
context -- set to True for contextual differences (defaults to False
|
which shows full differences).
|
numlines -- number of context lines. When context is set True,
|
controls number of lines displayed before and after the change.
|
When context is False, controls the number of lines to place
|
the "next" link anchors before the next change (so click of
|
"next" link jumps to just before the change).
|
R~ R s1 <tr><td class="diff_next"%s>%s</td>%ss% <td class="diff_next">%s</td>%s</tr>
|
i s) </tbody>
|
<tbody>
|
s <thead><tr>%s%s%s%s</tr></thead>s! <th class="diff_next"><br /></th>s+ <th colspan="2" class="diff_header">%s</th>R t data_rowst
|
header_rowRº i t +s <span class="diff_add">t -s <span class="diff_sub">t ^s <span class="diff_chg">s s </span>s s N( R Rú R Ræ Ré Rê Rè R R R t rangeR' R" t _table_templateR¸ RÐ R RU ( R RÙ RÚ Rõ Rö Rá Rð t context_linesR R R R R R Ry t fmtR, R! Rï ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyRô sJ
|
$ N( Rn Ro Rp Rñ Rò R& Ró R R R R R© R÷ Rú Rý R R R R R Rô ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR s& 7 / c c s y" i d d 6d d 6t | } Wn t k
|
rB t d | n Xd | f } x* | D]" } | d | k rV | d VqV qV Wd S( s
|
Generate one of the two sequences that generated a delta.
|
|
Given a `delta` produced by `Differ.compare()` or `ndiff()`, extract
|
lines originating from file 1 or 2 (parameter `which`), stripping off line
|
prefixes.
|
|
Examples:
|
|
>>> diff = ndiff('one\ntwo\nthree\n'.splitlines(1),
|
... 'ore\ntree\nemu\n'.splitlines(1))
|
>>> diff = list(diff)
|
>>> print ''.join(restore(diff, 1)),
|
one
|
two
|
three
|
>>> print ''.join(restore(diff, 2)),
|
ore
|
tree
|
emu
|
s - i s + i s) unknown delta choice (must be 1 or 2): %rs N( t intt KeyErrorRr ( t deltat whichR] t prefixesR{ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyR æ s " c C s% d d l } d d l } | j | S( Niÿÿÿÿ( t doctestt difflibt testmod( R. R/ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt _test s t __main__(# Rp t __all__Rs t collectionsR t _namedtuplet functoolsR R
|
R R R R} R Rß Rà t matchR R R¨ R Rµ R R R Ræ Rñ Rò R& Ró t objectR R R1 Rn ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/difflib.pyt <module> sN ÿ ÿ 0 ÿ U G I$ ÿ
|
ÿ ]
|
