pylint: upgrade to 1.4.0

third_party/pylint/checkers/similar.py

 # pylint: disable=W0622
 # Copyright (c) 2004-2013 LOGILAB S.A. (Paris, FRANCE).
 # http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
 # This program is free software; you can redistribute it and/or modify it under
 # the terms of the GNU General Public License as published by the Free Software
 # Foundation; either version 2 of the License, or (at your option) any later
 # version.
 #
 # This program is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details
 #
 # You should have received a copy of the GNU General Public License along with
 # this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """a similarities / code duplication command line tool and pylint checker
 """
+from __future__ import print_function
 import sys
-from itertools import izip
+from collections import defaultdict
 
 from logilab.common.ureports import Table
 
 from pylint.interfaces import IRawChecker
 from pylint.checkers import BaseChecker, table_lines_from_stats
 
+import six
+from six.moves import zip
+
 
 class Similar(object):
     """finds copy-pasted lines of code in a project"""
 
     def __init__(self, min_lines=4, ignore_comments=False,
                  ignore_docstrings=False, ignore_imports=False):
         self.min_lines = min_lines
         self.ignore_comments = ignore_comments
         self.ignore_docstrings = ignore_docstrings
         self.ignore_imports = ignore_imports
@@ skipping 14 matching lines @@
                                          self.ignore_imports))
         except UnicodeDecodeError:
             pass
 
     def run(self):
         """start looking for similarities and display results on stdout"""
         self._display_sims(self._compute_sims())
 
     def _compute_sims(self):
         """compute similarities in appended files"""
-        no_duplicates = {}
+        no_duplicates = defaultdict(list)
         for num, lineset1, idx1, lineset2, idx2 in self._iter_sims():
-            duplicate = no_duplicates.setdefault(num, [])
+            duplicate = no_duplicates[num]
             for couples in duplicate:
                 if (lineset1, idx1) in couples or (lineset2, idx2) in couples:
                     couples.add((lineset1, idx1))
                     couples.add((lineset2, idx2))
                     break
             else:
                 duplicate.append(set([(lineset1, idx1), (lineset2, idx2)]))
         sims = []
-        for num, ensembles in no_duplicates.iteritems():
+        for num, ensembles in six.iteritems(no_duplicates):
             for couples in ensembles:
                 sims.append((num, couples))
         sims.sort()
         sims.reverse()
         return sims
 
     def _display_sims(self, sims):
         """display computed similarities on stdout"""
         nb_lignes_dupliquees = 0
         for num, couples in sims:
-            print
-            print num, "similar lines in", len(couples), "files"
+            print()
+            print(num, "similar lines in", len(couples), "files")
             couples = sorted(couples)
             for lineset, idx in couples:
-                print "==%s:%s" % (lineset.name, idx)
+                print("==%s:%s" % (lineset.name, idx))
             # pylint: disable=W0631
             for line in lineset._real_lines[idx:idx+num]:
-                print "  ", line.rstrip()
+                print("  ", line.rstrip())
             nb_lignes_dupliquees += num * (len(couples)-1)
         nb_total_lignes = sum([len(lineset) for lineset in self.linesets])
-        print "TOTAL lines=%s duplicates=%s percent=%.2f" \
+        print("TOTAL lines=%s duplicates=%s percent=%.2f" \
             % (nb_total_lignes, nb_lignes_dupliquees,
-               nb_lignes_dupliquees*100. / nb_total_lignes)
+               nb_lignes_dupliquees*100. / nb_total_lignes))
 
     def _find_common(self, lineset1, lineset2):
         """find similarities in the two given linesets"""
         lines1 = lineset1.enumerate_stripped
         lines2 = lineset2.enumerate_stripped
         find = lineset2.find
         index1 = 0
         min_lines = self.min_lines
         while index1 < len(lineset1):
             skip = 1
             num = 0
             for index2 in find(lineset1[index1]):
                 non_blank = 0
                 for num, ((_, line1), (_, line2)) in enumerate(
-                        izip(lines1(index1), lines2(index2))):
+                        zip(lines1(index1), lines2(index2))):
                     if line1 != line2:
                         if non_blank > min_lines:
                             yield num, lineset1, index1, lineset2, index2
                         skip = max(skip, num)
                         break
                     if line1:
                         non_blank += 1
                 else:
                     # we may have reach the end
                     num += 1
@@ skipping 79 matching lines @@
             #if line:
             yield idx, line
             idx += 1
 
     def find(self, stripped_line):
         """return positions of the given stripped line in this set"""
         return self._index.get(stripped_line, ())
 
     def _mk_index(self):
         """create the index for this set"""
-        index = {}
+        index = defaultdict(list)
         for line_no, line in enumerate(self._stripped_lines):
             if line:
-                index.setdefault(line, []).append(line_no)
+                index[line].append(line_no)
         return index
 
 
 MSGS = {'R0801': ('Similar lines in %s files\n%s',
                   'duplicate-code',
                   'Indicates that a set of similar lines has been detected \
                   among multiple file. This usually means that the code should \
                   be refactored to avoid this duplication.')}
 
 def report_similarities(sect, stats, old_stats):
@@ skipping 92 matching lines @@
         stats['nb_duplicated_lines'] = duplicated
         stats['percent_duplicated_lines'] = total and duplicated * 100. / total
 
 
 def register(linter):
     """required method to auto register this checker """
     linter.register_checker(SimilarChecker(linter))
 
 def usage(status=0):
     """display command line usage information"""
-    print "finds copy pasted blocks in a set of files"
-    print
-    print 'Usage: symilar [-d|--duplicates min_duplicated_lines] \
-[-i|--ignore-comments] [--ignore-docstrings] [--ignore-imports] file1...'
+    print("finds copy pasted blocks in a set of files")
+    print()
+    print('Usage: symilar [-d|--duplicates min_duplicated_lines] \
+[-i|--ignore-comments] [--ignore-docstrings] [--ignore-imports] file1...')
     sys.exit(status)
 
 def Run(argv=None):
     """standalone command line access point"""
     if argv is None:
         argv = sys.argv[1:]
     from getopt import getopt
     s_opts = 'hdi'
     l_opts = ('help', 'duplicates=', 'ignore-comments', 'ignore-imports',
               'ignore-docstrings')
@@ skipping 16 matching lines @@
     if not args:
         usage(1)
     sim = Similar(min_lines, ignore_comments, ignore_docstrings, ignore_imports)
     for filename in args:
         sim.append_stream(filename, open(filename))
     sim.run()
     sys.exit(0)
 
 if __name__ == '__main__':
     Run()