Python difflib.Differ类代码示例

def getFirstLettersTheSame(wd1, wd2):
    #возращает одинаковые первые буквы у двух идущих друг за другом слов
    d = Differ()
    diff = ''.join(d.compare(wd1, wd2))
    diff = patternSpace.sub('',diff)

    return patternLetters.match(diff)

def get_changelist(old_text, new_text):
    # copy and make sure we don't register changes simply
    # because the endline characters changed (which happens
    # when syncing windows and linux files, and when an otw
    # unchanged line at the end of the file now has an endline
    # character)
    # splitlines() eliminate the last line if it's empty, and
    # removes the endline characters, so they won't be considered
    # for the diffs
    old_text = old_text.splitlines()
    old_text = [l for l in old_text]

    new_text = new_text.splitlines()
    new_text = [l for l in new_text]

    lines_with_changes = None

    differ = Differ()
    differ_output = differ.compare(old_text, new_text)

    lc = 0
    lines_with_changes = []
    for l in differ_output:
        if l[0] == '+':
            lines_with_changes.append(lc)
            lc += 1
        elif l[0] == '-':
            pass
        elif l[0] == ' ':
            lc += 1
        # there might also be the '?' case, but this doesn't affect the linecount
    
    return "\n".join([str(l) for l in lines_with_changes])

    def str_diffs(self):
        if self.actual == self.expected:
            return ''

        differ = Differ()
        diffs = differ.compare(self.actual.splitlines(), self.expected.splitlines())
        return 'Diffs:\n{0}'.format('\n'.join(diffs))

    def testcode(self):
        skipped_methods = []

        fname = "examples/android/TestsAndroguard/bin/classes.dex"

        parsed = parse_dex.read_dex(fname)

        with open(fname, "rb") as f:
            d = DalvikVMFormat(f.read())

            dif = Differ()

            for m in d.get_methods():
                if not m.get_code():
                    continue

                if m.get_method_idx() in skipped_methods:
                    continue

                code = hexlify(m.get_code().get_raw())
                self.assertEqual(parsed[m.get_method_idx()],
                                 code,
                                 "incorrect code for "
                                 "[{}]: {} --> {}:\n"
                                 "{}\ntries_size: {}, insns_size: {}\nSHOULD BE {}\n{}\n{}".format(m.get_method_idx(),
                                             m.get_class_name(),
                                             m.get_name(),
                                             "".join(dif.compare(parsed[m.get_method_idx()],
                                             code)),
                                             m.get_code().tries_size,
                                             m.get_code().insns_size,
                                             hexlify(m.get_code().get_raw()),
                                             parsed[m.get_method_idx()],
                                             hexlify(m.get_code().code.get_raw())))

