Ejemplo n.º 1
0
def findex():
    fform = FileForm()
    tform = TextForm()
    set_fform = 'True'
    if fform.validate_on_submit():
        filename1 = secure_filename(fform.File1.data.filename)
        fform.File1.data.save(uppath + filename1)
        filename2 = secure_filename(fform.File2.data.filename)
        fform.File2.data.save(uppath + filename2)
        with open(uppath + filename1, 'r') as f1, open(uppath + filename2,
                                                       'r') as f2:
            cmp = difflib.HtmlDiff()
            cmp_result = cmp.make_file(f1, f2)
        os.remove(uppath + filename1)
        os.remove(uppath + filename2)
        return cmp_result.encode('utf-8')
    return render_template('index.html',
                           fform=fform,
                           tform=tform,
                           set_fform=set_fform)
Ejemplo n.º 2
0
def compareFile(filename1, filename2):
    if filename1 == "" or filename2 == "":
        print "Usage:om_file_comp.py comfile1 comfile2"
        sys.exit(1)

    lines1 = readFile(filename1)
    lines2 = readFile(filename2)
    d = difflib.HtmlDiff()
    try:
        htmlFile = str(filename1).split("/")[-1] + 'temp.html'
        fileHandle = open(htmlFile, 'w')
        t = d.make_file(lines1, lines2)
        fileHandle.write(t)
        fileHandle.close()
    except IOError as error:
        print('Read file Error:' + str(error))
        sys.exit(1)

    #调用修改
    changeCode(filename1 + 'temp.html')
Ejemplo n.º 3
0
def diff_table(content_from, content_to, prev_id, curr_id):
    """Creates an HTML diff of the passed in content_from and content_to."""
    tidy_from, errors = _massage_diff_content(content_from)
    tidy_to, errors = _massage_diff_content(content_to)
    html_diff = difflib.HtmlDiff(wrapcolumn=DIFF_WRAP_COLUMN)
    from_lines = tidy_from.splitlines()
    to_lines = tidy_to.splitlines()
    try:
        diff = html_diff.make_table(
            from_lines,
            to_lines,
            _("Revision %s") % prev_id,
            _("Revision %s") % curr_id,
            context=True,
            numlines=constance.config.DIFF_CONTEXT_LINES)
    except RuntimeError:
        # some diffs hit a max recursion error
        message = _(u'There was an error generating the content.')
        diff = '<div class="warning"><p>%s</p></div>' % message
    return jinja2.Markup(diff)
Ejemplo n.º 4
0
    def compare_file(self):
        """比较两个文件并把结果生成一份html文本"""
        name_list = self.get_same_name_file()
        for file_name in name_list:
            text1_lines = self.read_file(os.path.join(self.file_dir1, file_name))
            text2_lines = self.read_file(os.path.join(self.file_dir2, file_name))

            diff = difflib.HtmlDiff()  # 创建HtmlDiff 对象
            result = diff.make_file(text1_lines, text2_lines)  # 通过make_file 方法输出 html 格式的对比结果

            current_path = os.path.dirname(os.path.abspath(__file__))
            report_path = os.path.join(current_path, 'resultreport')
            report_file_path = os.path.join(report_path, f'result_({file_name}).html')
            # 将结果写入到result_.html文件中
            try:
                with open(report_file_path, 'w') as result_file:
                    result_file.write(result)
                    print(f"{file_name} Successfully Finished")
            except IOError as error:
                print('写入html文件错误:{0}'.format(error))
Ejemplo n.º 5
0
def perform_diff(modeladmin, request, queryset):
    opts = modeladmin.model._meta
    count = queryset.count()
    if count != 2:
        raise Exception("You can only compare 2 outputs")
    else:

        from_output = queryset[0]
        to_output = queryset[1]
        import difflib
        d = difflib.HtmlDiff()
        table = d.make_table(
            from_output.result.splitlines(), to_output.result.splitlines(),
            "%s<br/>%s<br/>%s" % (from_output.job.command.command,
                                  from_output.node, from_output.updated_on),
            "%s<br/>%s<br/>%s" % (to_output.job.command.command,
                                  to_output.node, to_output.updated_on))
        return render_to_response("admin/ncm/full_diff.html", {'diff': table})

    perform_diff.short_description = description
