PyLint Checker: comparison PluginPyLint.py

-:f2144b9596a0
+:68beeb22dade
 """
 Module implementing the PyLint plug-in.
 """
+from __future__ import unicode_literals    # __IGNORE_WARNING__
+try:
+str = unicode
+except (NameError):
+pass
+import re
 import os
-import sys
 import copy
+import platform
-from PyQt4.QtCore import QObject, QTranslator, QCoreApplication
+from PyQt4.QtCore import QObject, QTranslator, QCoreApplication, QProcess
 from PyQt4.QtGui import QDialog
-from E5Gui.E5Application import e5App
+try:
-from E5Gui.E5Action import E5Action
+from E5Gui.E5Application import e5App
-from E5Gui import E5MessageBox
+from E5Gui.E5Action import E5Action
+from E5Gui import E5MessageBox
+error = ""
+except ImportError:
+error = QCoreApplication.translate("PyLintPlugin",
+"""Your version of Eric5 is not supported."""
+""" At least version 5.1.0 of Eric5 is needed.""")
+import Preferences
 import Utilities
 # Start-of-Header
 name = "PyLint Plugin"
 author = "Detlev Offenbach <detlev@die-offenbachs.de>"
 autoactivate = True
 deactivateable = True
-version = "5.2.1"
+version = "5.3.0"
 className = "PyLintPlugin"
 packageName = "PyLint"
 shortDescription = "Show the PyLint dialogs."
 longDescription = """This plug-in implements the PyLint dialogs.""" \
 """ PyLint is used to check Python source files according to various rules."""
 needsRestart = False
 pyqtApi = 2
 # End-of-Header
-error = ""
+exePy2 = []
+exePy3 = []
-def exeDisplayData():
+def exeDisplayDataList():
 """
 Public method to support the display of some executable info.
 @return dictionary containing the data to query the presence of
 the executable
 """
+dataList = []
 data = {
 "programEntry": True,
 "header": QCoreApplication.translate("PyLintPlugin",
 "Checkers - Pylint"),
 "exe": 'dummypylint',
 "versionStartsWith": 'dummypylint',
 "versionPosition": -1,
 "version": "",
 "versionCleanup": (0, -1),
 }
-exe = _findExecutable()
+if _checkProgram():
-if exe:
+for exePath in (exePy2[0], exePy3[0]):
-data["exe"] = exe
+data["exe"] = exePath
-data["versionStartsWith"] = 'pylint'
+data["versionStartsWith"] = "pylint"
+dataList.append(data.copy())
-return data
+else:
+dataList.append(data)
+return dataList
-def _findExecutable():
+def __getProgramVersion(exe):
+"""
+Private method to generate a program entry.
+@param exe name of the executable program (string)
+@return version string of detected version (string)
+"""
+proc = QProcess()
+proc.setProcessChannelMode(QProcess.MergedChannels)
+proc.start(exe, ['--version'])
+finished = proc.waitForFinished(10000)
+if finished:
+output = str(proc.readAllStandardOutput(),
+Preferences.getSystem("IOEncoding"),
+'replace')
+versionRe = re.compile('^pylint', re.UNICODE)
+for line in output.splitlines():
+if versionRe.search(line):
+version = line.split()[-1]
+version = version[:-1]
+break
+else:
+version = '0.0.0'
+return version
+def _findExecutable(majorVersion):
 """
 Restricted function to determine the name and path of the executable.
+@param majorVersion major python version of the executables (int)
 @return path name of the executable (string)
 """
+# Determine Python Version
+if majorVersion == 3:
+minorVersions = range(5)
+elif majorVersion == 2:
+minorVersions = range(5, 9)
+else:
+return []
+executables = set()
 if Utilities.isWindowsPlatform():
 #
 # Windows
 #
-exe = 'pylint.bat'
-if Utilities.isinpath(exe):
-return exe
 try:
-# only since python 3.2
+import winreg
-import sysconfig
-scripts = sysconfig.get_path('scripts', 'nt')
-return os.path.join(scripts, exe)
 except ImportError:
+import _winreg as winreg    # __IGNORE_WARNING__
+def getExePath(branch, access, versionStr):
 try:
-import winreg
+software = winreg.OpenKey(branch, 'Software', 0, access)
-except ImportError:
+python = winreg.OpenKey(software, 'Python', 0, access)
-# give up ...
+pcore = winreg.OpenKey(python, 'PythonCore', 0, access)
+version = winreg.OpenKey(pcore, versionStr, 0, access)
+installpath = winreg.QueryValue(version, 'InstallPath')
+exe = os.path.join(installpath, 'Scripts', 'pylint.bat')
+if os.access(exe, os.X_OK):
+return exe
+except WindowsError:        # __IGNORE_WARNING__
 return None