def _(success, output):
    d = Differ()
    assert world.out.value() == output, '\n' + '\n'.join(d.compare(world.out.value().split('\n'), output.split('\n')))
    if success == 'fail':
        assert world.status.value() != 0
    else:
        assert world.status.value() == 0

    def sortimports_linenum_msg(self, sort_result):
        """Parses isort.SortImports for line number changes and message

        Uses a diff.Differ comparison of SortImport `in_lines`:`out_lines` to
        yield the line numbers of import lines that have been moved or blank
        lines added.

        Args:
            sort_imports (isort.SortImports): The isorts results object.

        Yields:
            tuple: A tuple of the specific isort line number and message.
        """
        if sort_result.skipped:
            raise StopIteration

        self._fixup_sortimports_wrapped(sort_result)
        self._fixup_sortimports_eof(sort_result)

        differ = Differ()
        diff = differ.compare(sort_result.in_lines, sort_result.out_lines)

        line_num = 0
        for line in diff:
            if line.startswith('  ', 0, 2):
                line_num += 1  # Ignore unchanged lines but increment line_num.
            elif line.startswith('- ', 0, 2):
                line_num += 1
                if line.strip() == '-':
                    yield line_num, self.isort_blank_unexp
                else:
                    yield line_num, self.isort_unsorted
            elif line.strip() == '+':
                # Include newline additions but do not increment line_num.
                yield line_num + 1, self.isort_blank_req

    def diff(self, oldobj, obj):
        """Create a diff of `obj` vs. `oldobj`; description is handled using difflib module."""
        difflist = []
        skip     = "description_html".split()
        nl       = '\n'

        for fld in obj._meta.fields:
            name = fld.name
            if name not in skip:
                oldval = getattr(oldobj, fld.name)
                val    = getattr(obj, fld.name)

                if name == "description":
                    olddesc = oldobj.description.splitlines(1)
                    desc    = obj.description.splitlines(1)
                    if olddesc:
                        olddesc[-1] = olddesc[-1].strip() + '\r\n'
                    if desc:
                        desc[-1] = desc[-1].strip() + '\r\n'
                    d      = Differ()
                    result = list(d.compare(olddesc, desc))

                    # note: Differ returns full(?) content when there are no changes!!!?
                    if olddesc != desc:
                        difflist.extend( [nl + "Description diff:" + nl] + result + [nl] )
                else:
                    if oldval != val:
                        difflist.append("%s: changed from '%s' to '%s'" % (fld.name, oldval, val) + nl)

        diff = ''.join(difflist)
        return diff

    def compare_config(self, other=None, text=False):
        """
        Compares running config with another config. This other config can be either the *running*
        config or a :class:`~pyFG.forticonfig.FortiConfig`. The result of the comparison will be how to reach\
        the state represented in the target config (either the *candidate* or *other*) from the *running*\
        config.

        Args:
            * **other** (:class:`~pyFG.forticonfig.FortiConfig`) -- This parameter, if specified, will be used for the\
                comparison. If it is not specified the candidate config will be used.
            * **text** (bool):
                * If ``True`` this method will return a text diff showing how to get from the running config to\
                    the target config.
                * If ``False`` this method will return all the exact commands that needs to be run on the running\
                    config to reach the target config.

        Returns:
            See the explanation of the *text* arg in the section Args.

        """
        if other is None:
            other = self.candidate_config

        if not text:
            return self.running_config.compare_config(other)
        else:
            diff = Differ()
            result = diff.compare(
                self.running_config.to_text().splitlines(),
                other.to_text().splitlines()
            )
            return '\n'.join(result)

def diff(request, page_info):
    try:
        id0 = request.GET['diff_1']
        id1 = request.GET['diff_2']
        submit0 = Web.get_result_details(submit=Submit(int(id0)))
        submit1 = Web.get_result_details(submit=Submit(int(id1)))
        submits = [submit0,submit1]
    except:
        return HttpResponseRedirect(reverse('results',args=[unicode(page_info.contest.id)]))
    bar = StatusBar()
    codes = []
    ok = True
    for i in [0,1]:
        codes.append(submits[i].data)
        if codes[i]==None or codes[i]=="":
            ok = False
            bar.errors.append('Could not render submit '+unicode(submits[i].submit.id)+'!')
    diff_html = ""
    if ok:
        d = Differ()
        for line in d.compare(codes[1].splitlines(True),codes[0].splitlines(True)):
            if line[0]=='?':
                continue
            css = 'highlight_back'
            if line[0]=='+':
                css = 'highlight_pos'
            if line[0]=='-':
                css = 'highlight_neg'
            diff_html += '<span class="'+css+'">'+escape(line)+'</span>'
    return render_to_response('viewdiff.html',{'page_info' : page_info, 'submits' : submits, 'diff' : diff_html, 'status_bar' : bar})

def mergeDiff(global_, mooncake):
    if global_.strip() == "":
        return ["<!-- keep by customization: begin -->\n", mooncake+"\n", "<!-- keep by customization: end -->\n"]
    leadingBlank = global_.find(global_.strip())
    if global_.strip() == mooncake.strip():
        return [global_ + "\n"]
    globalText = handlePunctuation(global_.strip().split(" "))
    mooncakeText = handlePunctuation(mooncake.strip().split(" "))
    differ = Differ()
    diff = list(differ.compare(globalText, mooncakeText))
    i = 0
    result = []
    while i < len(diff):
        if diff[i][0] == " ":
            result.append(diff[i][2:])
            i += 1
        elif diff[i][0] == "-":
            result.append("<!-- deleted by customization")
            while i < len(diff) and diff[i][0] == "-":
                result.append(diff[i][2:])
                i += 1
            result.append("-->")
        elif diff[i][0] == "+":
            result.append("<!-- keep by customization: begin -->")
            while i < len(diff) and diff[i][0] == "+":
                result.append(diff[i][2:])
                i += 1
            result.append("<!-- keep by customization: end -->")
        else:
            i += 1
    text, count, percentage = mergeDeleteAndKeep2(result)
    if ((count < 0.1*float(len(globalText)) or count == 1) and percentage < 0.5) or global_.strip().find(mooncake.strip()) != -1 or mooncake.strip().find(global_.strip()) != -1:
        return [global_[:leadingBlank]+text.replace(" \b","").replace("\b","").replace("--> <!--", "--><!--")]
    
    return ["<!-- deleted by customization\n", global_+"\n", "-->\n", "<!-- keep by customization: begin -->\n", mooncake+"\n", "<!-- keep by customization: end -->\n"]