Ejemplo n.º 6
0
    def compare_results(self, act_res_path, exp_res_path):
        dcmp = dircmp(act_res_path, exp_res_path)

        match_files_list = []
        diff_files_list = []

        for name in dcmp.same_files:
            #print "Matching Data file \"%s\", Expected Res:\"%s\" and Actual Res \"%s\":-" %(name, dcmp.left, dcmp.right)
            match_files_list.append(name)

        for name in dcmp.diff_files:
            #print "Matching Data file \"%s\", Expected Res:\"%s\" and Actual Res \"%s\":-" %(name, dcmp.left, dcmp.right)
            diff_files_list.append(name)

        res_file = open("results.html", "wa", 0)
        sys.stdout = res_file

        print "Data files with inconsistency in results are: <br>"
        for counter in range(len(diff_files_list)):
            print "(", counter + 1, ") ", diff_files_list[counter], "<br>"

        for i in range(len(diff_files_list)):
            act_res_file_path = act_res_path + diff_files_list[i]
            exp_res_file_path = exp_res_path + diff_files_list[i]

            act_res_file = open(act_res_file_path, 'r')
            exp_res_file = open(exp_res_file_path, 'r')

            act_res_line = act_res_file.readlines()
            exp_res_line = exp_res_file.readlines()

            diff = difflib.HtmlDiff().make_file(act_res_line, exp_res_line)

            print "<br><br>Displaying the Difference in Result Set <br>"
            print "Actual Result File : %s <br>" % (act_res_file_path)
            print "Expected Result File: %s <br>" % (exp_res_file_path)
            print "<br>"
            sys.stdout.writelines(diff)

        act_res_file.close()
        exp_res_file.close()
Ejemplo n.º 7
0
def findOriginalpath(FindpathFilename, f1, f2, log_path):
    # print "++++现实文档文件++++"
    for root, dirs, files in os.walk(f2):
        for fileName in files:
            compare_filename = fileName
            #对比的文件名
            try:
                if compare_filename == FindpathFilename:
                    #difflib生成报告
                    ori = readfile(f2 + "/" + fileName)
                    stan = readfile(f1 + "/" + fileName)
                    diff = difflib.HtmlDiff()
                    p_txt = diff.make_file(stan, ori, context=True, numlines=0)

                    #创建报告文件
                    f = open(log_path + "/" + "diff.html", 'a')
                    #............
                    f.write("<meta charset='UTF-8'>")
                    f.write("<a>这是" + fileName + "的对比不同的地方:</a>")
                    #解决中文乱码
                    f.write(p_txt)
                    f.close()
                    #-------------
                    #创建报告文件HTML
                    #---------
                    #创建log文档方便shell查看
                    stan_lines = stan
                    ori_lines = ori
                    d = difflib.Differ()
                    log_diff = d.compare(stan_lines, ori_lines)
                    open_log = open(log_path + "/" + "diff.log", 'a')
                    open_log.write('\n' + "#这是" + fileName + "的对比不同的地方:<->" +
                                   '\n')
                    open_log.write('\n'.join(list(log_diff)))
                    open_log.close()
                    #创建log文档方便shell查看

                else:
                    exit()
            except:
                StandardError
Ejemplo n.º 8
0
def FileDiff(file1, file2, HtmlFileName,
             options):  #File1 = FileName of File1 / #File2 = FileName of File2
    fromdate = time.ctime(os.stat(file1).st_mtime)
    todate = time.ctime(os.stat(file2).st_mtime)
    fromlines = open(file1, 'U').readlines()
    tolines = open(file2, 'U').readlines()

    if options == 'u':
        diff = difflib.unified_diff(fromlines,
                                    tolines,
                                    file1,
                                    file2,
                                    fromdate,
                                    todate,
                                    n=n)
    elif options == 'n':
        diff = difflib.ndiff(fromlines, tolines)
    elif options == 'm':

        diff = difflib.HtmlDiff().make_file(fromlines,
                                            tolines,
                                            file1,
                                            file2,
                                            context=options,
                                            numlines=3)
    else:
        diff = difflib.context_diff(fromlines,
                                    tolines,
                                    file1,
                                    file2,
                                    fromdate,
                                    todate,
                                    n=n)

    orig_stdout = sys.stdout
    #f = file('index.html', 'w') # Old Index.html File here
    f = file(HtmlFileName, 'w')
    sys.stdout = f
    sys.stdout.writelines(diff)
    sys.stdout = orig_stdout
    f.close()
