Django Project: comparison ProjectDjango/Project.py

-:c6182aab51e9
+:b8f263e05c39
 """
 import os
 import re
 import shutil
+import contextlib
 from PyQt5.QtCore import QObject, QTimer, QUrl, QFileInfo
 from PyQt5.QtGui import QDesktopServices
 from PyQt5.QtWidgets import QMenu, QInputDialog, QLineEdit, QDialog
 from PyQt5.QtCore import QProcess as QProcessPyQt
 @keyparam mode access mode (QIODevice.OpenMode)
 """
 if args is None:
 args = []
-if cmd.endswith(('gnome-terminal', 'konsole', 'xfce4-terminal',
+if (
-'mate-terminal')):
+cmd.endswith(('gnome-terminal', 'konsole', 'xfce4-terminal',
-if '-e' in args:
+'mate-terminal')) and
-index = args.index('-e') + 1
+'-e' in args
-cargs = ' '.join(args[index:])
+):
-args[index:] = [cargs]
+index = args.index('-e') + 1
+cargs = ' '.join(args[index:])
-super(QProcess, self).start(cmd, args, mode)
+args[index:] = [cargs]
+super().start(cmd, args, mode)
 @staticmethod
 def startDetached(cmd, args=None, path=''):
 """
 Public static method to start the given program (cmd) in a new process,
 @return tuple of successful start and process id (boolean, integer)
 """
 if args is None:
 args = []