+return None
+for minorVersion in minorVersions:
+versionStr = '{0}.{1}'.format(majorVersion, minorVersion)
+exePath = getExePath(winreg.HKEY_CURRENT_USER,
+winreg.KEY_WOW64_32KEY | winreg.KEY_READ, versionStr)
+if exePath is not None:
+executables.add(exePath)
+exePath = getExePath(winreg.HKEY_LOCAL_MACHINE,
+winreg.KEY_WOW64_32KEY | winreg.KEY_READ, versionStr)
-def getExePath(branch):
+# Even on Intel 64-bit machines it's 'AMD64'
-version = str(sys.version_info.major) + '.' + \
+if platform.machine() == 'AMD64':
-str(sys.version_info.minor)
+if exePath is not None:
-try:
+executables.add(exePath)
-software = winreg.OpenKey(branch, 'Software')
+exePath = getExePath(winreg.HKEY_CURRENT_USER,
-python = winreg.OpenKey(software, 'Python')
+winreg.KEY_WOW64_64KEY | winreg.KEY_READ, versionStr)
-pcore = winreg.OpenKey(python, 'PythonCore')
-version = winreg.OpenKey(pcore, version)
+if exePath is not None:
-installpath = winreg.QueryValue(version, 'InstallPath')
+executables.add(exePath)
-return os.path.join(installpath, 'Scripts', exe)
+exePath = getExePath(winreg.HKEY_LOCAL_MACHINE,
-except WindowsError:        # __IGNORE_WARNING__
+winreg.KEY_WOW64_64KEY | winreg.KEY_READ, versionStr)
-return None
+if exePath is not None:
-exePath = getExePath(winreg.HKEY_CURRENT_USER)
+executables.add(exePath)
-if not exePath:
-exePath = getExePath(winreg.HKEY_LOCAL_MACHINE)
-return exePath
 else:
 #
 # Linux, Unix ...
 pylintScript = 'pylint'
 scriptSuffixes = ["",
-"-python{0}".format(sys.version[:1]),
+"-python{0}".format(majorVersion)]
-"-python{0}".format(sys.version[:3])]
+for minorVersion in minorVersions:
+scriptSuffixes.append(
+"-python{0}.{1}".format(majorVersion, minorVersion))
 # There could be multiple pylint executables in the path
 # e.g. for different python variants
 path = Utilities.getEnvironmentEntry('PATH')
 # environment variable not defined
 if path is None:
-return None
+return []
 # step 1: determine possible candidates
 exes = []
 dirs = path.split(os.pathsep)
 for dir in dirs:
 for suffix in scriptSuffixes:
 exe = os.path.join(dir, pylintScript + suffix)
 if os.access(exe, os.X_OK):
 exes.append(exe)
-# step 2: determine the Python 3 variant
+# step 2: determine the Python variant
-found = False
 if Utilities.isMacPlatform():
-checkStr = "Python.framework/Versions/3".lower()
+checkStrings = ["Python.framework/Versions/3".lower(),
+"python3"]
 else:
-checkStr = "python3"
+checkStrings = ["python3"]
+_exePy2 = set()
+_exePy3 = set()
 for exe in exes:
 try:
 f = open(exe, "r")
 line0 = f.readline()
-if checkStr in line0.lower():
+for checkStr in checkStrings:
-found = True
+if checkStr in line0.lower():
+_exePy3.add(exe)
+break
+else:
+_exePy2.add(exe)
 finally:
 f.close()
-if found:
-return exe
+executables = _exePy3 if majorVersion == 3 else _exePy2
-return None
+# Find the executable with the highest version number
+maxVersion = '0.0.0'
+maxExe = ''
+for executable in list(executables):
+version = __getProgramVersion(executable)
+if version > maxVersion:
+maxVersion = version
+maxExe = executable
+return maxExe, maxVersion
 def _checkProgram():
 """
 Restricted function to check the availability of pylint.
 @return flag indicating availability (boolean)
 """
-global error
+global error, exePy2, exePy3
-if _findExecutable() is None:
+exePy2 = _findExecutable(2)
+exePy3 = _findExecutable(3)
+if exePy2[0] == '' and exePy3[0] == '':
 error = QCoreApplication.translate("PyLintPlugin",
 "The pylint executable could not be found.")