Ejemplo n.º 9
0
    def diff(self, url, original_code, new_code):
        diff_data = ""

        # Prep the two code blocks, after expanding into readable segments
        options = {
            "keep_function_indentation": True,
            "keep_array_indentation": True,
            "jslint_happy": True
        }

        beautiful_old_code = jsbeautifier.beautify(original_code, options).splitlines()
        beautiful_new_code = jsbeautifier.beautify(new_code, options).splitlines()      

        if self.mode == CodeDifferMode.UNIFIED:
            delta = difflib.unified_diff(
                beautiful_old_code, beautiful_new_code,
                fromfile="before", tofile="after",
                lineterm="")

            # Create copies of the iterator so we can manipulate the colored one
            # seperately without storing it to the database with the ansi chars
            raw_delta, color_delta = tee(delta)

            diff_data = '\n'.join(raw_delta)
            
            if self.console:
                print( "[CHANGED FILE] {0}".format(url))
                color_diff = self.__color_diff(color_delta)            
                print('\n'.join(color_diff))
            
            return diff_data
        else:
            # Generate an HTML diff file
            differ = difflib.HtmlDiff()
            diff_data = differ.make_file( beautiful_old_code, beautiful_new_code )
            
            if self.console:
                print( "[CHANGED FILE] {0}".format(url))
                print(diff_data)

            return diff_data
Ejemplo n.º 10
0
def view_paste(request, uniqid):
    try:  # Teste la présence du paste
        paste = Pastebin.objects.get(uniqid=uniqid)
    except Pastebin.DoesNotExist:  # il n'existe pas, on renvoie sur l'accueil
        return HttpResponseRedirect('pastebin-1.html')

    author_m = paste.author_m

    # L'utilisateur peut-il modifier le paste ?
    if request.user.is_authenticated():
        can_edit_paste = (request.user.has_perm('pastebin.edit_all_pastes')
                          or paste.author == request.user.get_profile())
    else:
        can_edit_paste = False

    # Passage à la template
    data = {
        'uniqid': uniqid,
        'contents': paste.contents,
        'can_edit_paste': can_edit_paste,
        'paste': paste
    }

    # Gestion du diff
    if paste.author_m_id:
        contents_old = paste.contents_m

        # Generation du diff Html
        df = difflib.HtmlDiff().make_table(paste.contents_m.split('\n'),
                                           paste.contents.split('\n'),
                                           _('Ancienne version'),
                                           _('Nouvelle version'))

        # On enlève les nowrap
        df = df.replace('nowrap="nowrap"', '')

        # Template pour le diff
        data['contents_old'] = contents_old
        data['difftable'] = df

    return tpl('pastebin/view.html', data, request)
Ejemplo n.º 11
0
def json_compare(ret_obj1, ret_obj2, deleted_keys=[]):
    ret_obj = {
        'rc': 0,
        'data': {
            'matches': False,
            'difference': '',
            'deleted_keys': deleted_keys
        },
        'changed': False,
        'warnings': []
    }

    # Pick the highest RC to return (should not matter either way)
    if ret_obj1['rc'] > ret_obj2['rc']:
        ret_obj['rc'] = ret_obj1['rc']
    else:
        ret_obj['rc'] = ret_obj2['rc']

    if 'warnings' in ret_obj1 and ret_obj1['warnings']:
        ret_obj['warnings'].append(ret_obj1['warnings'])
    if 'warnings' in ret_obj2 and ret_obj2['warnings']:
        ret_obj['warnings'].append(ret_obj2['warnings'])

    sorted_json1 = json_sort(ret_obj1['data'])
    sorted_json2 = json_sort(ret_obj2['data'])

    if sorted_json1 == sorted_json2:
        ret_obj['data']['matches'] = True
    else:
        psj1 = pprint.pformat(sorted_json1)
        logger.debug('Sorted JSON1 to Compare: \n' + psj1)
        psj2 = pprint.pformat(sorted_json2)
        logger.debug('Sorted JSON2 to Compare: \n' + psj2)
        diff = difflib.ndiff(psj1.split('\n'), psj2.split('\n'))
        ret_obj['data']['difference'] = '\n'.join(diff)
        ret_obj['data']['context_difference'] = list(
            difflib.context_diff(psj1.split('\n'), psj2.split('\n')))
        ret_obj['data']['html_difference'] = difflib.HtmlDiff().make_file(
            psj1.split('\n'), psj2.split('\n'), context=True)

    return ret_obj