-if cmd.endswith(('gnome-terminal', 'konsole', 'xfce4-terminal',
+if (
-'mate-terminal')):
+cmd.endswith(('gnome-terminal', 'konsole', 'xfce4-terminal',
-if '-e' in args:
+'mate-terminal')) and
-index = args.index('-e') + 1
+'-e' in args
-cargs = ' '.join(args[index:])
+):
-args[index:] = [cargs]
+index = args.index('-e') + 1
+cargs = ' '.join(args[index:])
+args[index:] = [cargs]
 return QProcessPyQt.startDetached(cmd, args, path)
 class Project(QObject):
 @param iconSuffix suffix for the icons
 @type str
 @param parent parent
 @type QObject
 """
-super(Project, self).__init__(parent)
+super().__init__(parent)
 self.__plugin = plugin
 self.__iconSuffix = iconSuffix
 self.__ui = parent
 def __initDatabaseSqlActions(self):
 """
 Private method to define the database SQL related actions.
 """
-self.databaseSqlCreateTablesAct = E5Action(
-self.tr('Create Tables'),
-self.tr('Create &Tables'),
-0, 0,
-self, 'django_database_sql_create_tables')
-self.databaseSqlCreateTablesAct.setStatusTip(self.tr(
-'Prints the CREATE TABLE SQL statements for one or more'
-' applications'))
-self.databaseSqlCreateTablesAct.setWhatsThis(self.tr(
-"""<b>Create Tables</b>"""
-"""<p>Prints the CREATE TABLE SQL statements for one or """
-"""more applications.</p>"""
-))
-self.databaseSqlCreateTablesAct.triggered.connect(
-self.__databaseSqlCreateTables)
-self.actions.append(self.databaseSqlCreateTablesAct)
-self.databaseSqlCreateIndexesAct = E5Action(
-self.tr('Create Indexes'),
-self.tr('Create &Indexes'),
-0, 0,
-self, 'django_database_sql_create_indexes')
-self.databaseSqlCreateIndexesAct.setStatusTip(self.tr(
-'Prints the CREATE INDEX SQL statements for one or more'
-' applications'))
-self.databaseSqlCreateIndexesAct.setWhatsThis(self.tr(
-"""<b>Create Indexes</b>"""
-"""<p>Prints the CREATE INDEX SQL statements for one or """
-"""more applications.</p>"""
-))
-self.databaseSqlCreateIndexesAct.triggered.connect(
-self.__databaseSqlCreateIndexes)
-self.actions.append(self.databaseSqlCreateIndexesAct)
-self.databaseSqlCreateEverythingAct = E5Action(
-self.tr('Create Everything'),
-self.tr('Create &Everything'),
-0, 0,
-self, 'django_database_sql_create_everything')
-self.databaseSqlCreateEverythingAct.setStatusTip(self.tr(
-'Prints the CREATE ... SQL statements for one or more'
-' applications'))
-self.databaseSqlCreateEverythingAct.setWhatsThis(self.tr(
-"""<b>Create Everything</b>"""
-"""<p>Prints the CREATE TABLE, custom SQL and CREATE INDEX SQL """
-"""statements for one or more applications.</p>"""
-))
-self.databaseSqlCreateEverythingAct.triggered.connect(
-self.__databaseSqlCreateEverything)
-self.actions.append(self.databaseSqlCreateEverythingAct)
-self.databaseSqlCustomAct = E5Action(
-self.tr('Custom Statements'),
-self.tr('&Custom Statements'),
-0, 0,
-self, 'django_database_sql_custom')
-self.databaseSqlCustomAct.setStatusTip(self.tr(
-'Prints the custom table modifying SQL statements for '
-'one or more applications'))
-self.databaseSqlCustomAct.setWhatsThis(self.tr(
-"""<b>Custom Statements</b>"""
-"""<p>Prints the custom table modifying SQL statements """
-"""for one or more applications.</p>"""
-))
-self.databaseSqlCustomAct.triggered.connect(
-self.__databaseSqlCustom)
-self.actions.append(self.databaseSqlCustomAct)
-self.databaseSqlDropTablesAct = E5Action(
-self.tr('Drop Tables'),
-self.tr('&Drop Tables'),
-0, 0,
-self, 'django_database_sql_drop_tables')
-self.databaseSqlDropTablesAct.setStatusTip(self.tr(
-'Prints the DROP TABLE SQL statements for '
-'one or more applications'))
-self.databaseSqlDropTablesAct.setWhatsThis(self.tr(
-"""<b>Drop Tables</b>"""
-"""<p>Prints the DROP TABLE SQL statements """
-"""for one or more applications.</p>"""
-))
-self.databaseSqlDropTablesAct.triggered.connect(
-self.__databaseSqlDropTables)
-self.actions.append(self.databaseSqlDropTablesAct)
-self.databaseSqlDropIndexesAct = E5Action(
-self.tr('Drop Indexes'),
-self.tr('&Drop Indexes'),
-0, 0,
-self, 'django_database_sql_drop_indexes')
-self.databaseSqlDropIndexesAct.setStatusTip(self.tr(
-'Prints the DROP INDEX SQL statements for '
-'one or more applications'))
-self.databaseSqlDropIndexesAct.setWhatsThis(self.tr(
-"""<b>Drop Indexes</b>"""
-"""<p>Prints the DROP INDEX SQL statements """
-"""for one or more applications.</p>"""
-))
-self.databaseSqlDropIndexesAct.triggered.connect(
-self.__databaseSqlDropIndexes)
-self.actions.append(self.databaseSqlDropIndexesAct)
 self.databaseSqlFlushAct = E5Action(
 self.tr('Flush Database'),
 self.tr('&Flush Database'),
 0, 0,
 self, 'django_database_sql_flush_database')
 @rtype QMenu
 """
 menu = QMenu(self.tr("Show &SQL"), self.__ui)
 menu.setTearOffEnabled(True)
-if self.getDjangoVersion() < (1, 9, 0):
-menu.addAction(self.databaseSqlCreateTablesAct)
-menu.addAction(self.databaseSqlCreateIndexesAct)
-menu.addAction(self.databaseSqlCreateEverythingAct)
-menu.addSeparator()
-menu.addAction(self.databaseSqlCustomAct)
-menu.addSeparator()
-menu.addAction(self.databaseSqlDropTablesAct)
-menu.addAction(self.databaseSqlDropIndexesAct)
-menu.addSeparator()
 menu.addAction(self.databaseSqlFlushAct)
 menu.addAction(self.databaseSqlResetSeqAct)
 menu.addSeparator()
 menu.addAction(self.databaseSqlMigrateAct)
 menu.addAction(self.databaseSqlMigrateBackwardsAct)
 menu.setTearOffEnabled(True)
 menu.addAction(self.diffSettingsAct)
 menu.addSeparator()
 menu.addAction(self.runPythonShellAct)
