Django Project: comparison ProjectDjango/Project.py

-:e2084f0a28a2
+:208fced62e00
 def projectOpenedHooks(self):
 """
 Public method to add our hook methods.
 """
 if self.__e5project.getProjectType() == "Django":
-self.__formsBrowser = \
+self.__formsBrowser = (
 e5App().getObject("ProjectBrowser").getProjectBrowser("forms")
+)
 self.__formsBrowser.addHookMethodAndMenuEntry(
 "newForm",
 self.newForm, self.tr("New template..."))
 self.__e5project.projectLanguageAddedByCode.connect(
 self.__projectLanguageAdded)
-self.__translationsBrowser = \
+self.__translationsBrowser = (
-e5App().getObject("ProjectBrowser")\
+e5App().getObject("ProjectBrowser")
-.getProjectBrowser("translations")
+.getProjectBrowser("translations"))
 self.__translationsBrowser.addHookMethodAndMenuEntry(
 "generateAll",
 self.updateCatalogs, self.tr("Update all catalogs"))
 self.__translationsBrowser.addHookMethodAndMenuEntry(
 "generateSelected",
 if os.access(exe, os.X_OK) and exe not in paths:
 paths.append(exe)
 return paths
+# TODO: eliminate Python2
 def supportedPythonVariants(self):
 """
 Public method to get the supported Python variants.
 @return list of supported Python variants (list of strings)
 """
 variants = []
-for variant in 'Python2', 'Python3':
+for variant in ['Python3']:
 virtEnv = self.__getVirtualEnvironment(variant)
 if virtEnv:
 if self.__getDjangoAdminCommand(variant):
 variants.append(variant)
 else:
 variants.append(variant)
 break
 return variants
+# TODO: eliminate Python2
 def __isSuitableForVariant(self, variant, line0):
 """
 Private method to test, if a detected command file is suitable for the
 given Python variant.
 @param variant Python variant to test for
-@type str (one of Python2 or Python3)
+@type str
 @param line0 first line of the executable
 @type str
-"""
+@return flag indicating a suitable file was found
-assert variant in ("Python2", "Python3")
+@rtype bool
+"""
 l0 = line0.lower()
 ok = (variant.lower() in l0 or
 "{0}.".format(variant[-1]) in l0)
-if variant == "Python2":
+ok |= "pypy3" in l0
-ok |= "python3" not in l0 and "python" in l0
-ok |= "pypy2" in l0
-ok |= "pypy3" not in l0 and "pypy" in l0
-else:
-ok |= "pypy3" in l0
 return ok
 def __getVirtualEnvironment(self, language=""):
 """
 Private method to get the path of the virtual environment.
 @param language Python variant to get the virtual environment
-for (string, one of '', 'Python2' or 'Python3')
+for (string, one of '' or 'Python3')
 @return path of the virtual environment (string)
 """
 if not language:
 language = self.__e5project.getProjectLanguage()
 if self.__virtualEnvManager:
 if language == "Python3":
 venvName = self.__plugin.getPreferences(
 "VirtualEnvironmentNamePy3")
-elif language == "Python2":
-venvName = self.__plugin.getPreferences(
-"VirtualEnvironmentNamePy2")
 else:
 venvName = ""
 if venvName:
 virtEnv = self.__virtualEnvManager.getVirtualenvDirectory(
 venvName)
 virtEnv = ""
 else:
 # backward compatibility
 if language == "Python3":
 virtEnv = self.__plugin.getPreferences("VirtualEnvironmentPy3")
-elif language == "Python2":
-virtEnv = self.__plugin.getPreferences("VirtualEnvironmentPy2")
 else:
 virtEnv = ""
 if virtEnv and not os.path.exists(virtEnv):
 virtEnv = ""
 return virtEnv
 def __getDebugEnvironment(self, language=""):
 """
 Private method to get the path of the debugger environment.
 @param language Python variant to get the debugger environment
-for (string, one of '', 'Python2' or 'Python3')
+for (string, one of '' or 'Python3')
 @return path of the debugger environment (string)
 """
 if not language:
 language = self.__e5project.getProjectLanguage()
 if self.__virtualEnvManager:
 debugEnv = self.__getVirtualEnvironment(language)
 if not debugEnv:
 if language == "Python3":
 venvName = Preferences.getDebugger("Python3VirtualEnv")
-elif language == "Python2":
-venvName = Preferences.getDebugger("Python2VirtualEnv")
 else:
 venvName = ""
 if venvName:
 debugEnv = self.__virtualEnvManager.getVirtualenvDirectory(
 debugEnv = ""
 else:
 # backward compatibility
 if language == "Python3":
 debugEnv = Preferences.getDebugger("Python3Interpreter")
-if not debugEnv and sys.version_info[0] == 3:
+if not debugEnv and sys.version_info[0] >= 3:
-debugEnv = sys.executable
-elif language == "Python2":
-debugEnv = Preferences.getDebugger("PythonInterpreter")
-if not debugEnv and sys.version_info[0] == 2:
 debugEnv = sys.executable
 else:
 debugEnv = sys.executable
 debugEnv = os.path.dirname(debugEnv)
 if debugEnv and not os.path.exists(debugEnv):
-if (language == "Python3" and sys.version_info[0] == 3) or \
+if language == "Python3" and sys.version_info[0] >= 3:
-(language == "Python2" and sys.version_info[0] == 2):
 debugEnv = sys.exec_prefix
 else:
 debugEnv = ""
 return debugEnv
 def __getDjangoAdminCommand(self, language=""):
 """
 Private method to build a django-admin.py command.
 @param language Python variant to get the django-admin.py
-command for (string, one of '', 'Python2' or 'Python3')
+command for (string, one of '' or 'Python3')
 @return full django-admin.py command (string)
 """
 if not language:
 language = self.__e5project.getProjectLanguage()
 if os.path.exists(cmd):
 break
 else:
 cmd = ""
 else:
-if language == "Python2":
+if language == "Python3":
-cmds = ["django-admin2.py", "django-admin2",
-"django-admin.py-2.7", "django-admin.py-2.6"
-]
-elif language == "Python3":
 cmds = ["django-admin3.py", "django-admin3",
 "django-admin.py-3.7", "django-admin.py-3.6",
 "django-admin.py-3.5", "django-admin.py-3.4",
 "django-admin.py-3.3", "django-admin.py-3.2",
 ]
 venvName = self.__plugin.getPreferences(
 "VirtualEnvironmentNamePy3")
 if not venvName:
 # if none configured, use the global one
 venvName = Preferences.getDebugger("Python3VirtualEnv")
-elif language == "Python2":
-venvName = self.__plugin.getPreferences(
-"VirtualEnvironmentNamePy2")
-if not venvName:
-# if none configured, use the global one
-venvName = Preferences.getDebugger("Python2VirtualEnv")
 else:
 venvName = ""
 if venvName:
 python = self.__virtualEnvManager.getVirtualenvInterpreter(
 venvName)
 if python:
 break
 else:
 python = ""
 else:
-if language == "Python3":
+pythonExeList = ["python3", "pypy3"]
-pythonExeList = ["python3", "pypy3"]
-elif language == "Python2":
-pythonExeList = ["python2", "pypy2"]
 if not virtualEnv:
 virtualEnv = self.__getDebugEnvironment(language)
 for pythonExe in pythonExeList:
 for python in [
 self.__recentApplications.remove(applStr)
 self.__recentApplications.insert(0, applStr)
 maxRecentApps = self.__plugin.getPreferences("RecentNumberApps")
 if len(self.__recentApplications) > maxRecentApps:
-self.__recentApplications = \
+self.__recentApplications = (
-self.__recentApplications[:maxRecentApps]
+self.__recentApplications[:maxRecentApps])
 self.__saveRecentApplications()
 def __loadRecentTestData(self):
 """
 Private method to load the recently used test data lists.
 self.__recentTestData[key].insert(0, data)
 maxRecentTestData = self.__plugin.getPreferences(
 "RecentNumberTestData")
 if len(self.__recentTestData[key]) > maxRecentTestData:
-self.__recentTestData[key] = \
+self.__recentTestData[key] = (
-self.__recentTestData[key][:maxRecentTestData]
+self.__recentTestData[key][:maxRecentTestData])
 self.__saveRecentTestData()
 def getProjectPath(self):
 """
 Public method to get the path of the eric6 project.
 # create the base directory for translations
 i18nPath = os.path.join(path, projectName, "locale")
 if not os.path.exists(i18nPath):
 os.makedirs(i18nPath)
-if os.path.join(path, projectName) == \
+if (
-self.__e5project.getProjectPath():
+os.path.join(path, projectName) ==
+self.__e5project.getProjectPath()
+):
 self.__setCurrentSite("")
 else:
 self.__setCurrentSite(projectName)
 return res
 self.__ui,
 title,
 self.tr("""<p>The <b>django-admin.py</b> script"""
 """ is not in the path."""
 """ Aborting...</p>"""))
-return
+return False
 else:
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 try:
 path = self.__sitePath()
 def __serverProcFinished(self):
 """
 Private slot connected to the finished signal.
 """
-if self.__serverProc is not None and \
+if (
-self.__serverProc.state() != QProcess.NotRunning:
+self.__serverProc is not None and
+self.__serverProc.state() != QProcess.NotRunning
+):
 self.__serverProc.terminate()
 QTimer.singleShot(2000, self.__serverProc.kill)
 self.__serverProc.waitForFinished(3000)
 self.__serverProc = None
 """
 self.__recentDatabaseNames = [""]
 Preferences.Prefs.rsettings.sync()
 rdb = Preferences.Prefs.rsettings.value(self.RecentDatabaseNamesKey)
 if rdb is not None:
-maxRecentDatabaseNames = \
+maxRecentDatabaseNames = (
-self.__plugin.getPreferences("RecentNumberDatabaseNames")
+self.__plugin.getPreferences("RecentNumberDatabaseNames"))
 self.__recentDatabaseNames = rdb[:maxRecentDatabaseNames]
 def __saveRecentDatabaseNames(self):
 """
 Private method to save the list of recently used database names.
 """
 if dbName in self.__recentDatabaseNames:
 self.__recentDatabaseNames.remove(dbName)
 self.__recentDatabaseNames.insert(0, dbName)
-maxRecentDatabaseNames = \
+maxRecentDatabaseNames = (
-self.__plugin.getPreferences("RecentNumberDatabaseNames")
+self.__plugin.getPreferences("RecentNumberDatabaseNames"))
 if len(self.__recentDatabaseNames) > maxRecentDatabaseNames:
-self.__recentDatabaseNames = \
+self.__recentDatabaseNames = (
-self.__recentDatabaseNames[:maxRecentDatabaseNames]
+self.__recentDatabaseNames[:maxRecentDatabaseNames])
 self.__saveRecentDatabaseNames()
 def __selectDatabaseName(self):
 """
 Private method to select the name of the database to work with.
 self.tr("""No migrations available."""))
 return
 title = self.tr("SQL Migrate")
-from .DjangoMigrationSelectionDialog import \
+from .DjangoMigrationSelectionDialog import (
 DjangoMigrationSelectionDialog
+)
 dlg = DjangoMigrationSelectionDialog(migrations,
 migrationRequired=True,
 suffix=self.__iconSuffix)
 if dlg.exec_() == QDialog.Accepted:
 app, migration = dlg.getData()
 None,
 self.tr("Apply Selected Migrations"),
 self.tr("""No migrations available."""))
 return
-from .DjangoMigrationSelectionDialog import \
+from .DjangoMigrationSelectionDialog import (
 DjangoMigrationSelectionDialog
+)
 dlg = DjangoMigrationSelectionDialog(migrations,
 suffix=self.__iconSuffix)
 if dlg.exec_() == QDialog.Accepted:
 app, migration = dlg.getData()
 self.applyMigrations(app=app, migration=migration)
 None,
 self.tr("Squash Migrations"),
 self.tr("""No migrations available."""))
 return
-from .DjangoSquashMigrationSelectionDialog import \
+from .DjangoSquashMigrationSelectionDialog import (
 DjangoSquashMigrationSelectionDialog
+)
 dlg = DjangoSquashMigrationSelectionDialog(
 migrations, self, self.__iconSuffix)
 if dlg.exec_() == QDialog.Accepted:
 app, start, end, noOptimize, name = dlg.getData()
 args = Utilities.parseOptionString(consoleCmd)
 args[0] = Utilities.getExecutablePath(args[0])
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("shell")
-language = self.__e5project.getProjectLanguage()
+if self.getDjangoVersion() < (1, 10, 0):
-if language == "Python2":
+if (self.__plugin.getPreferences("Python3ConsoleType") ==
-if self.getDjangoVersion() < (1, 10, 0):
+"python"):
-if (self.__plugin.getPreferences("Python2ConsoleType") ==
+args.append("--plain")
-"python"):
-args.append("--plain")
-else:
-args.append("--interface={0}".format(
-self.__plugin.getPreferences("Python2ConsoleType")))
 else:
-if self.getDjangoVersion() < (1, 10, 0):
+args.append("--interface={0}".format(
-if (self.__plugin.getPreferences("Python3ConsoleType") ==
+self.__plugin.getPreferences("Python3ConsoleType")))
-"python"):
-args.append("--plain")
-else:
-args.append("--interface={0}".format(
-self.__plugin.getPreferences("Python3ConsoleType")))
 try:
 wd = self.__sitePath()
 self.__adjustWorkingDirectory(args, wd)
 started, pid = QProcess.startDetached(args[0], args[1:], wd)
 if not started:
 if self.getDjangoVersion() < (1, 9, 0):
 return
 title = self.tr("Send Test Email")
-from .DjangoSendTestEmailDataDialog import \
+from .DjangoSendTestEmailDataDialog import (
 DjangoSendTestEmailDataDialog
+)
 dlg = DjangoSendTestEmailDataDialog(self.__ui)
 if dlg.exec_() == QDialog.Accepted:
 managers, admins, recipients = dlg.getData()
 args = []
 from .DjangoTestDataDialog import DjangoTestDataDialog
 dlg = DjangoTestDataDialog(
 self, self.__plugin.getPreferences("KeepTestDatabase"),
 self.__ui)
 if dlg.exec_() == QDialog.Accepted:
-labels, pattern, tags, excludeTags, keep, reverse = \
+labels, pattern, tags, excludeTags, keep, reverse = (
-dlg.getData()
+dlg.getData())
 self.__plugin.setPreferences("KeepTestDatabase", keep)
 args = Utilities.parseOptionString(consoleCmd)
 args[0] = Utilities.getExecutablePath(args[0])
 fixtures.
 """
 consoleCmd = self.__isSpawningConsole(
 self.__plugin.getPreferences("ConsoleCommand"))[1]
 if consoleCmd:
-from .DjangoRunTestServerDataDialog import \
+from .DjangoRunTestServerDataDialog import (
 DjangoRunTestServerDataDialog
+)
 dlg = DjangoRunTestServerDataDialog(self, self.__ui)
 if dlg.exec_() == QDialog.Accepted:
 fixtures = dlg.getData()
 args = Utilities.parseOptionString(consoleCmd)
 self.__testServerProc.finished.connect(
 self.__serverProcFinished)
 self.__testServerProc.setWorkingDirectory(
 self.__sitePath())
 self.__testServerProc.start(args[0], args[1:])
-serverProcStarted = \
+serverProcStarted = (
-self.__testServerProc.waitForStarted()
+self.__testServerProc.waitForStarted())
 if not serverProcStarted:
 E5MessageBox.critical(
 None,
 self.tr('Process Generation Error'),
 self.tr('The Django test server could not be'
 def __testServerProcFinished(self):
 """
 Private slot connected to the finished signal of the test server.
 """
-if self.__testServerProc is not None and \
+if (
-self.__testServerProc.state() != QProcess.NotRunning:
+self.__testServerProc is not None and
+self.__testServerProc.state() != QProcess.NotRunning
+):
 self.__testServerProc.terminate()
 QTimer.singleShot(2000, self.__testServerProc.kill)
 self.__testServerProc.waitForFinished(3000)
 self.__testServerProc = None
 @param filename name of the file used for extraction (string)
 @return extracted locale (string) or None
 """
 if self.__e5project.getTranslationPattern():
-pattern = self.__e5project.getTranslationPattern()\
+pattern = (
+self.__e5project.getTranslationPattern()
 .replace("%language%", "(.*?)")
+)
 match = re.search(pattern, filename)
 if match is not None:
 loc = match.group(1)
 return loc
 else:
 """
 Private slot handling the addition of a new language.
 @param code language code of the new language (string)
 """
-title = self.tr("Initializing message catalog for '{0}'")\
+title = (
+self.tr("Initializing message catalog for '{0}'")
 .format(code)
+)
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("makemessages")
 "\nMessage catalog initialized successfully."))
 res = dia.startProcess(args, wd)
 if res:
 dia.exec_()
-langFile = self.__e5project.getTranslationPattern()\
+langFile = (
+self.__e5project.getTranslationPattern()
 .replace("%language%", code)
+)
 self.__e5project.appendFile(langFile)
 def updateSelectedCatalogs(self, filenames):
 """
 Public method to update the message catalogs.

Mercurial Repositories > Django Project / file comparison

comparison: ProjectDjango/Project.py

ProjectDjango/Project.py