Ejemplo n.º 12
0
	def run(self):
		logger = self.logger
		first_file = self.options['FIRSTFILE']
		first_file = open(first_file, 'r')
		second_file = self.options['SECONDFILE']
		second_file = open(second_file, 'r')
		self.report = open(self.options['REPORTFILE'], 'w', 1)
		self.differ = difflib.HtmlDiff()
		self.tables_to_skip = [
			c1219.constants.PROC_INITIATE_TBL,
			c1219.constants.PROC_RESPONSE_TBL,
			c1219.constants.PRESENT_REGISTER_DATA_TBL
		]

		self.report.write(HTML_HEADER)
		self.report.write(HTML_TABLE_LEGEND)
		self.report.write('<br />\n')
		self.report.write(HTML_TABLE_HEADER)
		self.highlight_table = True

		self.frmwk.print_status('Generating Diff...')
		fid, fline = self.get_line(first_file)
		sid, sline = self.get_line(second_file)
		while (fid != None) or (sid != None):
			if (fid == None or sid == None) or (fid == sid):
				self.report_line(fline, sline, (fid or sid))
				fid, fline = self.get_line(first_file)
				sid, sline = self.get_line(second_file)
			elif fid < sid:
				self.report_line(fline, '', fid)
				fid, fline = self.get_line(first_file)
			elif sid < fid:
				self.report_line('', sline, sid)
				sid, sline = self.get_line(second_file)

		self.report.write(HTML_TABLE_FOOTER)
		self.report.write(HTML_FOOTER)
		self.report.close()
		second_file.close()
		first_file.close()
		return
Ejemplo n.º 13
0
    def compare(self, session=None):
        conf1 = {}
        conf2 = {}
        conf = None
        dcmp_dag = None
        dag_name = request.args.get("dag_name")
        if dag_name and len(dag_name) > 0:
            # 增加限制非有权限的用户dagid,不能查看
            if (not wwwutils.get_filter_by_user_dagid(dag_name)):
                return render_template('airflow/circles.html',
                                       hostname=socket.getfqdn())

        version1 = request.args.get("version1")
        version2 = request.args.get("version2")
        if dag_name:
            dcmp_dag = session.query(DcmpDag).filter(
                DcmpDag.dag_name == dag_name, ).first()
            if dcmp_dag:
                conf = dcmp_dag.get_conf(session=session)
                conf1 = dcmp_dag.get_conf(version=version1, session=session)
                conf2 = dcmp_dag.get_conf(version=version2, session=session)

                dcmp_dag_confs = session.query(DcmpDagConf).filter(
                    DcmpDagConf.dag_id == dcmp_dag.id, ).order_by(
                        DcmpDagConf.version.desc())

        diff_table = difflib.HtmlDiff().make_table(
            self.conf_diff_preprocess(conf1),
            self.conf_diff_preprocess(conf2),
        )
        if conf is None:
            conf = self.DEFAULT_CONF
        return self.render("dcmp/compare.html",
                           can_access_approver=can_access_approver(),
                           diff_table=diff_table,
                           conf=conf,
                           version1=version1,
                           version2=version2,
                           dcmp_dag=dcmp_dag,
                           dcmp_dag_confs=dcmp_dag_confs,
                           command_render=command_render)
Ejemplo n.º 14
0
 def _get_diff(self, v1, v2):
     """Return the difference between two version of document version."""
     text1 = v1 and self.browse(v1).content or ""
     text2 = v2 and self.browse(v2).content or ""
     # Include line breaks to make it more readable
     # TODO: consider using a beautify library directly on the content
     text1 = text1.replace("</p><p>", "</p>\r\n<p>")
     text2 = text2.replace("</p><p>", "</p>\r\n<p>")
     line1 = text1.splitlines(True)
     line2 = text2.splitlines(True)
     if line1 == line2:
         return _("There are no changes in revisions.")
     else:
         diff = difflib.HtmlDiff()
         return diff.make_table(
             line1,
             line2,
             "Revision-{}".format(v1),
             "Revision-{}".format(v2),
             context=True,
         )