-if self.getDjangoVersion() >= (1, 9, 0):
+menu.addSeparator()
-menu.addSeparator()
+menu.addAction(self.testEmailAct)
-menu.addAction(self.testEmailAct)
 self.__menus["tools"] = menu
 return menu
 return [file]
 else:
 return []
 cur_path = os.path.join(os.curdir, file)
-if os.path.exists(cur_path):
+if os.path.exists(cur_path) and os.access(cur_path, os.X_OK):
-if os.access(cur_path, os.X_OK):
+paths.append(cur_path)
-paths.append(cur_path)
 path = os.getenv('PATH')
 # environment variable not defined
 if path is not None:
 for (string, one of '' or 'Python3')
 @return path of the virtual environment (string)
 """
 if not language:
 language = self.__e5project.getProjectLanguage()
-if language == "Python3":
+venvName = (
-venvName = self.__plugin.getPreferences(
+self.__plugin.getPreferences("VirtualEnvironmentNamePy3")
-"VirtualEnvironmentNamePy3")
+if language == "Python3" else
-else:
+""
-venvName = ""
+)
 if venvName:
 virtEnv = self.__virtualEnvManager.getVirtualenvDirectory(
 venvName)
 if not virtEnv:
 virtEnv = os.path.dirname(
 if not venvName:
 # if none configured, use the global one
 venvName = Preferences.getDebugger("Python3VirtualEnv")
 else:
 venvName = ""
-if venvName:
+python = (
-python = self.__virtualEnvManager.getVirtualenvInterpreter(
+self.__virtualEnvManager.getVirtualenvInterpreter(venvName)
-venvName)
+if venvName else
-else:
+""
-python = ""
+)
 return python
 def __djangoInfo(self):
 """
 args.append("--nothreading")
 addr = self.__plugin.getPreferences("ServerAddress")
 if addr:
 args.append(addr)
-try:
+with contextlib.suppress(DjangoNoSiteSelectedException):
 if Utilities.isWindowsPlatform():
 serverProcStarted, pid = QProcess.startDetached(
 args[0], args[1:], self.__sitePath())
 else:
 if self.__serverProc is not None:
 if not serverProcStarted:
 E5MessageBox.critical(
 None,
 self.tr('Process Generation Error'),
 self.tr('The Django server could not be started.'))
-except DjangoNoSiteSelectedException:
-pass
 def __serverProcFinished(self):
 """
 Private slot connected to the finished signal.
 """
 """
 if database is None:
 database = self.getRecentDatabaseNames()[0]
 self.__currentDatabase = database
-if database:
+curDb = database if database else self.tr("<default>")
-curDb = database
-else:
-curDb = self.tr("<default>")
 self.selectDatabaseNameAct.setText(
 self.tr('&Current Database ({0})').format(curDb))
 def currentDatabase(self):
 """
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("dbshell")
 if self.__currentDatabase:
 args.append("--database={0}".format(self.__currentDatabase))
-try:
+with contextlib.suppress(DjangoNoSiteSelectedException):
 wd = self.__sitePath()
 self.__adjustWorkingDirectory(args, wd)
 started, pid = QProcess.startDetached(args[0], args[1:], wd)
 if not started:
 E5MessageBox.critical(
 None,
 self.tr('Process Generation Error'),
 self.tr('The Django process could not be started.'))
-except DjangoNoSiteSelectedException:
-pass
 #######################################################################
 ## slots below implement database functions outputting SQL statements
 #######################################################################
 dia = DjangoDialog(title, fixed=True, linewrap=False,
 saveFilters=fileFilter)
 res = dia.startProcess(args, path, False)
 if res:
 dia.exec()