def diff_lines(old, new):
    d = Differ()
    diff = list(d.compare(old, new))
    for line in diff[:]:
        if line.startswith(" "):
            diff.remove(line)

    return diff

def diff(dir1, dir2, fn1, fn2):
	filenames_list1 = sorted(map(fn1, os.listdir(dir1)))
	filenames_list2 = sorted(map(fn2, os.listdir(dir2)))

	df = Differ()
	result = df.compare(filenames_list1, filenames_list2)
	with open(OUTPUT_FILE, 'w') as f:
		f.write('\n'.join(result))

def diff_inside(_dir, type1, type2):
	files =  os.listdir(_dir)
	filenames_list1 = sorted(map(lambda x:x.replace(type1, ''), filter(lambda f: f.endswith(type1), files)))
	filenames_list2 = sorted(map(lambda x:x.replace(type2, ''), filter(lambda f: f.endswith(type2), files)))

	df = Differ()
	result = df.compare(filenames_list1, filenames_list2)
	with open(OUTPUT_FILE, 'w') as f:
		f.write('\n'.join(result))

 def assertFileMatches(self, expected, actual):
     areSame = filecmp.cmp(expected, actual)
     if not areSame:
         d = Differ()
         expectedLines = open(expected).readlines()
         actualLines = open(actual).readlines()
         result = list(d.compare(expectedLines, actualLines))
         sys.stdout.writelines(result)
     self.assertTrue(areSame)

def compareWithMooncake(relativePath, text):
    try:
        mooncakefile = open(setting["compare"]["path"]+relativePath)
    except IOError:
        return text
    mooncakeLines = mooncakefile.readlines()
    mooncakefile.close()
    if len(mooncakeLines) == 0 or mooncakeLines[0].strip() == "<!-- not suitable for Mooncake -->":
        return "".join(mooncakeLines)
    i=0
    remodeKeepLines = []
    keepCount = 0
    keeps = {}
    while i < len(mooncakeLines):
        if mooncakeLines[i].strip() == "<!-- keep by customization: begin -->":
            remodeKeepLines.append("<!-- keep by customization: begin -->\n")
            remodeKeepLines.append(str(keepCount)+"\n")
            keepCount+=1
            i+=1
            keepStr = ""
            while mooncakeLines[i].strip() != "<!-- keep by customization: end -->":
                keepStr +=  mooncakeLines[i]
                i+=1
            keeps["<!-- keep by customization: begin -->\n"+str(keepCount-1)+"\n"+mooncakeLines[i]] = "<!-- keep by customization: begin -->\n"+keepStr+"<!-- keep by customization: end -->\n"
        remodeKeepLines.append(mooncakeLines[i])
        i+=1
    differ = Differ()
    lines = [x+"\n" for x in text.split("\n")]
    lines[len(lines)-1] = lines[len(lines)-1][0:len(lines[len(lines)-1])-1]
    diff = list(differ.compare(remodeKeepLines, lines))
    i = 0
    result = ""
    while i<len(diff):
        if diff[i][0] == " ":
            result+=diff[i][2:]
        elif diff[i][0] == "+":
            if diff[i][1:] == " ":
                if i+1<len(diff) and diff[i+1][0] == "-" and diff[i+1][1:].strip() == "":
                    result+="\n"
                i+=1
                continue
            elif i+1<len(diff) and diff[i+1].strip() == "- <!-- keep by customization: begin -->":
                i+=1
                continue
            elif i+1<len(diff) and diff[i+1][0] == "-":
                result+=handleOneLine3(diff, i)[2:]
                i+=1
            else:
                result+=diff[i][2:]
        elif diff[i][0] == "-":
            update = checkUpdate(diff, i)
            result+=update[0][2:]
            i+=update[1]
        i+=1
    for k, v in keeps.items():
        result = result.replace(k,v);
    return result