Ejemplo n.º 15
0
def diff_table(content_from, content_to, prev_id, curr_id, tidy=False):
    """
    Creates an HTML diff of the passed in content_from and content_to.
    """
    if tidy:
        content_from, errors = tidy_content(content_from)
        content_to, errors = tidy_content(content_to)

    html_diff = difflib.HtmlDiff(wrapcolumn=DIFF_WRAP_COLUMN)
    try:
        diff = html_diff.make_table(content_from.splitlines(),
                                    content_to.splitlines(),
                                    ugettext('Revision %s') % prev_id,
                                    ugettext('Revision %s') % curr_id,
                                    context=True,
                                    numlines=config.DIFF_CONTEXT_LINES)
    except RuntimeError:
        # some diffs hit a max recursion error
        message = ugettext('There was an error generating the content.')
        diff = '<div class="warning"><p>%s</p></div>' % message
    return jinja2.Markup(diff)
Ejemplo n.º 16
0
def run2(year, month, t1, t2, mf_dict, ss_dict, ss, lock):
    t1.join()
    t2.join()
    lock.acquire()
    print(str(year) + '/' + str(month))
    mfdata = mf_dict[str(year) + '/' + str(month)]
    sdata = ss_dict[str(year) + '/' + str(month)]
    if sdata == mfdata:
        print('SAME')
    elif len(mfdata) == 0:
        print('MoneyForward No Data')
    else:
        print('There is diff\nUpdate sheet')
        fname = 'diff' + str(month) + '.html'
        d = difflib.HtmlDiff()
        with open(fname, mode='w') as f:
            f.write(
                d.make_file([', '.join(map(str, i)) for i in mfdata],
                            [', '.join(map(str, i)) for i in sdata]))
        ss.merge(year, month, mfdata)
    lock.release()
Ejemplo n.º 17
0
class FileDiff(GeoffreyPlugin):

    diff = difflib.HtmlDiff()
    files = {}

    def run(self, filename):
        with magic.Magic(flags=magic.MAGIC_MIME_TYPE) as m:
            file_type = m.id_filename(filename)
            if not fnmatch(file_type, '*text*'):
                return False

        with open(filename, 'r') as f:
            content = f.readlines()

        if filename in self.files:
            if self.files[filename] != content:
                output = HTML(
                    self.diff.make_table(self.files[filename], content))
                yield from self.output_queue.put(output)

        self.files[filename] = content
Ejemplo n.º 18
0
def file_cmp(path1, path2):
    filename1 = get_filename(path1)
    filename2 = get_filename(path2)

    file1_line = open(path1).readlines()
    file2_line = open(path2).readlines()
    str1 = open(path1).read()
    str2 = open(path2).read()
    f = open("tmp/" + filename1 + "_" + filename2 + "_cmp.html", 'w')
    d = difflib.HtmlDiff()
    f.write(d.make_file(file1_line, file2_line))
    f.close()
    matcher = difflib.SequenceMatcher(None, file1_line, file2_line).ratio()
    # 计算莱文斯坦比
    sim2 = Levenshtein.ratio(str1, str2)
    # 计算jaro距离
    sim3 = Levenshtein.jaro(str1, str2)
    # Jaro–Winkler距离
    sim4 = Levenshtein.jaro_winkler(str1, str2)
    matcher = matcher * 0.25 + sim2 * 0.25 + sim3 * 0.25 + sim4 * 0.25
    return matcher
Ejemplo n.º 19
0
 def html_diff(self, context=True, wrapcolumn=40):
     """Return an HTML table showing differences"""
     # difflib is not Unicode-aware, so we need to force everything to
     # utf-8 manually
     a = [
         safe_unicode(i)
         for i in self._parseField(self.oldValue, filename=self.oldFilename)
     ]
     b = [
         safe_unicode(i)
         for i in self._parseField(self.newValue, filename=self.newFilename)
     ]
     vis_diff = difflib.HtmlDiff(wrapcolumn=wrapcolumn)
     diff = vis_diff.make_table(a,
                                b,
                                safe_unicode(self.id1),
                                safe_unicode(self.id2),
                                context=context)
     if six.PY2:
         diff = safe_utf8(diff)
     return diff