-def __databaseSqlCreateTables(self):
-"""
-Private slot to print the CREATE TABLE SQL statements for one
-or more applications.
-Note: available before Django v1.9.0
-"""
-self.__sqlCommand(self.tr("Create Tables"), "sql")
-def __databaseSqlCreateIndexes(self):
-"""
-Private slot to print the CREATE INDEX SQL statements for one
-or more applications.
-Note: available before Django v1.9.0
-"""
-self.__sqlCommand(self.tr("Create Indexes"), "sqlindexes")
-def __databaseSqlCreateEverything(self):
-"""
-Private slot to print the CREATE TABLE, custom SQL and
-CREATE INDEX SQL statements for one or more applications.
-Note: available before Django v1.9.0
-"""
-self.__sqlCommand(self.tr("Create Everything"), "sqlall")
-def __databaseSqlCustom(self):
-"""
-Private slot to print the custom table modifying SQL statements
-for one or more applications.
-Note: available before Django v1.9.0
-"""
-self.__sqlCommand(self.tr("Custom Statements"), "sqlcustom")
-def __databaseSqlDropTables(self):
-"""
-Private slot to print the DROP TABLE SQL statements for one or
-more applications.
-Note: available before Django v1.9.0
-"""
-self.__sqlCommand(self.tr("Drop Tables"), "sqlclear")
-def __databaseSqlDropIndexes(self):
-"""
-Private slot to print the DROP INDEX SQL statements for one or
-more applications.
-Note: available before Django v1.9.0
-"""
-self.__sqlCommand(self.tr("Drop Indexes"), "sqldropindexes")
 def __databaseSqlFlushDatabase(self):
 """
 Private slot to print a list of statements to return all database
 tables to their initial state.
 @param app name of an application to apply migrations for
 @type str
 @param migration name of a migration to update to
 @type str
 """
-if migration == "zero":
+title = (
-title = self.tr("Unapply Migrations")
+self.tr("Unapply Migrations")
-else:
+if migration == "zero" else
-title = self.tr("Apply Migrations")
+self.tr("Apply Migrations")
+)
 try:
 path = self.__sitePath()
 except DjangoNoSiteSelectedException:
 return
 args = []
 args.append("manage.py")
 args.append("showmigrations")
 args.append("--list")
-if self.getDjangoVersion() >= (1, 9, 0):
+if self.__currentDatabase:
-if self.__currentDatabase:
+args.append("--database={0}".format(self.__currentDatabase))
-args.append("--database={0}".format(self.__currentDatabase))
 migrations = {}
 proc = QProcess()
 if path:
 proc.setWorkingDirectory(path)
 proc.start(self.__getPythonExecutable(), args)
