pylint: upgrade to 1.4.0

third_party/pylint/gui.py

 # Copyright (c) 2003-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.
 """Tkinker gui for pylint"""
+from __future__ import print_function
 
 import os
 import sys
 import re
-import Queue
 from threading import Thread
-from Tkinter import (Tk, Frame, Listbox, Entry, Label, Button, Scrollbar,
-                     Checkbutton, Radiobutton, IntVar, StringVar)
-from Tkinter import (TOP, LEFT, RIGHT, BOTTOM, END, X, Y, BOTH, SUNKEN, W,
-                     HORIZONTAL, DISABLED, NORMAL, W)
-from tkFileDialog import askopenfilename, askdirectory
+
+import six
+
+from six.moves.tkinter import (
+    Tk, Frame, Listbox, Entry, Label, Button, Scrollbar,
+    Checkbutton, Radiobutton, IntVar, StringVar,
+    TOP, LEFT, RIGHT, BOTTOM, END, X, Y, BOTH, SUNKEN, W,
+    HORIZONTAL, DISABLED, NORMAL, W,
+)
+from six.moves.tkinter_tkfiledialog import (
+    askopenfilename, askdirectory,
+)
 
 import pylint.lint
 from pylint.reporters.guireporter import GUIReporter
 
 HOME = os.path.expanduser('~/')
 HISTORY = '.pylint-gui-history'
 COLORS = {'(I)':'lightblue',
           '(C)':'blue', '(R)':'darkblue',
           '(W)':'black', '(E)':'darkred',
           '(F)':'red'}
@@ skipping 41 matching lines @@
             self.outdict[self.currout][-1] += text.strip(os.linesep)
         if text.endswith(os.linesep) and text.strip():
             self.contents.append('')
             if self.currout:
                 self.outdict[self.currout].append('')
 
     def fix_contents(self):
         """finalize what the contents of the dict should look like before output"""
         for item in self.outdict:
             num_empty = self.outdict[item].count('')
-            for _ in xrange(num_empty):
+            for _ in range(num_empty):
                 self.outdict[item].remove('')
             if self.outdict[item]:
                 self.outdict[item].pop(0)
 
     def output_contents(self):
         """output contents of dict to the gui, and set the rating"""
         self.fix_contents()
         self.gui.tabs = self.outdict
         try:
             self.gui.rating.set(self.outdict['Global evaluation'][0])
-        except:
+        except KeyError:
             self.gui.rating.set('Error')
         self.gui.refresh_results_window()
 
         #reset stream variables for next run
         self.contents = []
         self.outdict = {}
         self.currout = None
         self.next_title = None
 
 
 class LintGui(object):
     """Build and control a window to interact with pylint"""
 
     def __init__(self, root=None):
         """init"""
         self.root = root or Tk()
         self.root.title('Pylint')
         #reporter
         self.reporter = None
         #message queue for output from reporter
-        self.msg_queue = Queue.Queue()
+        self.msg_queue = six.moves.queue.Queue()
         self.msgs = []
         self.visible_msgs = []
         self.filenames = []
         self.rating = StringVar()
         self.tabs = {}
         self.report_stream = BasicStream(self)
         #gui objects
         self.lb_messages = None
         self.showhistory = None
         self.results = None
@@ skipping 182 matching lines @@
             'I': lambda: self.information_box.get() == 1,
             'C': lambda: self.convention_box.get() == 1,
             'R': lambda: self.refactor_box.get() == 1,
             'E': lambda: self.error_box.get() == 1,
             'W': lambda: self.warning_box.get() == 1,
             'F': lambda: self.fatal_box.get() == 1
         }
         self.txt_module.focus_set()
 
 
-    def select_recent_file(self, event):
+    def select_recent_file(self, event): # pylint: disable=unused-argument
         """adds the selected file in the history listbox to the Module box"""
         if not self.showhistory.size():
             return
 
         selected = self.showhistory.curselection()
         item = self.showhistory.get(selected)
         #update module
         self.txt_module.delete(0, END)
         self.txt_module.insert(0, item)
 
@@ skipping 10 matching lines @@
                 fg_color = COLORS.get(msg_str[:3], 'black')
                 self.lb_messages.itemconfigure(END, fg=fg_color)
 
     def refresh_results_window(self):
         """refresh the results window with current output"""
         #clear the window
         self.results.delete(0, END)
         try:
             for res in self.tabs[self.box.get()]:
                 self.results.insert(END, res)
-        except:
+        except KeyError:
             pass
 
     def process_incoming(self):
         """process the incoming messages from running pylint"""
         while self.msg_queue.qsize():
             try:
                 msg = self.msg_queue.get(0)
                 if msg == "DONE":
                     self.report_stream.output_contents()
                     return False
 
                 #adding message to list of msgs
                 self.msgs.append(msg)
 
                 #displaying msg if message type is selected in check box
                 if self.msg_type_dict.get(msg.C)():
                     self.visible_msgs.append(msg)
                     msg_str = convert_to_string(msg)
                     self.lb_messages.insert(END, msg_str)
                     fg_color = COLORS.get(msg_str[:3], 'black')
                     self.lb_messages.itemconfigure(END, fg=fg_color)
 
-            except Queue.Empty:
+            except six.moves.queue.Empty:
                 pass
         return True
 
     def periodic_call(self):
         """determine when to unlock the run button"""
         if self.process_incoming():
             self.root.after(100, self.periodic_call)
         else:
             #enabling button so it can be run again
             self.btnRun.config(state=NORMAL)
 
     def mainloop(self):
         """launch the mainloop of the application"""
         self.root.mainloop()
 
     def quit(self, _=None):
         """quit the application"""
         self.root.quit()
 
-    def halt(self):
+    def halt(self): # pylint: disable=no-self-use
         """program halt placeholder"""
         return
 
     def file_open(self, package=False, _=None):
         """launch a file browser"""
         if not package:
             filename = askopenfilename(parent=self.root,
                                        filetypes=[('pythonfiles', '*.py'),
                                                   ('allfiles', '*')],
                                        title='Select Module')
@@ skipping 60 matching lines @@
 
         # Overwrite the .pylint-gui-history file with all the new recently added files
         # in order from filenames but only save last 10 files
         write_history = open(HOME+HISTORY, 'w')
         write_history.writelines(self.filenames)
         write_history.close()
         self.set_history_window()
 
         self.root.configure(cursor='')
 
-    def show_sourcefile(self, event=None):
+    def show_sourcefile(self, event=None):  # pylint: disable=unused-argument
         selected = self.lb_messages.curselection()
         if not selected:
             return
 
         msg = self.visible_msgs[int(selected[0])]
         scroll = msg.line - 3
         if scroll < 0:
             scroll = 0
 
         self.tabs["Source File"] = open(msg.path, "r").readlines()
         self.box.set("Source File")
         self.refresh_results_window()
         self.results.yview(scroll)
         self.results.select_set(msg.line - 1)
 
 
 def lint_thread(module, reporter, gui):
     """thread for pylint"""
     gui.status.text = "processing module(s)"
     pylint.lint.Run(args=[module], reporter=reporter, exit=False)
     gui.msg_queue.put("DONE")
 
 
 def Run(args):
     """launch pylint gui from args"""
     if args:
-        print 'USAGE: pylint-gui\n launch a simple pylint gui using Tk'
+        print('USAGE: pylint-gui\n launch a simple pylint gui using Tk')
         sys.exit(1)
     gui = LintGui()
     gui.mainloop()
     sys.exit(0)
 
 if __name__ == '__main__':
     Run(sys.argv[1:])