Ejemplo n.º 20
0
def make_html_diff(fromfile, tofile):
    import difflib

    with open(fromfile) as fh:
        fromlines = fh.readlines()
    with open(tofile) as fh:
        tolines = fh.readlines()

    diff = difflib.HtmlDiff().make_file(fromlines,
                                        tolines,
                                        fromfile,
                                        tofile,
                                        context=True,
                                        numlines=3)

    # writelines because diff is a generator
    _, tmp_path = tempfile.mkstemp(text=True, suffix=".html")
    with open(tmp_path, "w") as fh:
        fh.writelines(diff)

    return tmp_path
Ejemplo n.º 21
0
def create_diff_csv(referenced_msg, compared_msgs):
    hd = difflib.HtmlDiff()
    html = hd.make_file(referenced_msg, compared_msgs)
    lines = parse_side_by_side(html)
    csvlist = []
    for i in range(0, len(lines), 2):
        if lines[i].text == '':
            origline = ','
        else:
            origline = lines[i].text
        if lines[i + 1].text == '':
            revline = ','
        else:
            revline = lines[i + 1].text
            L = []
            L.append(origline.replace('\xa0', '\x20'))
            L.append(',')
            L.append(revline.replace('\xa0', '\x20'))
            L.append('\n')
            csvlist.append(''.join(L))
    return csvlist
Ejemplo n.º 22
0
def diffTextFiles(fFile,tFile,options):

   # we're passing these as arguments to the diff function
   fDate = time.ctime(stat(fFile).st_mtime)
   tDate = time.ctime(stat(tFile).st_mtime)
   fLines = getFileContent(fFile)
   tLines = getFileContent(tFile)

   if options.unified:
      return difflib.unified_diff(fLines, tLines,
         fFile, tFile, fDate, tDate, n=options.ablines)
   elif options.ndiff:
      return difflib.ndiff(fLines, tLines)
   elif options.html:
      return difflib.HtmlDiff().make_file(fLines, tLines,
         fFile, tFile, context=options.context, numlines=options.ablines)
   else:
      return difflib.context_diff(fLines, tLines,
         fFile, tFile, fDate, tDate, n=options.ablines)

   return
Ejemplo n.º 23
0
def run_compare(f1, f2):
    """主函数"""
    # try:
    #     # 获取文件名
    #     f1 = sys.argv[1]
    #     f2 = sys.argv[2]
    # except Exception as e:
    #     print("Error: " + str(e))
    #     print("Usage : python compareFile.py filename1 filename2")
    #     sys.exit()
    # # 参数不够
    # if f1 == "" or f2 == "":
    #     print("Usage : python compareFile.py filename1 filename2")
    #     sys.exit()
    tf1 = read_file(f1)
    tf2 = read_file(f2)

    # 创建一个实例difflib.HtmlDiff
    d = difflib.HtmlDiff()
    # 生成一个比较后的报告文件,格式为html
    write_file(d.make_file(tf1, tf2))
Ejemplo n.º 24
0
def test_tex_file(fn=None, htmldiff=None):
    if fn is None:
        testdir = os.path.split(os.path.realpath(__file__))[0]
        fn = testdir + os.sep + 'test_pub.tex'
    with open(fn) as f:
        orig = f.read().split('\n')
    tfstr = publication.TeXFile(fn)().split('\n')

    diffres = list(difflib.unified_diff(orig, tfstr))
    if htmldiff:
        hd = difflib.HtmlDiff()
        htmlres = hd.make_file(orig, tfstr)
        with open(htmldiff, 'w') as f:
            f.write(htmlres)
    else:
        for l in diffres:
            print l
    assert len(
        diffres
    ) == 0, 'TeXFile string does not match original file ' + os.path.split(
        fn)[1]
Ejemplo n.º 25
0
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('fromfile')
    parser.add_argument('tofile')
    options = parser.parse_args()

    fromfile = options.fromfile
    tofile = options.tofile

    with open(fromfile) as ff:
        fromlines = ff.readlines()
    with open(tofile) as tf:
        tolines = tf.readlines()

    diff = difflib.HtmlDiff().make_file(fromlines,
                                        tolines,
                                        fromfile,
                                        tofile,
                                        charset='utf-8')

    sys.stdout.writelines(diff)