-if proc.waitForStarted():
+if proc.waitForStarted() and proc.waitForFinished():
-if proc.waitForFinished():
+output = str(proc.readAllStandardOutput(),
-output = str(proc.readAllStandardOutput(),
+Preferences.getSystem("IOEncoding"), 'replace')
-Preferences.getSystem("IOEncoding"), 'replace')
+if output:
-if output:
+recentApp = ""
-recentApp = ""
+for line in output.splitlines():
-for line in output.splitlines():
+if not line.startswith(" "):
-if not line.startswith(" "):
+# application name
-# application name
+recentApp = line.strip()
-recentApp = line.strip()
+migrations[recentApp] = []
-migrations[recentApp] = []
+else:
-else:
+# migration name
-# migration name
+line = line.strip()
-line = line.strip()
+applied = line[1] != " "
-applied = line[1] != " "
+name = line[3:].strip()
-name = line[3:].strip()
+if recentApp:
-if recentApp:
+migrations[recentApp].append((applied, name))
-migrations[recentApp].append((applied, name))
 return migrations
 def __makeMigrations(self):
 """
 Private slot to generate migrations for the Django project.
 args = Utilities.parseOptionString(consoleCmd)
 args[0] = Utilities.getExecutablePath(args[0])
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("shell")
-if self.getDjangoVersion() < (1, 10, 0):
+args.append("--interface={0}".format(
-if (self.__plugin.getPreferences("Python3ConsoleType") ==
+self.__plugin.getPreferences("Python3ConsoleType")))
-"python"):
+with contextlib.suppress(DjangoNoSiteSelectedException):
-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:
 E5MessageBox.critical(
 None,
 self.tr('Process Generation Error'),
 self.tr('The Django process could not be started.'))
-except DjangoNoSiteSelectedException:
-pass
 def __sendTestEmail(self):
 """
 Private slot to send a test email through Django.
 """
-if self.getDjangoVersion() < (1, 9, 0):
-return
 title = self.tr("Send Test Email")
 from .DjangoSendTestEmailDataDialog import (
 DjangoSendTestEmailDataDialog
 )
 args.append("dumpdata")
 args.append("--format={0}".format(dumpFormat))
 args.append("--indent={0}".format(indent))
 for excl in excls:
 args.append("--exclude={0}".format(excl))
-if self.getDjangoVersion() >= (1, 9, 0):
+if self.__currentDatabase:
-if self.__currentDatabase:
+args.append("--database={0}".format(self.__currentDatabase))
-args.append("--database={0}".format(
-self.__currentDatabase))
 args += appls
 if dumpFormat == "json":
 fileFilters = self.tr("JSON Files (*.json)")
 elif dumpFormat == "xml":
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("loaddata")
-if self.getDjangoVersion() >= (1, 11, 0):
+for excl in excludes:
-for excl in excludes:
+args.append("--exclude={0}".format(excl))
-args.append("--exclude={0}".format(excl))
 if ignore:
 args.append("--ignorenonexistent")
 if appLabel:
 args.append("--app={0}".format(appLabel))
 if self.__currentDatabase:
 addr = self.__plugin.getPreferences("ServerAddress")
 if addr:
 args.append("--addrport={0}".format(addr))
 args += fixtures
-try:
+with contextlib.suppress(DjangoNoSiteSelectedException):
 if Utilities.isWindowsPlatform():
 serverProcStarted, pid = QProcess.startDetached(
 args[0], args[1:], self.__sitePath())
 else:
 if self.__testServerProc is not None:
 E5MessageBox.critical(
 None,
 self.tr('Process Generation Error'),
 self.tr('The Django test server could not be'
 ' started.'))
-except DjangoNoSiteSelectedException:
-pass
 def __testServerProcFinished(self):
 """
 Private slot connected to the finished signal of the test server.
 """
 args[0] = Utilities.getExecutablePath(args[0])
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("changepassword")
 args.append(userName)
-try:
+with contextlib.suppress(DjangoNoSiteSelectedException):
 wd = self.__sitePath()
 self.__adjustWorkingDirectory(args, wd)
 started, pid = QProcess.startDetached(
 args[0], args[1:], wd)
 if not started:
 E5MessageBox.critical(
 None,
 self.tr('Process Generation Error'),
 self.tr('The Django process could not be'
 ' started.'))
-except DjangoNoSiteSelectedException:
-pass
 def __createSuperUser(self):
 """
 Private slot to create a super user account.
 """
 args = Utilities.parseOptionString(consoleCmd)
 args[0] = Utilities.getExecutablePath(args[0])
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("createsuperuser")
-try:
+with contextlib.suppress(DjangoNoSiteSelectedException):
 wd = self.__sitePath()
 self.__adjustWorkingDirectory(args, wd)
 started, pid = QProcess.startDetached(args[0], args[1:], wd)
 if not started:
 E5MessageBox.critical(
 None,
 self.tr('Process Generation Error'),
 self.tr('The Django process could not be started.'))
-except DjangoNoSiteSelectedException:
-pass
 ##################################################################
 ## slots below implement session functions
 ##################################################################
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("compilemessages")
 args.append("--locale={0}".format(locale))
-if self.getDjangoVersion() >= (1, 8, 0):
+if self.__plugin.getPreferences("FuzzyTranslations"):
-if self.__plugin.getPreferences("FuzzyTranslations"):
+args.append("--use-fuzzy")
-args.append("--use-fuzzy")
 argsLists.append(args)
 if len(argsLists) == 0:
 E5MessageBox.warning(
 None,
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("compilemessages")
-if self.getDjangoVersion() >= (1, 8, 0):
+if self.__plugin.getPreferences("FuzzyTranslations"):
-if self.__plugin.getPreferences("FuzzyTranslations"):
+args.append("--use-fuzzy")
-args.append("--use-fuzzy")
 try:
 wd = self.__sitePath()
 except DjangoNoSiteSelectedException:
 E5MessageBox.warning(

Mercurial Repositories > Django Project / file comparison

comparison: ProjectDjango/Project.py

ProjectDjango/Project.py