+return False
+elif exePy2[1] < '0.23.0' and exePy3[1] < '0.23.0':
+error = QCoreApplication.translate("PyLintPlugin",
+"PyLint version < 0.23.0.")
 return False
 else:
 return True
 @return tuple of None and activation status (boolean)
 """
 global error
+# There is already an error, don't activate
+if error:
+return None, False
 # pylint is only activated if it is available
 if not _checkProgram():
-return None, False
-try:
-from pylint.__pkginfo__ import numversion
-if numversion < (0, 23, 0):
-error = self.trUtf8("PyLint version < 0.23.0.")
-return None, False
-except ImportError:
-error = self.trUtf8("Cannot determine pylint version.")
 return None, False
 menu = e5App().getObject("Project").getMenu("Checks")
 if menu:
 self.__projectAct = E5Action(self.trUtf8('Run PyLint'),
 @param menuName name of the menu to be shown (string)
 @param menu reference to the menu (QMenu)
 """
 if menuName == "Checks":
+lang = e5App().getObject("Project").getProjectLanguage()
 if self.__projectAct is not None:
-self.__projectAct.setEnabled(
+self.__projectAct.setEnabled(lang.startswith("Python"))
-e5App().getObject("Project").getProjectLanguage() == "Python3")
 if self.__projectShowAct is not None:
-self.__projectShowAct.setEnabled(
+self.__projectShowAct.setEnabled(lang.startswith("Python"))
-e5App().getObject("Project").getProjectLanguage() == "Python3")
 self.__projectShowAct.setEnabled(self.__pylintPDialog is not None)
 def __projectBrowserShowMenu(self, menuName, menu):
 """
 Private slot called, when the the project browser menu or a submenu is
 @param menuName name of the menu to be shown (string)
 @param menu reference to the menu (QMenu)
 """
 if menuName == "Checks" and \
-e5App().getObject("Project").getProjectLanguage() == "Python3":
+e5App().getObject("Project").getProjectLanguage().startswith("Python"):
 self.__projectBrowserMenu = menu
 if self.__projectBrowserAct is None:
 self.__projectBrowserAct = E5Action(self.trUtf8('Run PyLint'),
 self.trUtf8('Run &PyLint...'), 0, 0,
 self, '')
 @param mpName name of module or package to be checked (string)
 @param forProject flag indicating a run for the project (boolean)
 """
 if forEditor:
 parms = copy.deepcopy(self.__editorParms)
+editor = e5App().getObject("ViewManager").getOpenEditor(mpName)
+majorVersionStr = editor.getLanguage()
 else:
 parms = project.getData('CHECKERSPARMS', "PYLINT")
-exe = _findExecutable()
+majorVersionStr = project.getProjectLanguage()
-if exe is None:
+exe, version = {"Python": exePy2, "Python2": exePy2,
+"Python3": exePy3}.get(majorVersionStr)
+if exe == '':
 E5MessageBox.critical(None,
 self.trUtf8("pylint"),
 self.trUtf8("""The pylint executable could not be found."""))
 return
+elif version < '0.23.0':
+E5MessageBox.critical(None,
+self.trUtf8("pylint"),
+self.trUtf8("PyLint version < 0.23.0."))
+return
 from PyLint.PyLintConfigDialog import PyLintConfigDialog
-dlg = PyLintConfigDialog(project.getProjectPath(), exe, parms)
+dlg = PyLintConfigDialog(project.getProjectPath(), exe, parms, version)
 if dlg.exec_() == QDialog.Accepted:
 args, parms = dlg.generateParameters()
 self.__editorParms = copy.deepcopy(parms)
 if not forEditor:
 project.setData('CHECKERSPARMS', "PYLINT", parms)
 # now do the call
 from PyLint.PyLintExecDialog import PyLintExecDialog
 dlg2 = PyLintExecDialog()
-try:
+reportFile = parms.get('reportFile', None)
-reportFile = parms['reportFile']
-except KeyError:
-reportFile = None
 res = dlg2.start(args, mpName, reportFile, project.getProjectPath())
 if res:
 dlg2.show()
 if forProject:
 self.__pylintPDialog = dlg2
 @param editor reference to the editor (QScintilla.Editor)
 """
 if menuName == "Checks":
 if not self.__editorAct in menu.actions():
 menu.addAction(self.__editorAct)
-self.__editorAct.setEnabled(editor.isPy3File())
+self.__editorAct.setEnabled(editor.isPy3File() or editor.isPy2File())
 def __editorPylint(self):
 """
 Private slot to handle the Pylint context menu action of the editors.
 """

Mercurial Repositories > PyLint Checker / file comparison

comparison: PluginPyLint.py

PluginPyLint.py