Ejemplo n.º 26
0
    def getDiff(self, cr, uid, v1, v2, context=None):
        """ @param cr: the current row, from the database cursor,
            @param uid: the current user’s ID for security checks, """

        history_pool = self.pool.get('wiki.wiki.history')
        text1 = history_pool.read(cr, uid, [v1], ['text_area'])[0]['text_area']
        text2 = history_pool.read(cr, uid, [v2], ['text_area'])[0]['text_area']
        line1 = line2 = ''
        if text1:
            line1 = tools.ustr(text1.splitlines(1))
        if text2:
            line2 = tools.ustr(text2.splitlines(1))
        if (not line1 and not line2) or (line1 == line2):
            raise osv.except_osv(_('Warning !'),
                                 _('There are no changes in revisions'))
        diff = difflib.HtmlDiff()
        return diff.make_file(line1,
                              line2,
                              "Revision-%s" % (v1),
                              "Revision-%s" % (v2),
                              context=False)
Ejemplo n.º 27
0
    def compare(self, new):
        new_lines = new.splitlines()
        state_lines = self.state.splitlines()

        d = difflib.Differ()
        diff = d.compare(state_lines, new_lines)
        diff = [line for line in diff if str.startswith(line, ("+", "-"))]

        if diff:
            diff_html = difflib.HtmlDiff().make_table(state_lines, new_lines)

            self.logger.info("Creating diff.html")
            with open(self.path + "/resources/diff.html", "w") as f:
                f.write(diff_html)

        self.logger.info("Rewriting state")
        self.state = new
        with open(self.path + "/resources/state.html", "w") as f:
            f.write(self.state)

        return diff
Ejemplo n.º 28
0
    def write(self, test, outdir, result, actual, expected, diff):
        import difflib

        actual_file = open(os.path.join(outdir, actual), 'r')
        expected_file = open(expected, 'r')
        html = difflib.HtmlDiff().make_file(actual_file.readlines(),
                                            expected_file.readlines(),
                                            "Actual",
                                            "Expected",
                                            context=True)
        actual_file.close()
        expected_file.close()

        diffdir = self._create_diff_for_test(outdir, test)
        pretty_diff_name = result + '-pretty-diff.html'
        pretty_diff = os.path.abspath(os.path.join(diffdir, pretty_diff_name))
        f = open(pretty_diff, 'w')
        f.write(html)
        f.close()

        return os.path.join(test, pretty_diff_name)
Ejemplo n.º 29
0
def compare_two_files(textfile1,textfile2):
    text1_lines = readfile(textfile1) 
    text2_lines = readfile(textfile2)
    if textfile1=="" or textfile2=="":
        print ("有文件不存在")
    #输出html格式
    d = difflib.HtmlDiff()
    html=d.make_file(text1_lines, text2_lines)
    
    #直接输出结果
    d2 = difflib.Differ()
    diff = d2.compare(text1_lines, text2_lines)
    compare_line='\n'.join(list(diff))
    #print(compare_line)
    print ('type(html)')
    #保存到html文件中
    save_tempHtml(html)
    #替换文件中的charset=ISO-8859-1为charset=UTF-8
    
    replace_tempHtml(''' content=\"text/html; charset=ISO-8859-1"''','''content="text/html; charset=UTF-8"''')
    conut_str('''td''')
Ejemplo n.º 30
0
def index(request):
    context = {
        'answer': '1',
        'tx1': '1',
        'tx2': '1',
        'issame': "",  # 是否显示
        'hmdistance': '',  # 海明距离,
        'dedistance': '',  # 判断距离,
        'diffe': ''  # 对比结果
    }

    try:
        simhash = SimHash()
        tx1 = (request.POST['tx1'])
        tx2 = (request.POST['tx2'])
        context['tx1'] = tx1
        context['tx2'] = tx2
        if len(tx1) <= 2 or len(tx2) <= 2:
            context['answer'] = "对比文本不能小于2字符"
        else:
            hash1 = simhash.hash(tx1)
            hash2 = simhash.hash(tx2)
            distince = simhash.getDistince(hash1, hash2)
            value = 20
            context['hmdistance'] = distince
            context['dedistance'] = value
            context['issame'] = distince <= value
            res = "海明距离:" + str(distince) + " 判定距离:" + str(
                value) + " 是否相似 " + str(distince <= value)
            context['answer'] = res

            dtx1 = tx1.splitlines()
            dtx2 = tx2.splitlines()
            d = difflib.HtmlDiff()
            dres = d.make_file(dtx1, dtx2, charset="utf-8")
            context['diffe'] = dres
    except KeyError:
        context['answer'] = '空字符串'
        return render(request, 'simhash.html', context)
    return render(request, 'simhash.html', context)