Django Project: comparison ProjectDjango/Project.py

-:8413c2429808
+:64339135bd61
 import Preferences
 import Utilities
 import UI.PixmapCache
-class DjangoNoSiteSelectedException(Exception):
+class DjangoNoSiteSelectedError(Exception):
 """
 Exception thrown to signal, that there is no current site.
 """
 pass
 class QProcess(QProcessPyQt):
 """
 Class transforming the call arguments in case of gnome-terminal.
 """
 def start(self, cmd, args=None, mode=QIODeviceBase.OpenModeFlag.ReadWrite):
 """
 Public method to start the given program (cmd) in a new process, if
 none is already running, passing the command line arguments in args.
 @param cmd start the given program cmd
 @type str
 @param args list of parameters
 @type list of str
 @param mode access mode
 @type QIODeviceBase.OpenMode
 """
 if args is None:
 args = []
 if (
-cmd.endswith(('gnome-terminal', 'konsole', 'xfce4-terminal',
+cmd.endswith(
-'mate-terminal')) and
+("gnome-terminal", "konsole", "xfce4-terminal", "mate-terminal")
-'-e' in args
+)
+and "-e" in args
 ):
-index = args.index('-e') + 1
+index = args.index("-e") + 1
-cargs = ' '.join(args[index:])
+cargs = " ".join(args[index:])
 args[index:] = [cargs]
 super().start(cmd, args, mode)
 @staticmethod
-def startDetached(cmd, args=None, path=''):
+def startDetached(cmd, args=None, path=""):
 """
 Public static method to start the given program (cmd) in a new process,
 if none is already running, passing the command line arguments in args.
 @param cmd start the given program cmd
 @type str
 @param args list of parameters
 @type list of str
 @param path new working directory
 @return tuple of successful start and process id
 @rtype tuple of (bool, int)
 """
 if args is None:
 args = []
 if (
-cmd.endswith(('gnome-terminal', 'konsole', 'xfce4-terminal',
+cmd.endswith(
-'mate-terminal')) and
+("gnome-terminal", "konsole", "xfce4-terminal", "mate-terminal")
-'-e' in args
+)
+and "-e" in args
 ):
-index = args.index('-e') + 1
+index = args.index("-e") + 1
-cargs = ' '.join(args[index:])
+cargs = " ".join(args[index:])
 args[index:] = [cargs]
 return QProcessPyQt.startDetached(cmd, args, path)
 class Project(QObject):
 """
 Class implementing the Django project support.
 """
 RecentApplicationsKey = "Django/RecentApplications"
 RecentDatabaseNamesKey = "Django/RecentDatabaseNames"
 def __init__(self, plugin, iconSuffix, parent=None):
 """
 Constructor
 @param plugin reference to the plugin object
 @type ProjectDjangoPlugin
 @param iconSuffix suffix for the icons
 @type str
 @param parent parent
 @type QObject
 """
 super().__init__(parent)
 self.__plugin = plugin
 self.__iconSuffix = iconSuffix
 self.__ui = parent
 self.__ericProject = ericApp().getObject("Project")
 self.__virtualEnvManager = ericApp().getObject("VirtualEnvManager")
 self.__hooksInstalled = False
-self.__menus = {}   # dictionary with references to menus
+self.__menus = {}  # dictionary with references to menus
 self.__serverProc = None
 self.__testServerProc = None
 self.__recentApplications = []
 self.__loadRecentApplications()
 self.__recentDatabaseNames = []
 self.__loadRecentDatabaseNames()
 self.__recentTestData = {
 "RecentTestLabels": [],
 "RecentTestTags": [],
 "RecentTestExcludeTags": [],
 }
 self.__loadRecentTestData()
 def initActions(self):
 """
 Public method to define the Django actions.
 """
 self.actions = []
 self.selectSiteAct = EricAction(
-self.tr('Current Project'),
+self.tr("Current Project"), "", 0, 0, self, "django_current_project"
-"",
+)
-0, 0,
+self.selectSiteAct.setStatusTip(self.tr("Selects the current project"))
-self, 'django_current_project')
+self.selectSiteAct.setWhatsThis(
-self.selectSiteAct.setStatusTip(self.tr(
+self.tr(
-'Selects the current project'))
+"""<b>Current Project</b>"""
-self.selectSiteAct.setWhatsThis(self.tr(
+"""<p>Selects the current project. Used for multi-project """
-"""<b>Current Project</b>"""
+"""Django projects to switch between the projects.</p>"""
-"""<p>Selects the current project. Used for multi-project """
+)
-"""Django projects to switch between the projects.</p>"""
+)
-))
 self.selectSiteAct.triggered.connect(self.__selectSite)
 self.actions.append(self.selectSiteAct)
 self.__setCurrentSite(None)
 ##############################
 ## start actions below      ##
 ##############################
 self.startProjectAct = EricAction(
-self.tr('Start Project'),
+self.tr("Start Project"),
-self.tr('Start &Project'),
+self.tr("Start &Project"),
-0, 0,
+0,
-self, 'django_start_project')
+0,
-self.startProjectAct.setStatusTip(self.tr(
+self,
-'Starts a new Django project'))
+"django_start_project",
-self.startProjectAct.setWhatsThis(self.tr(
+)
-"""<b>Start Project</b>"""
+self.startProjectAct.setStatusTip(self.tr("Starts a new Django project"))
-"""<p>Starts a new Django project using "django-admin.py"""
+self.startProjectAct.setWhatsThis(
-""" startproject".</p>"""
+self.tr(
-))
+"""<b>Start Project</b>"""
+"""<p>Starts a new Django project using "django-admin.py"""
+""" startproject".</p>"""
+)
+)
 self.startProjectAct.triggered.connect(self.__startProject)
 self.actions.append(self.startProjectAct)
 self.startGlobalApplicationAct = EricAction(
-self.tr('Start Application (global)'),
+self.tr("Start Application (global)"),
-self.tr('Start Application (&global)'),
+self.tr("Start Application (&global)"),
-0, 0,
+0,
-self, 'django_start_global_application')
+0,
-self.startGlobalApplicationAct.setStatusTip(self.tr(
+self,
-'Starts a new global Django application'))
+"django_start_global_application",
-self.startGlobalApplicationAct.setWhatsThis(self.tr(
+)
-"""<b>Start Application (global)</b>"""
+self.startGlobalApplicationAct.setStatusTip(
-"""<p>Starts a new global Django application using"""
+self.tr("Starts a new global Django application")
-""" "django-admin.py startapp".</p>"""
+)
-))
+self.startGlobalApplicationAct.setWhatsThis(
-self.startGlobalApplicationAct.triggered.connect(
+self.tr(
-self.__startGlobalApplication)
+"""<b>Start Application (global)</b>"""
+"""<p>Starts a new global Django application using"""
+""" "django-admin.py startapp".</p>"""
+)
+)
+self.startGlobalApplicationAct.triggered.connect(self.__startGlobalApplication)
 self.actions.append(self.startGlobalApplicationAct)
 self.startLocalApplicationAct = EricAction(
-self.tr('Start Application (local)'),
+self.tr("Start Application (local)"),
-self.tr('Start Application (&local)'),
+self.tr("Start Application (&local)"),
-0, 0,
+0,
-self, 'django_start_local_application')
+0,
-self.startLocalApplicationAct.setStatusTip(self.tr(
+self,
-'Starts a new local Django application'))
+"django_start_local_application",
-self.startLocalApplicationAct.setWhatsThis(self.tr(
+)
-"""<b>Start Application (local)</b>"""
+self.startLocalApplicationAct.setStatusTip(
-"""<p>Starts a new local Django application using"""
+self.tr("Starts a new local Django application")
-""" "manage.py startapp".</p>"""
+)
-))
+self.startLocalApplicationAct.setWhatsThis(
-self.startLocalApplicationAct.triggered.connect(
+self.tr(
-self.__startLocalApplication)
+"""<b>Start Application (local)</b>"""
+"""<p>Starts a new local Django application using"""
+""" "manage.py startapp".</p>"""
+)
+)
+self.startLocalApplicationAct.triggered.connect(self.__startLocalApplication)
 self.actions.append(self.startLocalApplicationAct)
 ##############################
 ## run actions below        ##
 ##############################
 self.runServerAct = EricAction(
-self.tr('Run Server'),
+self.tr("Run Server"),
-self.tr('Run &Server'),
+self.tr("Run &Server"),
-0, 0,
+0,
-self, 'django_run_server')
+0,
-self.runServerAct.setStatusTip(self.tr(
+self,
-'Starts the Django Web server'))
+"django_run_server",
-self.runServerAct.setWhatsThis(self.tr(
+)
-"""<b>Run Server</b>"""
+self.runServerAct.setStatusTip(self.tr("Starts the Django Web server"))
-"""<p>Starts the Django Web server using "manage.py"""
+self.runServerAct.setWhatsThis(
-""" runserver".</p>"""
+self.tr(
-))
+"""<b>Run Server</b>"""
+"""<p>Starts the Django Web server using "manage.py"""
+""" runserver".</p>"""
+)
+)
 self.runServerAct.triggered.connect(self.__runServer)
 self.actions.append(self.runServerAct)
 self.runBrowserAct = EricAction(
-self.tr('Run Web-Browser'),
+self.tr("Run Web-Browser"),
-self.tr('Run &Web-Browser'),
+self.tr("Run &Web-Browser"),
-0, 0,
+0,
-self, 'django_run_browser')
+0,
-self.runBrowserAct.setStatusTip(self.tr(
+self,
-'Starts the default Web-Browser with the URL of the Django Web'
+"django_run_browser",
-' server'))
+)
-self.runBrowserAct.setWhatsThis(self.tr(
+self.runBrowserAct.setStatusTip(
-"""<b>Run Web-Browser</b>"""
+self.tr(
-"""<p>Starts the default Web-Browser with the URL of the """
+"Starts the default Web-Browser with the URL of the Django Web"
-"""Django Web server.</p>"""
+" server"
-))
+)
+)
+self.runBrowserAct.setWhatsThis(
+self.tr(
+"""<b>Run Web-Browser</b>"""
+"""<p>Starts the default Web-Browser with the URL of the """
+"""Django Web server.</p>"""
+)
+)
 self.runBrowserAct.triggered.connect(self.__runBrowser)
 self.actions.append(self.runBrowserAct)
 ##############################
 ## caching actions below    ##
 ##############################
 self.createCacheTableAct = EricAction(
-self.tr('Create Cache Tables'),
+self.tr("Create Cache Tables"),
-self.tr('C&reate Cache Tables'),
+self.tr("C&reate Cache Tables"),
-0, 0,
+0,
-self, 'django_create_cache_tables')
+0,
-self.createCacheTableAct.setStatusTip(self.tr(
+self,
-'Creates the tables needed to use the SQL cache backend'))
+"django_create_cache_tables",
-self.createCacheTableAct.setWhatsThis(self.tr(
+)
-"""<b>Create Cache Tables</b>"""
+self.createCacheTableAct.setStatusTip(
-"""<p>Creates the tables needed to use the SQL cache"""
+self.tr("Creates the tables needed to use the SQL cache backend")
-""" backend.</p>"""
+)
-))
+self.createCacheTableAct.setWhatsThis(
-self.createCacheTableAct.triggered.connect(
+self.tr(
-self.__createCacheTables)
+"""<b>Create Cache Tables</b>"""
+"""<p>Creates the tables needed to use the SQL cache"""
+""" backend.</p>"""
+)
+)
+self.createCacheTableAct.triggered.connect(self.__createCacheTables)
 self.actions.append(self.createCacheTableAct)
 ##############################
 ## help action below        ##
 ##############################
 self.helpAct = EricAction(
-self.tr('Help'),
+self.tr("Help"), self.tr("&Help"), 0, 0, self, "django_help"
-self.tr('&Help'),
+)
-0, 0,
+self.helpAct.setStatusTip(self.tr("Shows the Django help index"))
-self, 'django_help')
+self.helpAct.setWhatsThis(
-self.helpAct.setStatusTip(self.tr(
+self.tr("""<b>Help</b>""" """<p>Shows the Django help index page.</p>""")
-'Shows the Django help index'))
+)
-self.helpAct.setWhatsThis(self.tr(
-"""<b>Help</b>"""
-"""<p>Shows the Django help index page.</p>"""
-))
 self.helpAct.triggered.connect(self.__showHelpIndex)
 self.actions.append(self.helpAct)
 ##############################
 ## about action below       ##
 ##############################
 self.aboutDjangoAct = EricAction(
-self.tr('About Django'),
+self.tr("About Django"),
-self.tr('About D&jango'),
+self.tr("About D&jango"),
-0, 0,
+0,
-self, 'django_about')
+0,
-self.aboutDjangoAct.setStatusTip(self.tr(
+self,
-'Shows some information about Django'))
+"django_about",
-self.aboutDjangoAct.setWhatsThis(self.tr(
+)
-"""<b>About Django</b>"""
+self.aboutDjangoAct.setStatusTip(self.tr("Shows some information about Django"))
-"""<p>Shows some information about Django.</p>"""
+self.aboutDjangoAct.setWhatsThis(
-))
+self.tr(
+"""<b>About Django</b>"""
+"""<p>Shows some information about Django.</p>"""
+)
+)
 self.aboutDjangoAct.triggered.connect(self.__djangoInfo)
 self.actions.append(self.aboutDjangoAct)
 ##############################
 ## check action below       ##
 ##############################
 self.checkAct = EricAction(
-self.tr('Check Project'),
+self.tr("Check Project"),
-self.tr('Check Project'),
+self.tr("Check Project"),
-0, 0,
+0,
-self, 'django_check_project')
+0,
-self.checkAct.setStatusTip(self.tr(
+self,
-'Inspects the Django project for common problems'))
+"django_check_project",
-self.checkAct.setWhatsThis(self.tr(
+)
-"""<b>Check Project</b>"""
+self.checkAct.setStatusTip(
-"""<p>This inspects the Django project for common problems.</p>"""
+self.tr("Inspects the Django project for common problems")
-))
+)
+self.checkAct.setWhatsThis(
+self.tr(
+"""<b>Check Project</b>"""
+"""<p>This inspects the Django project for common problems.</p>"""
+)
+)
 self.checkAct.triggered.connect(self.__performCheck)
 self.actions.append(self.checkAct)
 self.__initDatabaseActions()
 self.__initDatabaseSqlActions()
 self.__initMigrationActions()
 self.__initToolsActions()
 self.__initTestingActions()
 def __initDatabaseActions(self):
 """
 Private method to define the database related actions.
 """
 self.selectDatabaseNameAct = EricAction(
-self.tr('Current Database'),
+self.tr("Current Database"), "", 0, 0, self, "django_current_database"
-"",
+)
-0, 0,
+self.selectDatabaseNameAct.setStatusTip(self.tr("Selects the current database"))
-self, 'django_current_database')
+self.selectDatabaseNameAct.setWhatsThis(
-self.selectDatabaseNameAct.setStatusTip(self.tr(
+self.tr(
-'Selects the current database'))
+"""<b>Current Database</b>"""
-self.selectDatabaseNameAct.setWhatsThis(self.tr(
+"""<p>Selects the database name to be used by all database"""
-"""<b>Current Database</b>"""
+""" actions. An empty database name indicates to use the default"""
-"""<p>Selects the database name to be used by all database"""
+""" name.</p>"""
-""" actions. An empty database name indicates to use the default"""
+)
-""" name.</p>"""
+)
-))
 self.selectDatabaseNameAct.triggered.connect(self.__selectDatabaseName)
 self.actions.append(self.selectDatabaseNameAct)
 self.__setCurrentDatabase(None)
 self.inspectDatabaseAct = EricAction(
-self.tr('Introspect'),
+self.tr("Introspect"),
-self.tr('&Introspect'),
+self.tr("&Introspect"),
-0, 0,
+0,
-self, 'django_database_inspect')
+0,
-self.inspectDatabaseAct.setStatusTip(self.tr(
+self,
-'Introspects the database tables and outputs a Django model'
+"django_database_inspect",
-' module'))
+)
-self.inspectDatabaseAct.setWhatsThis(self.tr(
+self.inspectDatabaseAct.setStatusTip(
-"""<b>Introspect</b>"""
+self.tr(
-"""<p>Introspects the database tables and outputs a """
+"Introspects the database tables and outputs a Django model" " module"
-"""Django model module.</p>"""
+)
-))
+)
+self.inspectDatabaseAct.setWhatsThis(
+self.tr(
+"""<b>Introspect</b>"""
+"""<p>Introspects the database tables and outputs a """
+"""Django model module.</p>"""
+)
+)
 self.inspectDatabaseAct.triggered.connect(self.__databaseInspect)
 self.actions.append(self.inspectDatabaseAct)
 self.flushDatabaseAct = EricAction(
-self.tr('Flush'),
+self.tr("Flush"), self.tr("&Flush"), 0, 0, self, "django_database_flush"
-self.tr('&Flush'),
+)
-0, 0,
+self.flushDatabaseAct.setStatusTip(
-self, 'django_database_flush')
+self.tr(
-self.flushDatabaseAct.setStatusTip(self.tr(
+"Returns all database tables to the state just after their"
-'Returns all database tables to the state just after their'
+" installation"
-' installation'))
+)
-self.flushDatabaseAct.setWhatsThis(self.tr(
+)
-"""<b>Flush</b>"""
+self.flushDatabaseAct.setWhatsThis(
-"""<p>Returns all database tables to the state """
+self.tr(
-"""just after their installation.</p>"""
+"""<b>Flush</b>"""
-))
+"""<p>Returns all database tables to the state """
+"""just after their installation.</p>"""
+)
+)
 self.flushDatabaseAct.triggered.connect(self.__databaseFlush)
 self.actions.append(self.flushDatabaseAct)
 self.databaseClientAct = EricAction(
-self.tr('Start Client Console'),
+self.tr("Start Client Console"),
-self.tr('Start &Client Console'),
+self.tr("Start &Client Console"),
-0, 0,
+0,
-self, 'django_database_client')
+0,
-self.databaseClientAct.setStatusTip(self.tr(
+self,
-'Starts a console window for the database client'))
+"django_database_client",
-self.databaseClientAct.setWhatsThis(self.tr(
+)
-"""<b>Start Client Console</b>"""
+self.databaseClientAct.setStatusTip(
-"""<p>Starts a console window for the database client.</p>"""
+self.tr("Starts a console window for the database client")
-))
+)
+self.databaseClientAct.setWhatsThis(
+self.tr(
+"""<b>Start Client Console</b>"""
+"""<p>Starts a console window for the database client.</p>"""
+)
+)
 self.databaseClientAct.triggered.connect(self.__runDatabaseClient)
 self.actions.append(self.databaseClientAct)
 def __initDatabaseSqlActions(self):
 """
 Private method to define the database SQL related actions.
 """
 self.databaseSqlFlushAct = EricAction(
-self.tr('Flush Database'),
+self.tr("Flush Database"),
-self.tr('&Flush Database'),
+self.tr("&Flush Database"),
-0, 0,
+0,
-self, 'django_database_sql_flush_database')
+0,
-self.databaseSqlFlushAct.setStatusTip(self.tr(
+self,
-'Prints a list of statements to return all database tables to the'
+"django_database_sql_flush_database",
-' state just after their installation'))
+)
-self.databaseSqlFlushAct.setWhatsThis(self.tr(
+self.databaseSqlFlushAct.setStatusTip(
-"""<b>Flush Database</b>"""
+self.tr(
-"""<p>Prints a list of statements to return all database tables"""
+"Prints a list of statements to return all database tables to the"
-""" to the state just after their installation.</p>"""
+" state just after their installation"
-))
+)
-self.databaseSqlFlushAct.triggered.connect(
+)
-self.__databaseSqlFlushDatabase)
+self.databaseSqlFlushAct.setWhatsThis(
+self.tr(
+"""<b>Flush Database</b>"""
+"""<p>Prints a list of statements to return all database tables"""
+""" to the state just after their installation.</p>"""
+)
+)
+self.databaseSqlFlushAct.triggered.connect(self.__databaseSqlFlushDatabase)
 self.actions.append(self.databaseSqlFlushAct)
 self.databaseSqlResetSeqAct = EricAction(
-self.tr('Reset Sequences'),
+self.tr("Reset Sequences"),
-self.tr('Reset &Sequences'),
+self.tr("Reset &Sequences"),
-0, 0,
+0,
-self, 'django_database_sql_reset_sequences')
+0,
-self.databaseSqlResetSeqAct.setStatusTip(self.tr(
+self,
-'Prints the SQL statements for resetting sequences for '
+"django_database_sql_reset_sequences",
-'one or more applications'))
+)
-self.databaseSqlResetSeqAct.setWhatsThis(self.tr(
+self.databaseSqlResetSeqAct.setStatusTip(
-"""<b>Reset Sequences</b>"""
+self.tr(
-"""<p>Prints the SQL statements for resetting sequences for """
+"Prints the SQL statements for resetting sequences for "
-"""one or more applications.</p>"""
+"one or more applications"
-))
+)
-self.databaseSqlResetSeqAct.triggered.connect(
+)
-self.__databaseSqlResetSequences)
+self.databaseSqlResetSeqAct.setWhatsThis(
+self.tr(
+"""<b>Reset Sequences</b>"""
+"""<p>Prints the SQL statements for resetting sequences for """
+"""one or more applications.</p>"""
+)
+)
+self.databaseSqlResetSeqAct.triggered.connect(self.__databaseSqlResetSequences)
 self.actions.append(self.databaseSqlResetSeqAct)
 self.databaseSqlMigrateAct = EricAction(
-self.tr('Apply Migration'),
+self.tr("Apply Migration"),
-self.tr('&Apply Migration'),
+self.tr("&Apply Migration"),
-0, 0,
+0,
-self, 'django_database_sql_apply_migration')
+0,
-self.databaseSqlMigrateAct.setStatusTip(self.tr(
+self,
-'Prints the SQL statements to apply a migration of an'
+"django_database_sql_apply_migration",
-' application'))
+)
-self.databaseSqlMigrateAct.setWhatsThis(self.tr(
+self.databaseSqlMigrateAct.setStatusTip(
-"""<b>Apply Migration</b>"""
+self.tr(
-"""<p>Prints the SQL statements to apply a migration of an"""
+"Prints the SQL statements to apply a migration of an" " application"
-""" application.</p>"""
+)
-))
+)
-self.databaseSqlMigrateAct.triggered.connect(
+self.databaseSqlMigrateAct.setWhatsThis(
-self.__databaseSqlMigrate)
+self.tr(
+"""<b>Apply Migration</b>"""
+"""<p>Prints the SQL statements to apply a migration of an"""
+""" application.</p>"""
+)
+)
+self.databaseSqlMigrateAct.triggered.connect(self.__databaseSqlMigrate)
 self.actions.append(self.databaseSqlMigrateAct)
 self.databaseSqlMigrateBackwardsAct = EricAction(
-self.tr('Unapply Migration'),
+self.tr("Unapply Migration"),
-self.tr('&Unapply Migration'),
+self.tr("&Unapply Migration"),
-0, 0,
+0,
-self, 'django_database_sql_unapply_migration')
+0,
-self.databaseSqlMigrateBackwardsAct.setStatusTip(self.tr(
+self,
-'Prints the SQL statements to unapply a migration of an'
+"django_database_sql_unapply_migration",
-' application'))
+)
-self.databaseSqlMigrateBackwardsAct.setWhatsThis(self.tr(
+self.databaseSqlMigrateBackwardsAct.setStatusTip(
-"""<b>Unapply Migration</b>"""
+self.tr(
-"""<p>Prints the SQL statements to unapply a migration of an"""
+"Prints the SQL statements to unapply a migration of an" " application"
-""" application.</p>"""
+)
-))
+)
+self.databaseSqlMigrateBackwardsAct.setWhatsThis(
+self.tr(
+"""<b>Unapply Migration</b>"""
+"""<p>Prints the SQL statements to unapply a migration of an"""
+""" application.</p>"""
+)
+)
 self.databaseSqlMigrateBackwardsAct.triggered.connect(
-lambda: self.__databaseSqlMigrate(backwards=True))
+lambda: self.__databaseSqlMigrate(backwards=True)
+)
 self.actions.append(self.databaseSqlMigrateBackwardsAct)
 def __initToolsActions(self):
 """
 Private method to define the tool actions.
 """
 self.diffSettingsAct = EricAction(
-self.tr('Diff Settings'),
+self.tr("Diff Settings"),
-self.tr('&Diff Settings'),
+self.tr("&Diff Settings"),
-0, 0,
+0,
-self, 'django_tools_diffsettings')
+0,
-self.diffSettingsAct.setStatusTip(self.tr(
+self,
-'Shows the modification made to the settings'))
+"django_tools_diffsettings",
-self.diffSettingsAct.setWhatsThis(self.tr(
+)
-"""<b>Diff Settings</b>"""
+self.diffSettingsAct.setStatusTip(
-"""<p>Shows the modification made to the settings.</p>"""
+self.tr("Shows the modification made to the settings")
-))
+)
+self.diffSettingsAct.setWhatsThis(
+self.tr(
+"""<b>Diff Settings</b>"""
+"""<p>Shows the modification made to the settings.</p>"""
+)
+)
 self.diffSettingsAct.triggered.connect(self.__diffSettings)
 self.actions.append(self.diffSettingsAct)
 self.runPythonShellAct = EricAction(
-self.tr('Start Python Console'),
+self.tr("Start Python Console"),
-self.tr('Start &Python Console'),
+self.tr("Start &Python Console"),
-0, 0,
+0,
-self, 'django_tools_pythonconsole')
+0,
-self.runPythonShellAct.setStatusTip(self.tr(
+self,
-'Starts a Python interactive interpreter'))
+"django_tools_pythonconsole",
-self.runPythonShellAct.setWhatsThis(self.tr(
+)
-"""<b>Start Python Console</b>"""
+self.runPythonShellAct.setStatusTip(
-"""<p>Starts a Python interactive interpreter.</p>"""
+self.tr("Starts a Python interactive interpreter")
-))
+)
+self.runPythonShellAct.setWhatsThis(
+self.tr(
+"""<b>Start Python Console</b>"""
+"""<p>Starts a Python interactive interpreter.</p>"""
+)
+)
 self.runPythonShellAct.triggered.connect(self.__runPythonShell)
 self.actions.append(self.runPythonShellAct)
 self.testEmailAct = EricAction(
-self.tr('Send Test Email'),
+self.tr("Send Test Email"),
-self.tr('Send Test &Email'),
+self.tr("Send Test &Email"),
-0, 0,
+0,
-self, 'django_tools_sendtestemail')
+0,
-self.testEmailAct.setStatusTip(self.tr(
+self,
-'Send a test email through Django'))
+"django_tools_sendtestemail",
-self.testEmailAct.setWhatsThis(self.tr(
+)
-"""<b>Send Test Email</b>"""
+self.testEmailAct.setStatusTip(self.tr("Send a test email through Django"))
-"""<p>Sends a test email to confirm email sending through Django"""
+self.testEmailAct.setWhatsThis(
-""" is working.</p>"""
+self.tr(
-))
+"""<b>Send Test Email</b>"""
+"""<p>Sends a test email to confirm email sending through Django"""
+""" is working.</p>"""
+)
+)
 self.testEmailAct.triggered.connect(self.__sendTestEmail)
 self.actions.append(self.testEmailAct)
 def __initTestingActions(self):
 """
 Private method to define the testing actions.
 """
 self.dumpDataAct = EricAction(
-self.tr('Dump Data'),
+self.tr("Dump Data"),
-self.tr('&Dump Data'),
+self.tr("&Dump Data"),
-0, 0,
+0,
-self, 'django_tools_dumpdata')
+0,
-self.dumpDataAct.setStatusTip(self.tr(
+self,
-'Dump the database data to a fixture'))
+"django_tools_dumpdata",
-self.dumpDataAct.setWhatsThis(self.tr(
+)
-"""<b>Dump Data</b>"""
+self.dumpDataAct.setStatusTip(self.tr("Dump the database data to a fixture"))
-"""<p>Dump the database data to a fixture.</p>"""
+self.dumpDataAct.setWhatsThis(
-))
+self.tr(
+"""<b>Dump Data</b>""" """<p>Dump the database data to a fixture.</p>"""
+)
+)
 self.dumpDataAct.triggered.connect(self.__dumpData)
 self.actions.append(self.dumpDataAct)
 self.loadDataAct = EricAction(
-self.tr('Load Data'),
+self.tr("Load Data"),
-self.tr('&Load Data'),
+self.tr("&Load Data"),
-0, 0,
+0,
-self, 'django_tools_loaddata')
+0,
-self.loadDataAct.setStatusTip(self.tr(
+self,
-'Load data from fixture files'))
+"django_tools_loaddata",
-self.loadDataAct.setWhatsThis(self.tr(
+)
-"""<b>Load Data</b>"""
+self.loadDataAct.setStatusTip(self.tr("Load data from fixture files"))
-"""<p>Load data from fixture files.</p>"""
+self.loadDataAct.setWhatsThis(
-))
+self.tr("""<b>Load Data</b>""" """<p>Load data from fixture files.</p>""")
+)
 self.loadDataAct.triggered.connect(self.__loadData)
 self.actions.append(self.loadDataAct)
 self.runTestAct = EricAction(
-self.tr('Run Testsuite'),
+self.tr("Run Testsuite"),
-self.tr('Run &Testsuite'),
+self.tr("Run &Testsuite"),
-0, 0,
+0,
-self, 'django_tools_run_test')
+0,
-self.runTestAct.setStatusTip(self.tr(
+self,
-'Run the test suite for applications or the whole site'))
+"django_tools_run_test",
-self.runTestAct.setWhatsThis(self.tr(
+)
-"""<b>Run Testsuite</b>"""
+self.runTestAct.setStatusTip(
-"""<p>Run the test suite for applications or the whole site.</p>"""
+self.tr("Run the test suite for applications or the whole site")
-))
+)
+self.runTestAct.setWhatsThis(
+self.tr(
+"""<b>Run Testsuite</b>"""
+"""<p>Run the test suite for applications or the whole site.</p>"""
+)
+)
 self.runTestAct.triggered.connect(self.__runTestSuite)
 self.actions.append(self.runTestAct)
 self.runDeprecationTestAct = EricAction(
-self.tr('Run Testsuite (-Wall)'),
+self.tr("Run Testsuite (-Wall)"),
-self.tr('Run Testsuite (-Wall)'),
+self.tr("Run Testsuite (-Wall)"),
-0, 0,
+0,
-self, 'django_tools_run_deprecation_test')
+0,
-self.runDeprecationTestAct.setStatusTip(self.tr(
+self,
-'Run the test suite for applications or the whole site with'
+"django_tools_run_deprecation_test",
-' activated deprecation warnings'))
+)
-self.runDeprecationTestAct.setWhatsThis(self.tr(
+self.runDeprecationTestAct.setStatusTip(
-"""<b>Run Testsuite (-Wall)</b>"""
+self.tr(
-"""<p>Run the test suite for applications or the whole site"""
+"Run the test suite for applications or the whole site with"
-""" with activated deprecation warnings.</p>"""
+" activated deprecation warnings"
-))
+)
+)
+self.runDeprecationTestAct.setWhatsThis(
+self.tr(
+"""<b>Run Testsuite (-Wall)</b>"""
+"""<p>Run the test suite for applications or the whole site"""
+""" with activated deprecation warnings.</p>"""
+)
+)
 self.runDeprecationTestAct.triggered.connect(
-lambda: self.__runTestSuite(deprecation=True))
+lambda: self.__runTestSuite(deprecation=True)
+)
 self.actions.append(self.runDeprecationTestAct)
 self.runTestServerAct = EricAction(
-self.tr('Run Testserver'),
+self.tr("Run Testserver"),
-self.tr('Run Test&server'),
+self.tr("Run Test&server"),
-0, 0,
+0,
-self, 'django_tools_run_test_server')
+0,
-self.runTestServerAct.setStatusTip(self.tr(
+self,
-'Run a development server with data from a set of fixtures'))
+"django_tools_run_test_server",
-self.runTestServerAct.setWhatsThis(self.tr(
+)
-"""<b>Run Testserver</b>"""
+self.runTestServerAct.setStatusTip(
-"""<p>Run a development server with data from a set of"""
+self.tr("Run a development server with data from a set of fixtures")
-""" fixtures.</p>"""
+)
-))
+self.runTestServerAct.setWhatsThis(
+self.tr(
+"""<b>Run Testserver</b>"""
+"""<p>Run a development server with data from a set of"""
+""" fixtures.</p>"""
+)
+)
 self.runTestServerAct.triggered.connect(self.__runTestServer)
 self.actions.append(self.runTestServerAct)
 def __initAuthorizationActions(self):
 """
 Private method to define the authorization actions.
 """
 self.changePasswordAct = EricAction(
-self.tr('Change Password'),
+self.tr("Change Password"),
-self.tr('Change &Password'),
+self.tr("Change &Password"),
-0, 0,
+0,
-self, 'django_auth_changepassword')
+0,
-self.changePasswordAct.setStatusTip(self.tr(
+self,
-'Change the password of a user'))
+"django_auth_changepassword",
-self.changePasswordAct.setWhatsThis(self.tr(
+)
-"""<b>Change Password</b>"""
+self.changePasswordAct.setStatusTip(self.tr("Change the password of a user"))
-"""<p>Change the password of a user of the Django project.</p>"""
+self.changePasswordAct.setWhatsThis(
-))
+self.tr(
+"""<b>Change Password</b>"""
+"""<p>Change the password of a user of the Django project.</p>"""
+)
+)
 self.changePasswordAct.triggered.connect(self.__changePassword)
 self.actions.append(self.changePasswordAct)
 self.createSuperUserAct = EricAction(
-self.tr('Create Superuser'),
+self.tr("Create Superuser"),
-self.tr('Create &Superuser'),
+self.tr("Create &Superuser"),
-0, 0,
+0,
-self, 'django_auth_createsuperuser')
+0,
-self.createSuperUserAct.setStatusTip(self.tr(
+self,
-'Create a superuser account'))
+"django_auth_createsuperuser",
-self.createSuperUserAct.setWhatsThis(self.tr(
+)
-"""<b>Create Superuser</b>"""
+self.createSuperUserAct.setStatusTip(self.tr("Create a superuser account"))
-"""<p>Create a superuser account for the Django project.</p>"""
+self.createSuperUserAct.setWhatsThis(
-))
+self.tr(
+"""<b>Create Superuser</b>"""
+"""<p>Create a superuser account for the Django project.</p>"""
+)
+)
 self.createSuperUserAct.triggered.connect(self.__createSuperUser)
 self.actions.append(self.createSuperUserAct)
 def __initSessionActions(self):
 """
 Private method to define the session actions.
 """
 self.clearSessionsAct = EricAction(
-self.tr('Clear Sessions'),
+self.tr("Clear Sessions"),
-self.tr('Clear &Sessions'),
+self.tr("Clear &Sessions"),
-0, 0,
+0,
-self, 'django_session_clearsessions')
+0,
-self.clearSessionsAct.setStatusTip(self.tr(
+self,
-'Clear expired sessions'))
+"django_session_clearsessions",
-self.clearSessionsAct.setWhatsThis(self.tr(
+)
-"""<b>Clear Sessions</b>"""
+self.clearSessionsAct.setStatusTip(self.tr("Clear expired sessions"))
-"""<p>Clear expired sessions of the Django project.</p>"""
+self.clearSessionsAct.setWhatsThis(
-))
+self.tr(
+"""<b>Clear Sessions</b>"""
+"""<p>Clear expired sessions of the Django project.</p>"""
+)
+)
 self.clearSessionsAct.triggered.connect(self.__clearSessions)
 self.actions.append(self.clearSessionsAct)
 def __initMigrationActions(self):
 """
 Private method to define the migration actions.
 """
 self.showMigrationsAct = EricAction(
-self.tr('Show Migrations'),
+self.tr("Show Migrations"),
-self.tr('&Show Migrations'),
+self.tr("&Show Migrations"),
-0, 0,
+0,
-self, 'django_migration_show')
+0,
-self.showMigrationsAct.setStatusTip(self.tr(
+self,
-'Show a list of available migrations'))
+"django_migration_show",
-self.showMigrationsAct.setWhatsThis(self.tr(
+)
-"""<b>Show Migrations</b>"""
+self.showMigrationsAct.setStatusTip(
-"""<p>This shows a list of available migrations of the Django"""
+self.tr("Show a list of available migrations")
-""" project and their status.</p>"""
+)
-))
+self.showMigrationsAct.setWhatsThis(
+self.tr(
+"""<b>Show Migrations</b>"""
+"""<p>This shows a list of available migrations of the Django"""
+""" project and their status.</p>"""
+)
+)
 self.showMigrationsAct.triggered.connect(self.__showMigrationsList)
 self.actions.append(self.showMigrationsAct)
 self.showMigrationsPlanAct = EricAction(
-self.tr('Show Migrations Plan'),
+self.tr("Show Migrations Plan"),
-self.tr('Show Migrations &Plan'),
+self.tr("Show Migrations &Plan"),
-0, 0,
+0,
-self, 'django_migration_show_plan')
+0,
-self.showMigrationsPlanAct.setStatusTip(self.tr(
+self,
-'Show a list with the migrations plan'))
+"django_migration_show_plan",
-self.showMigrationsPlanAct.setWhatsThis(self.tr(
+)
-"""<b>Show Migrations Plan</b>"""
+self.showMigrationsPlanAct.setStatusTip(
-"""<p>This shows a list with the migrations plan of the Django"""
+self.tr("Show a list with the migrations plan")
-""" project.</p>"""
+)
-))
+self.showMigrationsPlanAct.setWhatsThis(
+self.tr(
+"""<b>Show Migrations Plan</b>"""
+"""<p>This shows a list with the migrations plan of the Django"""
+""" project.</p>"""
+)
+)
 self.showMigrationsPlanAct.triggered.connect(self.__showMigrationsPlan)
 self.actions.append(self.showMigrationsPlanAct)
 self.migrateAllAct = EricAction(
-self.tr('Apply All Migrations'),
+self.tr("Apply All Migrations"),
-self.tr('&Apply All Migrations'),
+self.tr("&Apply All Migrations"),
-0, 0,
+0,
-self, 'django_migration_apply_all')
+0,
-self.migrateAllAct.setStatusTip(self.tr(
+self,
-'Apply all available migrations'))
+"django_migration_apply_all",
-self.migrateAllAct.setWhatsThis(self.tr(
+)
-"""<b>Apply All Migrations</b>"""
+self.migrateAllAct.setStatusTip(self.tr("Apply all available migrations"))
-"""<p>This applies all migrations of the Django project.</p>"""
+self.migrateAllAct.setWhatsThis(
-))
+self.tr(
+"""<b>Apply All Migrations</b>"""
+"""<p>This applies all migrations of the Django project.</p>"""
+)
+)
 self.migrateAllAct.triggered.connect(self.__applyAllMigrations)
 self.actions.append(self.migrateAllAct)
 self.migrateSelectedAct = EricAction(
-self.tr('Apply Selected Migrations'),
+self.tr("Apply Selected Migrations"),
-self.tr('Apply Selected Migrations'),
+self.tr("Apply Selected Migrations"),
-0, 0,
+0,
-self, 'django_migration_apply_selected')
+0,
-self.migrateSelectedAct.setStatusTip(self.tr(
+self,
-'Apply selected migrations'))
+"django_migration_apply_selected",
-self.migrateSelectedAct.setWhatsThis(self.tr(
+)
-"""<b>Apply Selected Migrations</b>"""
+self.migrateSelectedAct.setStatusTip(self.tr("Apply selected migrations"))
-"""<p>This applies selected migrations of the Django"""
+self.migrateSelectedAct.setWhatsThis(
-""" project.</p>"""
+self.tr(
-))
+"""<b>Apply Selected Migrations</b>"""
-self.migrateSelectedAct.triggered.connect(
+"""<p>This applies selected migrations of the Django"""
-self.__applySelectedMigrations)
+""" project.</p>"""
+)
+)
+self.migrateSelectedAct.triggered.connect(self.__applySelectedMigrations)
 self.actions.append(self.migrateSelectedAct)
 self.unmigrateAct = EricAction(
-self.tr('Unapply Migrations'),
+self.tr("Unapply Migrations"),
-self.tr('&Unapply Migrations'),
+self.tr("&Unapply Migrations"),
-0, 0,
+0,
-self, 'django_migration_unapply')
+0,
-self.unmigrateAct.setStatusTip(self.tr(
+self,
-'Unapply all migrations for an app'))
+"django_migration_unapply",
-self.unmigrateAct.setWhatsThis(self.tr(
+)
-"""<b>Unapply Migrations</b>"""
+self.unmigrateAct.setStatusTip(self.tr("Unapply all migrations for an app"))
-"""<p>This unapplies all migrations for an app of the Django"""
+self.unmigrateAct.setWhatsThis(
-""" project.</p>"""
+self.tr(
-))
+"""<b>Unapply Migrations</b>"""
+"""<p>This unapplies all migrations for an app of the Django"""
+""" project.</p>"""
+)
+)
 self.unmigrateAct.triggered.connect(self.__unapplyMigrations)
 self.actions.append(self.unmigrateAct)
 self.makeMigrationsAct = EricAction(
-self.tr('Make Migrations'),
+self.tr("Make Migrations"),
-self.tr('&Make Migrations'),
+self.tr("&Make Migrations"),
-0, 0,
+0,
-self, 'django_migration_make')
+0,
-self.makeMigrationsAct.setStatusTip(self.tr(
+self,
-'Generate migrations for the project'))
+"django_migration_make",
-self.makeMigrationsAct.setWhatsThis(self.tr(
+)
-"""<b>Make Migrations</b>"""
+self.makeMigrationsAct.setStatusTip(
-"""<p>This generates migrations for the Django project.</p>"""
+self.tr("Generate migrations for the project")
-))
+)
+self.makeMigrationsAct.setWhatsThis(
+self.tr(
+"""<b>Make Migrations</b>"""
+"""<p>This generates migrations for the Django project.</p>"""
+)
+)
 self.makeMigrationsAct.triggered.connect(self.__makeMigrations)
 self.actions.append(self.makeMigrationsAct)
 self.squashMigrationsAct = EricAction(
-self.tr('Squash Migrations'),
+self.tr("Squash Migrations"),
-self.tr('S&quash Migrations'),
+self.tr("S&quash Migrations"),
-0, 0,
+0,
-self, 'django_migration_squash')
+0,
-self.squashMigrationsAct.setStatusTip(self.tr(
+self,
-'Squash migrations of an application of the project'))
+"django_migration_squash",
-self.squashMigrationsAct.setWhatsThis(self.tr(
+)
-"""<b>Squash Migrations</b>"""
+self.squashMigrationsAct.setStatusTip(
-"""<p>This squashes migrations of an application of the"""
+self.tr("Squash migrations of an application of the project")
-""" Django project.</p>"""
+)
-))
+self.squashMigrationsAct.setWhatsThis(
+self.tr(
+"""<b>Squash Migrations</b>"""
+"""<p>This squashes migrations of an application of the"""
+""" Django project.</p>"""
+)
+)
 self.squashMigrationsAct.triggered.connect(self.__squashMigrations)
 self.actions.append(self.squashMigrationsAct)
 def initMenu(self):
 """
 Public method to initialize the Django menu.
 @return the menu generated
 @rtype QMenu
 """
-self.__menus = {}   # clear menus references
+self.__menus = {}  # clear menus references
-menu = QMenu(self.tr('D&jango'), self.__ui)
+menu = QMenu(self.tr("D&jango"), self.__ui)
 menu.setTearOffEnabled(True)
 menu.addAction(self.selectSiteAct)
 menu.addSeparator()
 menu.addAction(self.runServerAct)
 menu.addAction(self.runBrowserAct)
 menu.addSeparator()
 menu.addMenu(self.__initSessionMenu())
 menu.addSeparator()
 menu.addAction(self.aboutDjangoAct)
 menu.addSeparator()
 menu.addAction(self.helpAct)
 self.__menus["main"] = menu
 return menu
 def __initDatabaseMenu(self):
 """
 Private method to initialize the database menu.
 @return the menu generated
 @rtype QMenu
 """
 menu = QMenu(self.tr("&Database"), self.__ui)
 menu.setTearOffEnabled(True)
 menu.addAction(self.selectDatabaseNameAct)
 menu.addSeparator()
 menu.addAction(self.inspectDatabaseAct)
 menu.addSeparator()
 menu.addAction(self.flushDatabaseAct)
 menu.addSeparator()
 menu.addAction(self.databaseClientAct)
 menu.addSeparator()
 menu.addMenu(self.__initDatabaseSqlMenu())
 self.__menus["database"] = menu
 return menu
 def __initDatabaseSqlMenu(self):
 """
 Private method to initialize the database SQL submenu.
 @return the menu generated
 @rtype QMenu
 """
 menu = QMenu(self.tr("Show &SQL"), self.__ui)
 menu.setTearOffEnabled(True)
 menu.addAction(self.databaseSqlFlushAct)
 menu.addAction(self.databaseSqlResetSeqAct)
 menu.addSeparator()
 menu.addAction(self.databaseSqlMigrateAct)
 menu.addAction(self.databaseSqlMigrateBackwardsAct)
 self.__menus["sql"] = menu
 return menu
 def __initMigrationsMenu(self):
 """
 Private method to initialize the Migrations submenu.
 @return the menu generated
 @rtype QMenu
 """
 menu = QMenu(self.tr("&Migrations"), self.__ui)
 menu.setTearOffEnabled(True)
 menu.addAction(self.showMigrationsAct)
 menu.addAction(self.showMigrationsPlanAct)
 menu.addSeparator()
 menu.addAction(self.migrateAllAct)
 menu.addAction(self.migrateSelectedAct)
 menu.addAction(self.unmigrateAct)
 menu.addSeparator()
 menu.addAction(self.makeMigrationsAct)
 menu.addSeparator()
 menu.addAction(self.squashMigrationsAct)
 self.__menus["migrations"] = menu
 return menu
 def __initToolsMenu(self):
 """
 Private method to initialize the tools menu.
 @return the menu generated
 @rtype QMenu
 """
 menu = QMenu(self.tr("&Tools"), self.__ui)
 menu.setTearOffEnabled(True)
 menu.addAction(self.diffSettingsAct)
 menu.addSeparator()
 menu.addAction(self.runPythonShellAct)
 menu.addSeparator()
 menu.addAction(self.testEmailAct)
 self.__menus["tools"] = menu
 return menu
 def __initTestingMenu(self):
 """
 Private method to initialize the testing menu.
 @return the menu generated
 @rtype QMenu
 """
 menu = QMenu(self.tr("T&esting"), self.__ui)
 menu.setTearOffEnabled(True)
 menu.addAction(self.dumpDataAct)
 menu.addAction(self.loadDataAct)
 menu.addSeparator()
 menu.addAction(self.runTestAct)
 menu.addAction(self.runDeprecationTestAct)
 menu.addAction(self.runTestServerAct)
 self.__menus["testing"] = menu
 return menu
 def __initAuthorizationMenu(self):
 """
 Private method to initialize the authorization menu.
 @return the menu generated
 @rtype QMenu
 """
 menu = QMenu(self.tr("&Authorization"), self.__ui)
 menu.setTearOffEnabled(True)
 menu.addAction(self.changePasswordAct)
 menu.addAction(self.createSuperUserAct)
 self.__menus["authorization"] = menu
 return menu
 def __initSessionMenu(self):
 """
 Private method to initialize the authorization menu.
 @return the menu generated
 @rtype QMenu
 """
 menu = QMenu(self.tr("&Session"), self.__ui)
 menu.setTearOffEnabled(True)
 menu.addAction(self.clearSessionsAct)
 self.__menus["session"] = menu
 return menu
 def getMenu(self, name):
 """
 Public method to get a reference to the requested menu.
 @param name name of the menu
 @type str
 @return reference to the menu or None, if no menu with the given
 name exists
 @rtype QMenu
 """
 if name in self.__menus:
 return self.__menus[name]
 else:
 return None
 def getMenuNames(self):
 """
 Public method to get the names of all menus.
 @return menu names
 @rtype list of str
 """
 return list(self.__menus.keys())
 ##################################################################
 ## methods below implement the various hook related functions
 ##################################################################
 def registerOpenHook(self):
 """
 Public method to register the open hook to open a translations file
 in a translations editor.
 """
 editor = self.__plugin.getPreferences("TranslationsEditor")
 if editor:
 self.__translationsBrowser.addHookMethodAndMenuEntry(
 "open",
 self.openPOEditor,
-self.tr("Open with {0}").format(
+self.tr("Open with {0}").format(os.path.basename(editor)),
-os.path.basename(editor)))
+)
 else:
 self.__translationsBrowser.removeHookMethod("open")
 def projectOpenedHooks(self):
 """
 Public method to add our hook methods.
 """
 if self.__ericProject.getProjectType() == "Django":
 self.__formsBrowser = (
-ericApp().getObject("ProjectBrowser")
+ericApp().getObject("ProjectBrowser").getProjectBrowser("forms")
-.getProjectBrowser("forms")
 )
 self.__formsBrowser.addHookMethodAndMenuEntry(
-"newForm",
+"newForm", self.newForm, self.tr("New template...")
-self.newForm, self.tr("New template..."))
+)
 self.__ericProject.projectLanguageAddedByCode.connect(
-self.__projectLanguageAdded)
+self.__projectLanguageAdded
+)
 self.__translationsBrowser = (
-ericApp().getObject("ProjectBrowser")
+ericApp().getObject("ProjectBrowser").getProjectBrowser("translations")
-.getProjectBrowser("translations"))
+)
 self.__translationsBrowser.addHookMethodAndMenuEntry(
-"generateAll",
+"generateAll", self.updateCatalogs, self.tr("Update all catalogs")
-self.updateCatalogs, self.tr("Update all catalogs"))
+)
 self.__translationsBrowser.addHookMethodAndMenuEntry(
 "generateSelected",
 self.updateSelectedCatalogs,
-self.tr("Update selected catalogs"))
+self.tr("Update selected catalogs"),
+)
 self.__translationsBrowser.addHookMethodAndMenuEntry(
-"generateAllWithObsolete", self.updateCatalogsWithObsolete,
+"generateAllWithObsolete",
-self.tr("Update all catalogs (with obsolete)"))
+self.updateCatalogsWithObsolete,
+self.tr("Update all catalogs (with obsolete)"),
+)
 self.__translationsBrowser.addHookMethodAndMenuEntry(
 "generateSelectedWithObsolete",
 self.updateSelectedCatalogsWithObsolete,
-self.tr("Update selected catalogs (with obsolete)"))
+self.tr("Update selected catalogs (with obsolete)"),
+)
 self.__translationsBrowser.addHookMethodAndMenuEntry(
-"releaseAll",
+"releaseAll", self.compileCatalogs, self.tr("Compile all catalogs")
-self.compileCatalogs, self.tr("Compile all catalogs"))
+)
 self.__translationsBrowser.addHookMethodAndMenuEntry(
 "releaseSelected",
 self.compileSelectedCatalogs,
-self.tr("Compile selected catalogs"))
+self.tr("Compile selected catalogs"),
+)
 self.__hooksInstalled = True
 self.registerOpenHook()
 def projectClosedHooks(self):
 """
 Public method to remove our hook methods.
 """
 if self.__hooksInstalled:
 self.__formsBrowser.removeHookMethod("newForm")
 self.__formsBrowser = None
 self.__ericProject.projectLanguageAddedByCode.disconnect(
-self.__projectLanguageAdded)
+self.__projectLanguageAdded
-self.__translationsBrowser.removeHookMethod(
+)
-"generateAll")
+self.__translationsBrowser.removeHookMethod("generateAll")
-self.__translationsBrowser.removeHookMethod(
+self.__translationsBrowser.removeHookMethod("generateSelected")
-"generateSelected")
+self.__translationsBrowser.removeHookMethod("generateAllWithObsolete")
-self.__translationsBrowser.removeHookMethod(
+self.__translationsBrowser.removeHookMethod("generateSelectedWithObsolete")
-"generateAllWithObsolete")
+self.__translationsBrowser.removeHookMethod("releaseAll")
-self.__translationsBrowser.removeHookMethod(
+self.__translationsBrowser.removeHookMethod("releaseSelected")
-"generateSelectedWithObsolete")
-self.__translationsBrowser.removeHookMethod(
-"releaseAll")
-self.__translationsBrowser.removeHookMethod(
-"releaseSelected")
 self.__translationsBrowser.removeHookMethod("open")
 self.__translationsBrowser = None
 self.__hooksInstalled = False
 def newForm(self, path):
 """
 Public method to create a new form.
 @param path full directory path for the new form file
 @type str
 """
 fname, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
 self.__ui,
 self.tr("New Form"),
 path,
 filter,
 None,
-EricFileDialog.DontConfirmOverwrite)
+EricFileDialog.DontConfirmOverwrite,
+)
 if not fname:
 # user aborted or didn't enter a filename
 return
 ext = QFileInfo(fname).suffix()
 if not ext:
 ex = selectedFilter.split("(*")[1].split(")")[0]
 if ex:
 fname += ex
 if os.path.exists(fname):
 res = EricMessageBox.yesNo(
 self.__ui,
 self.tr("New Form"),
 self.tr("The file already exists! Overwrite it?"),
-icon=EricMessageBox.Warning)
+icon=EricMessageBox.Warning,
+)
 if not res:
 # user selected to not overwrite
 return
 try:
 with open(fname, "w") as f:
-f.write('<!DOCTYPE html>')
+f.write("<!DOCTYPE html>")
-f.write('<html>\n')
+f.write("<html>\n")
-f.write('  <head>\n')
+f.write("  <head>\n")
 f.write('    <meta content="" />\n')
-f.write('    <title></title>\n')
+f.write("    <title></title>\n")
-f.write('    <link rel="stylesheet" type="text/css"'
+f.write(
-' href="style.css"/>')
+'    <link rel="stylesheet" type="text/css"' ' href="style.css"/>'
-f.write('    <!--[if lte IE 7]>')
+)
-f.write('      <link rel="stylesheet" type="text/css"'
+f.write("    <!--[if lte IE 7]>")
-' href="ie.css"/>')
+f.write(
-f.write('    <![endif]-->')
+'      <link rel="stylesheet" type="text/css"' ' href="ie.css"/>'
-f.write('  </head>\n')
+)
-f.write('\n')
+f.write("    <![endif]-->")
+f.write("  </head>\n")
+f.write("\n")
 f.write('  <body  class="bodyclass">\n')
 f.write('    <div id="container">')
-f.write('    </div>')
+f.write("    </div>")
-f.write('  </body>\n')
+f.write("  </body>\n")
 f.close()
-f.write('</html>\n')
+f.write("</html>\n")
 except OSError as e:
 EricMessageBox.critical(
 self.__ui,
 self.tr("New Form"),
-self.tr("<p>The new form file <b>{0}</b> could not be"
+self.tr(
-" created.<br> Problem: {1}</p>")
+"<p>The new form file <b>{0}</b> could not be"
-.format(fname, str(e)))
+" created.<br> Problem: {1}</p>"
+).format(fname, str(e)),
+)
 return
 self.__ericProject.appendFile(fname)
 self.__formsBrowser.sourceFile.emit(fname)
 ##################################################################
 ## slots below implement general functionality
 ##################################################################
 def projectClosed(self):
 """
 Public method to handle the closing of a project.
 """
 if self.__serverProc is not None:
 self.__serverProcFinished()
 self.__setCurrentSite(None)
 def __getExecutablePaths(self, file):
 """
 Private method to build all full paths of an executable file from
 the environment.
 @param file filename of the executable
 @type str
 @return list of full executable names, if the executable file is
 accessible via the searchpath defined by the PATH environment
 variable, or an empty list otherwise.
 @rtype list of str
 """
 paths = []
 if os.path.isabs(file):
 if os.access(file, os.X_OK):
 return [file]
 else:
 return []
 cur_path = os.path.join(os.curdir, file)
 if os.path.exists(cur_path) and os.access(cur_path, os.X_OK):
 paths.append(cur_path)
-path = os.getenv('PATH')
+path = os.getenv("PATH")
 # environment variable not defined
 if path is not None:
 dirs = path.split(os.pathsep)
 for directory in dirs:
 exe = os.path.join(directory, file)
 if os.access(exe, os.X_OK) and exe not in paths:
 paths.append(exe)
 return paths
 def supportedPythonVariants(self):
 """
 Public method to get the supported Python variants.
 @return list of supported Python variants
 @rtype list of str
 """
 variants = []
-for variant in ['Python3']:
+for variant in ["Python3"]:
 virtEnv = self.__getVirtualEnvironment(variant)
 if virtEnv:
 if self.__getDjangoAdminCommand(variant):
 variants.append(variant)
 else:
 fullCmds = Utilities.getExecutablePaths(cmd)
 except AttributeError:
 fullCmds = self.__getExecutablePaths(cmd)
 for fullCmd in fullCmds:
 try:
-with open(fullCmd, 'r', encoding='utf-8') as f:
+with open(fullCmd, "r", encoding="utf-8") as f:
 l0 = f.readline()
 except OSError:
 l0 = ""
 if self.__isSuitableForVariant(variant, l0):
 variants.append(variant)
 break
 return variants
 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
 @param line0 first line of the executable
 @type str
 @return flag indicating a suitable file was found
 @rtype bool
 """
 l0 = line0.lower()
-ok = (variant.lower() in l0 or
+ok = variant.lower() in l0 or "{0}.".format(variant[-1]) in l0
-"{0}.".format(variant[-1]) in l0)
 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 (one of '' or 'Python3')
 @type str
 @return path of the virtual environment
 @rtype str
 """
 if not language:
 language = self.__ericProject.getProjectLanguage()
 venvName = (
 self.__plugin.getPreferences("VirtualEnvironmentNamePy3")
-if language == "Python3" else
+if language == "Python3"
-""
+else ""
 )
 if venvName:
-virtEnv = self.__virtualEnvManager.getVirtualenvDirectory(
+virtEnv = self.__virtualEnvManager.getVirtualenvDirectory(venvName)
-venvName)
 if not virtEnv:
 virtEnv = os.path.dirname(
-self.__virtualEnvManager.getVirtualenvInterpreter(
+self.__virtualEnvManager.getVirtualenvInterpreter(venvName)
-venvName))
+)
 if virtEnv.endswith(("Scripts", "bin")):
 virtEnv = os.path.dirname(virtEnv)
 else:
 virtEnv = ""
 if virtEnv and not os.path.exists(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 (one of '' or 'Python3')
 @type str
 @return path of the debugger environment
 @rtype str
 if not debugEnv:
 if language == "Python3":
 venvName = Preferences.getDebugger("Python3VirtualEnv")
 else:
 venvName = ""
 if venvName:
-debugEnv = self.__virtualEnvManager.getVirtualenvDirectory(
+debugEnv = self.__virtualEnvManager.getVirtualenvDirectory(venvName)
-venvName)
 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 (one of '' or 'Python3')
 @type str
 @return full django-admin.py command
 @rtype str
 """
 if not language:
 language = self.__ericProject.getProjectLanguage()
 virtualEnv = self.__getVirtualEnvironment(language)
 if virtualEnv:
 if isWindowsPlatform():
 for cmd in [
 # standard Python
 else:
 cmds = [
 os.path.join(virtualEnv, "bin", "django-admin"),
 os.path.join(virtualEnv, "bin", "django-admin.py"),
 os.path.join(virtualEnv, "local", "bin", "django-admin"),
-os.path.join(virtualEnv, "local", "bin",
+os.path.join(virtualEnv, "local", "bin", "django-admin.py"),
-"django-admin.py"),
 ]
 for cmd in cmds:
 if os.path.exists(cmd):
 break
 else:
 break
 else:
 cmd = ""
 else:
 if language == "Python3":
-cmds = ["django-admin3",
+cmds = [
-"django-admin3.py",
+"django-admin3",
-"django-admin.py-3.10",
+"django-admin3.py",
-"django-admin.py-3.9",
+"django-admin.py-3.10",
-"django-admin.py-3.8",
+"django-admin.py-3.9",
-"django-admin.py-3.7",
+"django-admin.py-3.8",
-"django-admin.py-3.6",
+"django-admin.py-3.7",
-]
+"django-admin.py-3.6",
+]
 else:
 cmds = []
 cmds.extend(["django-admin", "django-admin.py"])
 for cmd in cmds:
 if Utilities.isinpath(cmd):
 break
 else:
 cmd = ""
 return cmd
 def __getPythonExecutable(self):
 """
 Private method to build the Python command.
 @return python command
 @rtype str
 """
 language = self.__ericProject.getProjectLanguage()
 if language == "Python3":
-venvName = self.__plugin.getPreferences(
+venvName = self.__plugin.getPreferences("VirtualEnvironmentNamePy3")
-"VirtualEnvironmentNamePy3")
 if not venvName:
 # if none configured, use the global one
 venvName = Preferences.getDebugger("Python3VirtualEnv")
 else:
 venvName = ""
 python = (
 self.__virtualEnvManager.getVirtualenvInterpreter(venvName)
-if venvName else
+if venvName
-""
+else ""
 )
 return python
 def __djangoInfo(self):
 """
 Private slot to show some info about Django.
 """
 version = self.getDjangoVersionString()
 url = "https://www.djangoproject.com"
 msgBox = EricMessageBox.EricMessageBox(
 EricMessageBox.Question,
 self.tr("About Django"),
 self.tr(
 "<p>Django is a high-level Python Web framework that"
 " encourages rapid development and clean, pragmatic"
 " design.</p>"
 "<p><table>"
 "<tr><td>Version:</td><td>{0}</td></tr>"
-"<tr><td>URL:</td><td><a href=\"{1}\">"
+'<tr><td>URL:</td><td><a href="{1}">'
 "{1}</a></td></tr>"
 "</table></p>"
 ).format(version, url),
 modal=True,
-buttons=EricMessageBox.Ok)
+buttons=EricMessageBox.Ok,
-msgBox.setIconPixmap(UI.PixmapCache.getPixmap(
+)
-os.path.join("ProjectDjango", "icons",
+msgBox.setIconPixmap(
-"django64-{0}".format(self.__iconSuffix))))
+UI.PixmapCache.getPixmap(
+os.path.join(
+"ProjectDjango", "icons", "django64-{0}".format(self.__iconSuffix)
+)
+)
+)
 msgBox.exec()
 def getDjangoVersionString(self):
 """
 Public method to get the Django version as a string.
 @return Django version
 @rtype str
 """
 djangoVersion = ""
-args = ['--version']
+args = ["--version"]
 ioEncoding = Preferences.getSystem("IOEncoding")
 cmd = self.__getDjangoAdminCommand()
 if cmd:
 if isWindowsPlatform():
 args.insert(0, cmd)
 cmd = self.__getPythonExecutable()
 process = QProcess()
 process.start(cmd, args)
 procStarted = process.waitForStarted()
 if procStarted:
 finished = process.waitForFinished(30000)
 if finished and process.exitCode() == 0:
-output = str(process.readAllStandardOutput(), ioEncoding,
+output = str(process.readAllStandardOutput(), ioEncoding, "replace")
-'replace')
 djangoVersion = output.splitlines()[0].strip()
 return djangoVersion
 def getDjangoVersion(self):
 """
 Public method to get the Django version as a tuple.
 @return Django version
 @rtype tuple of int
 """
 djangoVersionStr = self.getDjangoVersionString()
 djangoVersionList = []
 for part in djangoVersionStr.split("."):
 try:
 djangoVersionList.append(int(part))
 except ValueError:
 djangoVersionList.append(part)
 return tuple(djangoVersionList)
 def __getApplications(self):
 """
 Private method to ask the user for a list of application names.
 @return list of application names
 @rtype list of str
 """
 applStr, ok = QInputDialog.getItem(
 self.__ui,
 self.tr("Select Applications"),
 self.tr("Enter the list of applications separated by spaces."),
 self.getRecentApplications(),
-0, True)
+0,
+True,
+)
 if ok and applStr != "":
 self.setMostRecentApplication(applStr)
 return applStr.split()
 else:
 return []
 Preferences.Prefs.rsettings.sync()
 ra = Preferences.Prefs.rsettings.value(self.RecentApplicationsKey)
 if ra is not None:
 maxRecentApps = self.__plugin.getPreferences("RecentNumberApps")
 self.__recentApplications = ra[:maxRecentApps]
 def __saveRecentApplications(self):
 """
 Private method to save the list of recently used applications list.
 """
-Preferences.Prefs.rsettings.setValue(self.RecentApplicationsKey,
+Preferences.Prefs.rsettings.setValue(
-self.__recentApplications)
+self.RecentApplicationsKey, self.__recentApplications
+)
 Preferences.Prefs.rsettings.sync()
 def getRecentApplications(self):
 """
 Public method to get the list of recent applications.
 @return list of recent applications entries (list of strings)
 """
 self.__loadRecentApplications()
 return self.__recentApplications
 def setMostRecentApplication(self, applStr):
 """
 Public method to set the most recently used applications entry.
 @param applStr applications entry
 @type str
 """
 if applStr in self.__recentApplications:
 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 = {
 "RecentTestLabels": [],
 "RecentTestTags": [],
 "RecentTestExcludeTags": [],
 }
 Preferences.Prefs.rsettings.sync()
-maxRecentTestData = self.__plugin.getPreferences(
+maxRecentTestData = self.__plugin.getPreferences("RecentNumberTestData")
-"RecentNumberTestData")
 for key in self.__recentTestData:
 recent = Preferences.Prefs.rsettings.value("Django/" + key)
 if recent is not None:
 self.__recentTestData[key] = recent[:maxRecentTestData]
 def __saveRecentTestData(self):
 """
 Private method to save the list of recently used test data.
 """
 for key in self.__recentTestData:
-Preferences.Prefs.rsettings.setValue("Django/" + key,
+Preferences.Prefs.rsettings.setValue(
-self.__recentTestData[key])
+"Django/" + key, self.__recentTestData[key]
+)
 Preferences.Prefs.rsettings.sync()
 def getRecentTestData(self, key):
 """
 Public method to get the list of recent test data.
 @param key key (name) of the test data to get
 @type str
 @return list of recent test data entries
 @rtype list of str
 """
 self.__loadRecentTestData()
 return self.__recentTestData[key]
 def setMostRecentTestData(self, key, data):
 """
 Public method to set the most recently used test data entry.
 @param key key (name) of the test data to set
 @type str
 @param data test data entry to be set
 @type str
 """
 if data in self.__recentTestData[key]:
 self.__recentTestData[key].remove(data)
 self.__recentTestData[key].insert(0, data)
-maxRecentTestData = self.__plugin.getPreferences(
+maxRecentTestData = self.__plugin.getPreferences("RecentNumberTestData")
-"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 eric7 project.
 @return path of the eric7 project
 @rtype str
 """
 return self.__ericProject.getProjectPath()
 def __showHelpIndex(self):
 """
 Private slot to show the help index page.
 """
-page = os.path.join(os.path.dirname(__file__),
+page = os.path.join(
-"Documentation", "help", "index.html")
+os.path.dirname(__file__), "Documentation", "help", "index.html"
+)
 self.__ui.launchHelpViewer(page)
 def __isSpawningConsole(self, consoleCmd):
 """
 Private method to check, if the given console is a spawning console.
 @param consoleCmd console command
 @type str
 @return tuple of two entries giving an indication, if the console
 is spawning and the (possibly) cleaned console command
 @rtype tuple of (bool, str)
 """
-if consoleCmd and consoleCmd[0] == '@':
+if consoleCmd and consoleCmd[0] == "@":
 return (True, consoleCmd[1:])
 else:
 return (False, consoleCmd)
 def __adjustWorkingDirectory(self, args, wd):
 """
 Private method to adjust the working directory in the arguments list.
 @param args list of arguments to be modified
 @type list of str
 @param wd working directory
 @type str
 """
 elif args[0].endswith(("gnome-terminal", "mate-terminal")):
 for index in range(len(args)):
 if args[index].startswith("--working-directory="):
 args[index] = "--working-directory={0}".format(wd)
 break
 ##################################################################
 ## slots below implement creation functions
 ##################################################################
 def newProjectCreated(self):
 """
 Public slot to finish up the newly generated project.
 """
 if self.__ericProject.getProjectType() == "Django":
 ppath = self.__ericProject.getProjectPath()
 # get rid of an __init__.py file because it would be in our way
 initModule = os.path.join(ppath, "__init__.py")
 if os.path.exists(initModule):
 self.__ericProject.deleteFile("__init__.py")
 self.__ericProject.saveProject()
 def startProjectOrApplication(self):
 """
 Public slot to start a new Django project or application.
 """
 if self.__ericProject.getProjectType() == "Django":
 applStr = self.tr("Application")
 selections = ["", projectStr, applStr]
 selection, ok = QInputDialog.getItem(
 self.__ui,
 self.tr("Start Django"),
-self.tr("Select if this project should be a "
+self.tr(
-"Django Project or Application.<br />"
+"Select if this project should be a "
-"Select the empty entry for none."),
+"Django Project or Application.<br />"
+"Select the empty entry for none."
+),
 selections,
-0, False)
+0,
+False,
+)
 if ok and bool(selection):
 if selection == projectStr:
 path, projectName = os.path.split(
-self.__ericProject.getProjectPath())
+self.__ericProject.getProjectPath()
+)
 self.__createProject(projectName, path)
 elif selection == applStr:
-path, applName = os.path.split(
+path, applName = os.path.split(self.__ericProject.getProjectPath())
-self.__ericProject.getProjectPath())
 self.__createApplication(applName, path)
 def __createProject(self, projectName, path):
 """
 Private slot to create a new Django project.
 @param projectName name of the new project
 @type str
 @param path the directory where the project should be created
 @type str
 @return flag indicating a successful creation
 @rtype bool
 """
 title = self.tr("Start Django Project")
 # remove the project directory if it exists already
 ppath = os.path.join(path, projectName)
 if os.path.exists(ppath):
 okToRemove = EricMessageBox.yesNo(
 self.__ui,
 title,
-self.tr("""<p>The Django project path <b>{0}</b> exists"""
+self.tr(
-""" already. Shall it be removed and recreated?"""
+"""<p>The Django project path <b>{0}</b> exists"""
-"""</p>""").format(ppath))
+""" already. Shall it be removed and recreated?"""
+"""</p>"""
+).format(ppath),
+)
 if not okToRemove:
 EricMessageBox.information(
 self.__ui,
 title,
-self.tr("""<p>Please add the files to the eric project"""
+self.tr(
-""" manually.</p>"""))
+"""<p>Please add the files to the eric project"""
+""" manually.</p>"""
+),
+)
 return True
 shutil.rmtree(ppath, ignore_errors=True)
 args = []
 cmd = self.__getDjangoAdminCommand()
 if cmd:
 if Utilities.isWindowsPlatform():
 args.append(self.__getPythonExecutable())
 args.append(cmd)
 else:
 EricMessageBox.critical(
 self.__ui,
 title,
-self.tr("""<p>The <b>django-admin.py</b> script is"""
+self.tr(
-""" not in the path. Aborting...</p>"""))
+"""<p>The <b>django-admin.py</b> script is"""
+""" not in the path. Aborting...</p>"""
+),
+)
 return False
 args.append("startproject")
 args.append(projectName)
 dia = DjangoDialog(
-title,
+title, msgSuccess=self.tr("Django project created successfully.")
-msgSuccess=self.tr("Django project created successfully."))
+)
 res = dia.startProcess(args, path)
 if res:
 dia.exec()
 # create the base directory for translations
 i18nPath = os.path.join(path, projectName, "locale")
 if not os.path.exists(i18nPath):
 os.makedirs(i18nPath)
-if (
+if os.path.join(path, projectName) == self.__ericProject.getProjectPath():
-os.path.join(path, projectName) ==
-self.__ericProject.getProjectPath()
-):
 self.__setCurrentSite("")
 else:
 self.__setCurrentSite(projectName)
 return res
 def __startProject(self):
 """
 Private slot to start a new Django project.
 """
 projectName, ok = QInputDialog.getText(
 self.__ui,
 self.tr("Start Django Project"),
 self.tr("Enter the name of the new Django project."),
-QLineEdit.EchoMode.Normal)
+QLineEdit.EchoMode.Normal,
+)
 if ok and projectName != "":
-res = self.__createProject(projectName,
+res = self.__createProject(projectName, self.__ericProject.getProjectPath())
-self.__ericProject.getProjectPath())
 if res:
 # search for new files and add them to the project
-sitePath = os.path.join(self.__ericProject.getProjectPath(),
+sitePath = os.path.join(
-projectName)
+self.__ericProject.getProjectPath(), projectName
+)
 for entry in os.walk(sitePath):
 for fileName in entry[2]:
 fullName = os.path.join(entry[0], fileName)
 self.__ericProject.appendFile(fullName)
 def __createApplication(self, applName, path, isGlobal=True):
 """
 Private slot to create a new Django application.
 @param applName name of the new application
 @type str
 @param path the directory where the application should be created
 @type str
 @param isGlobal flag indicating a standalone Django application
 @type bool
 @return flag indicating a successful creation
 @rtype bool
 """
 title = self.tr("Start Django Application")
 # remove the application directory if it exists already
 apath = os.path.join(path, applName)
 if os.path.exists(apath):
 shutil.rmtree(apath, ignore_errors=True)
 args = []
 if isGlobal:
 cmd = self.__getDjangoAdminCommand()
 if cmd:
 if Utilities.isWindowsPlatform():
 args.append(cmd)
 else:
 EricMessageBox.critical(
 self.__ui,
 title,
-self.tr("""<p>The <b>django-admin.py</b> script"""
+self.tr(
-""" is not in the path."""
+"""<p>The <b>django-admin.py</b> script"""
-""" Aborting...</p>"""))
+""" is not in the path."""
+""" Aborting...</p>"""
+),
+)
 return False
 else:
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 try:
 path = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return False
 args.append("startapp")
 args.append(applName)
 dia = DjangoDialog(
-title,
+title, msgSuccess=self.tr("Django application created successfully.")
-msgSuccess=self.tr("Django application created successfully."))
+)
 res = dia.startProcess(args, path)
 if res:
 dia.exec()
 return res
 def __startGlobalApplication(self):
 """
 Private slot to start a new global Django application.
 """
 applName, ok = QInputDialog.getText(
 self.__ui,
 self.tr("Start Global Django Application"),
-self.tr("Enter the name of the new global Django"
+self.tr("Enter the name of the new global Django" " application."),
-" application."),
+QLineEdit.EchoMode.Normal,
-QLineEdit.EchoMode.Normal)
+)
 if ok and applName != "":
-res = self.__createApplication(applName,
+res = self.__createApplication(
-self.__ericProject.getProjectPath())
+applName, self.__ericProject.getProjectPath()
+)
 if res:
 # search for new files and add them to the project
-appPath = os.path.join(self.__ericProject.getProjectPath(),
+appPath = os.path.join(self.__ericProject.getProjectPath(), applName)
-applName)
 for entry in os.walk(appPath):
 for fileName in entry[2]:
 fullName = os.path.join(entry[0], fileName)
 self.__ericProject.appendFile(fullName)
 def __startLocalApplication(self):
 """
 Private slot to start a new local Django application.
 """
 applName, ok = QInputDialog.getText(
 self.__ui,
 self.tr("Start Local Django Application"),
 self.tr("Enter the name of the new local Django application."),
-QLineEdit.EchoMode.Normal)
+QLineEdit.EchoMode.Normal,
+)
 if ok and applName != "":
 res = self.__createApplication(applName, "", False)
 if res:
 try:
 # search for new files and add them to the project
 appPath = os.path.join(self.__sitePath(), applName)
 for entry in os.walk(appPath):
 for fileName in entry[2]:
 fullName = os.path.join(entry[0], fileName)
 self.__ericProject.appendFile(fullName)
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 ##################################################################
 ## methods below implement site related functions
 ##################################################################
 def __findSites(self):
 """
 Private method to determine the relative path to all manage.py scripts.
 @return list of sites
 @rtype list of str
 """
 sites = []
 for file in sorted(self.__ericProject.getSources()):
 if os.path.basename(file) == "manage.py":
 sites.append(os.path.dirname(file))
 return sites
 def __selectSite(self):
 """
 Private method to select a site to work with.
 """
 sites = self.__findSites()
 site, ok = QInputDialog.getItem(
 self.__ui,
 self.tr("Select Project"),
 self.tr("Select the Django project to work with."),
 sites,
-cur, False)
+cur,
+False,
+)
 if not ok:
 site = None
 self.__setCurrentSite(site)
 def __sitePath(self):
 """
 Private method to calculate the full path of the Django site.
 @return path of the site
 @rtype str
-@exception DjangoNoSiteSelectedException raised, if no site is selected
+@exception DjangoNoSiteSelectedError raised, if no site is selected
 """
 if self.__currentSite is None:
 self.__selectSite()
 if self.__currentSite is None:
-raise DjangoNoSiteSelectedException
+raise DjangoNoSiteSelectedError
 else:
-path = os.path.join(self.__ericProject.getProjectPath(),
+path = os.path.join(self.__ericProject.getProjectPath(), self.__currentSite)
-self.__currentSite)
 return path
 def __setCurrentSite(self, site):
 """
 Private slot to set the current site.
 @param site name of the site
 @type str
 """
 self.__currentSite = site
 if self.__currentSite is None:
 elif self.__currentSite == "":
 curSite = self.tr("Project")
 else:
 curSite = self.__currentSite
 self.selectSiteAct.setText(
-self.tr('&Current Django project ({0})').format(curSite))
+self.tr("&Current Django project ({0})").format(curSite)
+)
 if self.__currentSite is None:
 self.__ericProject.setTranslationPattern("")
 else:
 self.__ericProject.setTranslationPattern(
-os.path.join(site, "locale", "%language%", "LC_MESSAGES",
+os.path.join(site, "locale", "%language%", "LC_MESSAGES", "django.po")
-"django.po")
+)
-)
 def __site(self):
 """
 Private method to get the name of the current site.
 @return name of the site
 @rtype str
-@exception DjangoNoSiteSelectedException raised, if no site is selected
+@exception DjangoNoSiteSelectedError raised, if no site is selected
 """
 if self.__currentSite is None:
 self.__selectSite()
 if self.__currentSite is None:
-raise DjangoNoSiteSelectedException
+raise DjangoNoSiteSelectedError
 else:
 return self.__currentSite
 ##################################################################
 ## slots below implement run functions
 ##################################################################
 def __runServer(self):
 """
 Private slot to start the Django Web server.
 """
 consoleCmd = self.__isSpawningConsole(
-self.__plugin.getPreferences("ConsoleCommand"))[1]
+self.__plugin.getPreferences("ConsoleCommand")
+)[1]
 if consoleCmd:
 args = Utilities.parseOptionString(consoleCmd)
 args[0] = Utilities.getExecutablePath(args[0])
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 if not self.__plugin.getPreferences("UseThreading"):
 args.append("--nothreading")
 addr = self.__plugin.getPreferences("ServerAddress")
 if addr:
 args.append(addr)
-with contextlib.suppress(DjangoNoSiteSelectedException):
+with contextlib.suppress(DjangoNoSiteSelectedError):
 if Utilities.isWindowsPlatform():
 serverProcStarted, pid = QProcess.startDetached(
-args[0], args[1:], self.__sitePath())
+args[0], args[1:], self.__sitePath()
+)
 else:
 if self.__serverProc is not None:
 self.__serverProcFinished()
 self.__serverProc = QProcess()
-self.__serverProc.finished.connect(
+self.__serverProc.finished.connect(self.__serverProcFinished)
-self.__serverProcFinished)
 self.__serverProc.setWorkingDirectory(self.__sitePath())
 self.__serverProc.start(args[0], args[1:])
 serverProcStarted = self.__serverProc.waitForStarted()
 if not serverProcStarted:
 EricMessageBox.critical(
 None,
-self.tr('Process Generation Error'),
+self.tr("Process Generation Error"),
-self.tr('The Django server could not be started.'))
+self.tr("The Django server could not be started."),
+)
 def __serverProcFinished(self):
 """
 Private slot connected to the finished signal.
 """
 if (
-self.__serverProc is not None and
+self.__serverProc is not None
-self.__serverProc.state() != QProcess.ProcessState.NotRunning
+and self.__serverProc.state() != QProcess.ProcessState.NotRunning
 ):
 self.__serverProc.terminate()
 QTimer.singleShot(2000, self.__serverProc.kill)
 self.__serverProc.waitForFinished(3000)
 self.__serverProc = None
 def __runBrowser(self):
 """
 Private slot to start the default web browser with the server URL.
 """
 addr = self.__plugin.getPreferences("ServerAddress")
 ipv6 = self.__plugin.getPreferences("UseIPv6")
 if addr:
 # test for an IPv6 and port address
-if ']:' in addr:
+if "]:" in addr:
-addr, port = addr.rsplit(':', 1)
+addr, port = addr.rsplit(":", 1)
-elif ':' in addr:
+elif ":" in addr:
-addr, port = addr.split(':', 1)
+addr, port = addr.split(":", 1)
 else:
 port = addr
 if ipv6:
 addr = "[::1]"
 else:
 if self.__plugin.getPreferences("UseExternalBrowser"):
 res = QDesktopServices.openUrl(QUrl(url))
 if not res:
 EricMessageBox.critical(
 None,
-self.tr('Run Web-Browser'),
+self.tr("Run Web-Browser"),
-self.tr('Could not start the web-browser for the'
+self.tr(
-' url "{0}".').format(url.toString()))
+"Could not start the web-browser for the" ' url "{0}".'
+).format(url.toString()),
+)
 else:
 self.__ui.launchHelpViewer(url)
 ##################################################################
 ## slots below implement functions to save and load recently used
 ## database names
 ##################################################################
 def __loadRecentDatabaseNames(self):
 """
 Private method to load the list of recently used database names.
 """
 self.__recentDatabaseNames = [""]
 Preferences.Prefs.rsettings.sync()
 rdb = Preferences.Prefs.rsettings.value(self.RecentDatabaseNamesKey)
 if rdb is not None:
-maxRecentDatabaseNames = (
+maxRecentDatabaseNames = self.__plugin.getPreferences(
-self.__plugin.getPreferences("RecentNumberDatabaseNames"))
+"RecentNumberDatabaseNames"
+)
 self.__recentDatabaseNames = rdb[:maxRecentDatabaseNames]
 def __saveRecentDatabaseNames(self):
 """
 Private method to save the list of recently used database names.
 """
-Preferences.Prefs.rsettings.setValue(self.RecentDatabaseNamesKey,
+Preferences.Prefs.rsettings.setValue(
-self.__recentDatabaseNames)
+self.RecentDatabaseNamesKey, self.__recentDatabaseNames
+)
 Preferences.Prefs.rsettings.sync()
 def getRecentDatabaseNames(self):
 """
 Public method to get the list of recently used database names.
 @return list of recently used database names
 @rtype list of str
 """
 self.__loadRecentDatabaseNames()
 return self.__recentDatabaseNames
 def setMostRecentDatabaseNames(self, dbName):
 """
 Public method to set the most recently used database names.
 @param dbName database name
 @type str
 """
 if dbName in self.__recentDatabaseNames:
 self.__recentDatabaseNames.remove(dbName)
 self.__recentDatabaseNames.insert(0, dbName)
-maxRecentDatabaseNames = (
+maxRecentDatabaseNames = self.__plugin.getPreferences(
-self.__plugin.getPreferences("RecentNumberDatabaseNames"))
+"RecentNumberDatabaseNames"
+)
 if len(self.__recentDatabaseNames) > maxRecentDatabaseNames:
-self.__recentDatabaseNames = (
+self.__recentDatabaseNames = self.__recentDatabaseNames[
-self.__recentDatabaseNames[:maxRecentDatabaseNames])
+:maxRecentDatabaseNames
+]
 self.__saveRecentDatabaseNames()
 def __selectDatabaseName(self):
 """
 Private method to select the name of the database to work with.
 """
 recentDatabases = self.getRecentDatabaseNames()[:]
 if "" not in recentDatabases:
 recentDatabases.insert(1, "")
 selectedDatabase, ok = QInputDialog.getItem(
 self.__ui,
 self.tr("Database Name"),
 self.tr("Select a database name (leave empty for default):"),
 recentDatabases,
-0, True)
+0,
+True,
+)
 if ok:
 self.setMostRecentDatabaseNames(selectedDatabase)
 self.__setCurrentDatabase(selectedDatabase)
 def __setCurrentDatabase(self, database):
 """
 Private method to set the database name to be used.
 @param database name of the database
 @type str
 """
 if database is None:
 database = self.getRecentDatabaseNames()[0]
 self.__currentDatabase = database
 curDb = database if database else self.tr("<default>")
 self.selectDatabaseNameAct.setText(
-self.tr('&Current Database ({0})').format(curDb))
+self.tr("&Current Database ({0})").format(curDb)
+)
 def currentDatabase(self):
 """
 Public method to get the database name to be used.
 @return database name
 @rtype str
 """
 return self.__currentDatabase
 ##################################################################
 ## slots below implement database related functions
 ##################################################################
 def __databaseInspect(self):
 """
 Private slot to introspect the database and output a Django model
 module.
 """
 title = self.tr("Introspect Database")
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("inspectdb")
 if self.__currentDatabase:
 args.append("--database={0}".format(self.__currentDatabase))
 try:
 path = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 dia = DjangoDialog(title, fixed=True, linewrap=False)
 res = dia.startProcess(args, path, False)
 if res:
 dia.exec()
 def __databaseFlush(self):
 """
 Private slot to return all database tables to the state just after
 their installation.
 """
 try:
 path = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 title = self.tr("Flush Database")
 res = EricMessageBox.yesNo(
 self.__ui,
 title,
-self.tr("""Flushing the database will destroy all data."""
+self.tr(
-""" Are you sure?"""))
+"""Flushing the database will destroy all data.""" """ Are you sure?"""
+),
+)
 if res:
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("flush")
 args.append("--noinput")
 if self.__currentDatabase:
 args.append("--database={0}".format(self.__currentDatabase))
 dia = DjangoDialog(
-title,
+title, msgSuccess=self.tr("Database tables flushed" " successfully.")
-msgSuccess=self.tr("Database tables flushed"
+)
-" successfully."))
 res = dia.startProcess(args, path)
 if res:
 dia.exec()
 def __runDatabaseClient(self):
 """
 Private slot to start a database client for a Django project.
 """
 consoleCmd = self.__isSpawningConsole(
-self.__plugin.getPreferences("ConsoleCommand"))[1]
+self.__plugin.getPreferences("ConsoleCommand")
+)[1]
 if consoleCmd:
 args = Utilities.parseOptionString(consoleCmd)
 args[0] = Utilities.getExecutablePath(args[0])
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("dbshell")
 if self.__currentDatabase:
 args.append("--database={0}".format(self.__currentDatabase))
-with contextlib.suppress(DjangoNoSiteSelectedException):
+with contextlib.suppress(DjangoNoSiteSelectedError):
 wd = self.__sitePath()
 self.__adjustWorkingDirectory(args, wd)
 started, pid = QProcess.startDetached(args[0], args[1:], wd)
 if not started:
 EricMessageBox.critical(
 None,
-self.tr('Process Generation Error'),
+self.tr("Process Generation Error"),
-self.tr('The Django process could not be started.'))
+self.tr("The Django process could not be started."),
+)
 #######################################################################
 ## slots below implement database functions outputting SQL statements
 #######################################################################
 def __sqlCommand(self, title, command, requestApps=True):
 """
 Private method to perform an SQL creation function.
 @param title dialog title
 @type str
 @param command Django sql... command
 @type str
 @param requestApps flag indicating to request a list of applications
 to work on
 @type bool
 """
 try:
 path = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 if requestApps:
 apps = self.__getApplications()
 if not apps:
 return
 else:
 apps = []
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append(command)
 if self.__currentDatabase:
 args.append("--database={0}".format(self.__currentDatabase))
 args += apps
 fileFilter = self.tr("SQL Files (*.sql)")
-dia = DjangoDialog(title, fixed=True, linewrap=False,
+dia = DjangoDialog(title, fixed=True, linewrap=False, saveFilters=fileFilter)
-saveFilters=fileFilter)
 res = dia.startProcess(args, path, False)
 if res:
 dia.exec()
 def __databaseSqlFlushDatabase(self):
 """
 Private slot to print a list of statements to return all database
 tables to their initial state.
 """
 self.__sqlCommand(self.tr("Flush Database"), "sqlflush", False)
 def __databaseSqlResetSequences(self):
 """
 Private slot to print the SQL statements for resetting sequences for
 one or more applications.
 """
 self.__sqlCommand(self.tr("Reset Sequences"), "sqlsequencereset")
 def __databaseSqlMigrate(self, backwards=False):
 """
 Private slot to print the SQL statements for a migration of an
 application.
 @param backwards flag indicating to generate the SQL code to revert
 a migration
 @type bool
 """
 try:
 path = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 migrations = self.__getMigrations()
 if not migrations:
 EricMessageBox.information(
-None,
+None, self.tr("SQL Migrate"), self.tr("""No migrations available.""")
-self.tr("SQL Migrate"),
+)
-self.tr("""No migrations available."""))
 return
 title = self.tr("SQL Migrate")
-from .DjangoMigrationSelectionDialog import (
+from .DjangoMigrationSelectionDialog import DjangoMigrationSelectionDialog
-DjangoMigrationSelectionDialog
-)
+dlg = DjangoMigrationSelectionDialog(
-dlg = DjangoMigrationSelectionDialog(migrations,
+migrations, migrationRequired=True, suffix=self.__iconSuffix
-migrationRequired=True,
+)
-suffix=self.__iconSuffix)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 app, migration = dlg.getData()
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("sqlmigrate")
 if self.__currentDatabase:
 args.append("--database={0}".format(self.__currentDatabase))
 if backwards:
 args.append("--backwards")
 args.append(app)
 args.append(migration)
 fileFilter = self.tr("SQL Files (*.sql)")
-dia = DjangoDialog(title, fixed=True, linewrap=False,
+dia = DjangoDialog(
-saveFilters=fileFilter)
+title, fixed=True, linewrap=False, saveFilters=fileFilter
+)
 res = dia.startProcess(args, path, False)
 if res:
 dia.exec()
 ##################################################################
 ## slots below implement migration related functions
 ##################################################################
 def __showMigrationsList(self):
 """
 Private slot to show the available migrations and their status.
 """
 try:
 path = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 from .DjangoMigrationsListDialog import DjangoMigrationsListDialog
 self.__migrationsListDialog = DjangoMigrationsListDialog(
-DjangoMigrationsListDialog.MigrationsListMode, self, self.__ui)
+DjangoMigrationsListDialog.MigrationsListMode, self, self.__ui
+)
 self.__migrationsListDialog.show()
-self.__migrationsListDialog.start(self.__getPythonExecutable(), path,
+self.__migrationsListDialog.start(
-self.__currentDatabase)
+self.__getPythonExecutable(), path, self.__currentDatabase
+)
 def __showMigrationsPlan(self):
 """
 Private slot to show the migrations plan.
 """
 try:
 path = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 from .DjangoMigrationsListDialog import DjangoMigrationsListDialog
 self.__migrationsPlanDialog = DjangoMigrationsListDialog(
-DjangoMigrationsListDialog.MigrationsPlanMode, self, self.__ui)
+DjangoMigrationsListDialog.MigrationsPlanMode, self, self.__ui
+)
 self.__migrationsPlanDialog.show()
-self.__migrationsPlanDialog.start(self.__getPythonExecutable(), path,
+self.__migrationsPlanDialog.start(
-self.__currentDatabase)
+self.__getPythonExecutable(), path, self.__currentDatabase
+)
 def __applyAllMigrations(self):
 """
 Private slot to apply all migrations.
 """
 self.applyMigrations()
 def __applySelectedMigrations(self):
 """
 Private slot to apply selected migrations of a selected app.
 """
 migrations = self.__getMigrations()
 if not migrations:
 EricMessageBox.information(
 None,
 self.tr("Apply Selected Migrations"),
-self.tr("""No migrations available."""))
+self.tr("""No migrations available."""),
+)
 return
-from .DjangoMigrationSelectionDialog import (
+from .DjangoMigrationSelectionDialog import DjangoMigrationSelectionDialog
-DjangoMigrationSelectionDialog
-)
+dlg = DjangoMigrationSelectionDialog(migrations, suffix=self.__iconSuffix)
-dlg = DjangoMigrationSelectionDialog(migrations,
-suffix=self.__iconSuffix)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 app, migration = dlg.getData()
 self.applyMigrations(app=app, migration=migration)
 def applyMigrations(self, app=None, migration=None):
 """
 Public slot to apply migrations.
 @param app name of an application to apply migrations for
 @type str
 @param migration name of a migration to update to
 @type str
 """
 title = (
 self.tr("Unapply Migrations")
-if migration == "zero" else
+if migration == "zero"
-self.tr("Apply Migrations")
+else self.tr("Apply Migrations")
 )
 try:
 path = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("migrate")
 args.append("--noinput")
 if app:
 args.append(app)
 if migration:
 args.append(migration)
 dia = DjangoDialog(title)
 res = dia.startProcess(args, path)
 if res:
 dia.exec()
 def __unapplyMigrations(self):
 """
 Private slot to revert all migrations of an application.
 """
 apps = sorted(self.__getMigrations().keys())
 if not apps:
 EricMessageBox.information(
 None,
 self.tr("Unapply Migrations"),
-self.tr("""No migrations available."""))
+self.tr("""No migrations available."""),
+)
 return
 app, ok = QInputDialog.getItem(
 None,
 self.tr("Unapply Migrations"),
 self.tr("Select an application:"),
 [""] + apps,
-0, False)
+0,
+False,
+)
 if ok and app:
 self.applyMigrations(app=app, migration="zero")
 def __getMigrations(self):
 """
 Private method to get the available migrations.
 @return dictionary containing the available migrations
 @rtype dict with app name as key (str) and list of tuples of
 applied indication (bool) and migration name (str) as value
 """
 try:
 path = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return {}
 args = []
 args.append("manage.py")
 args.append("showmigrations")
 args.append("--list")
 if 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() and proc.waitForFinished():
-output = str(proc.readAllStandardOutput(),
+output = str(
-Preferences.getSystem("IOEncoding"), 'replace')
+proc.readAllStandardOutput(),
+Preferences.getSystem("IOEncoding"),
+"replace",
+)
 if output:
 recentApp = ""
 for line in output.splitlines():
 if not line.startswith(" "):
 # application name
 applied = line[1] != " "
 name = line[3:].strip()
 if recentApp:
 migrations[recentApp].append((applied, name))
 return migrations
 def __makeMigrations(self):
 """
 Private slot to generate migrations for the Django project.
 """
 from .DjangoMakeMigrationsDialog import DjangoMakeMigrationsDialog
 dlg = DjangoMakeMigrationsDialog(self.getRecentApplications())
 if dlg.exec() == QDialog.DialogCode.Accepted:
 apps, migration, dryRun, empty, merge = dlg.getData()
 if apps:
 self.setMostRecentApplication(apps)
 apps = apps.split()
 self.makeMigrations(apps, migration, dryRun, empty, merge)
-def makeMigrations(self, apps, migration=None, dryRun=False, empty=False,
+def makeMigrations(
-merge=False):
+self, apps, migration=None, dryRun=False, empty=False, merge=False
+):
 """
 Public method to generate migrations.
 @param apps list of application names to generate migrations for
 @type list of str
 @param migration name of the migration to generate
 @type str
 @param dryRun flag indicating a dry run
 @type bool
 @param merge flag indicating to fix migration conflicts
 @type bool
 """
 title = self.tr("Make Migrations")
 try:
 path = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("makemigrations")
 if migration:
 args.append("--empty")
 if merge:
 args.append("--merge")
 if apps:
 args += apps
 dia = DjangoDialog(title, showInput=True)
 res = dia.startProcess(args, path)
 if res:
 dia.exec()
 def __squashMigrations(self):
 """
 Private slot to squash migrations.
 """
 migrations = self.__getMigrations()
 if not migrations:
 EricMessageBox.information(
 None,
 self.tr("Squash Migrations"),
-self.tr("""No migrations available."""))
+self.tr("""No migrations available."""),
+)
 return
 from .DjangoSquashMigrationSelectionDialog import (
-DjangoSquashMigrationSelectionDialog
+DjangoSquashMigrationSelectionDialog,
 )
-dlg = DjangoSquashMigrationSelectionDialog(
-migrations, self, self.__iconSuffix)
+dlg = DjangoSquashMigrationSelectionDialog(migrations, self, self.__iconSuffix)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 app, start, end, noOptimize, name = dlg.getData()
 title = self.tr("Squash Migrations")
 try:
 path = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("squashmigrations")
 args.append("--noinput")
 args.append("--squashed-name={0}".format(name))
 args.append(app)
 if start:
 args.append(start)
 args.append(end)
 dia = DjangoDialog(title)
 res = dia.startProcess(args, path)
 if res:
 dia.exec()
 ##################################################################
 ## slots below implement some tool functions
 ##################################################################
 def __diffSettings(self):
 """
 Private slot to show the changes made to the settings.py file.
 """
 title = self.tr("Diff Settings")
 from .DjangoDiffsettingsDataDialog import DjangoDiffsettingsDataDialog
 dlg = DjangoDiffsettingsDataDialog(self, self.__ui)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 showAll, defaultModule, outputFormat = dlg.getData()
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("diffsettings")
 if showAll:
 args.append("--all")
 if defaultModule:
 args.append("--default={0}".format(defaultModule))
 if outputFormat:
 args.append("--output={0}".format(outputFormat))
 try:
 path = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 dia = DjangoDialog(title, fixed=True, linewrap=False)
 res = dia.startProcess(args, path, False)
 if res:
 dia.exec()
 def __runPythonShell(self):
 """
 Private slot to start a Python console for a Django project.
 """
 consoleCmd = self.__isSpawningConsole(
-self.__plugin.getPreferences("ConsoleCommand"))[1]
+self.__plugin.getPreferences("ConsoleCommand")
+)[1]
 if consoleCmd:
 args = Utilities.parseOptionString(consoleCmd)
 args[0] = Utilities.getExecutablePath(args[0])
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("shell")
-args.append("--interface={0}".format(
+args.append(
-self.__plugin.getPreferences("Python3ConsoleType")))
+"--interface={0}".format(
-with contextlib.suppress(DjangoNoSiteSelectedException):
+self.__plugin.getPreferences("Python3ConsoleType")
+)
+)
+with contextlib.suppress(DjangoNoSiteSelectedError):
 wd = self.__sitePath()
 self.__adjustWorkingDirectory(args, wd)
 started, pid = QProcess.startDetached(args[0], args[1:], wd)
 if not started:
 EricMessageBox.critical(
 None,
-self.tr('Process Generation Error'),
+self.tr("Process Generation Error"),
-self.tr('The Django process could not be started.'))
+self.tr("The Django process could not be started."),
+)
 def __sendTestEmail(self):
 """
 Private slot to send a test email through Django.
 """
 title = self.tr("Send Test Email")
-from .DjangoSendTestEmailDataDialog import (
+from .DjangoSendTestEmailDataDialog import DjangoSendTestEmailDataDialog
-DjangoSendTestEmailDataDialog
-)
 dlg = DjangoSendTestEmailDataDialog(self.__ui)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 managers, admins, recipients = dlg.getData()
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("sendtestemail")
 if managers:
 args.append("--managers")
 if admins:
 args.append("--admins")
 args.extend(recipients)
 try:
 path = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 dia = DjangoDialog(
 title,
 linewrap=False,
 msgSuccess=self.tr("Test Email sent successfully."),
-msgError=self.tr("Test Email could not be sent.")
+msgError=self.tr("Test Email could not be sent."),
 )
 res = dia.startProcess(args, path, False)
 if res:
 dia.exec()
 ##################################################################
 ## slots below implement caching functions
 ##################################################################
 def __createCacheTables(self):
 """
 Private slot to create the tables for the SQL caching backend.
 """
 title = self.tr("Create Cache Tables")
 try:
 wd = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("createcachetable")
 if self.__currentDatabase:
 args.append("--database={0}".format(self.__currentDatabase))
 dia = DjangoDialog(
-title,
+title, msgSuccess=self.tr("Cache tables created successfully.")
-msgSuccess=self.tr("Cache tables created successfully."))
+)
 res = dia.startProcess(args, wd)
 if res:
 dia.exec()
 ##################################################################
 ## slots below implement testing functions
 ##################################################################
 def __dumpData(self):
 """
 Private slot to dump the database data to a fixture.
 """
 title = self.tr("Dump Data")
 try:
 wd = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 from .DjangoDumpdataDataDialog import DjangoDumpdataDataDialog
 dlg = DjangoDumpdataDataDialog(self, self.__ui)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 appls, excls, dumpFormat, indent = dlg.getData()
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("dumpdata")
 args.append("--format={0}".format(dumpFormat))
 for excl in excls:
 args.append("--exclude={0}".format(excl))
 if self.__currentDatabase:
 args.append("--database={0}".format(self.__currentDatabase))
 args += appls
 if dumpFormat == "json":
 fileFilters = self.tr("JSON Files (*.json)")
 elif dumpFormat == "xml":
 fileFilters = self.tr("XML Files (*.xml)")
 elif dumpFormat == "yaml":
 fileFilters = self.tr("YAML Files (*.yaml)")
 dia = DjangoDialog(
-title, fixed=True, linewrap=False, saveFilters=fileFilters)
+title, fixed=True, linewrap=False, saveFilters=fileFilters
+)
 res = dia.startProcess(args, wd, showCommand=False)
 if res:
 dia.exec()
 def __loadData(self):
 """
 Private slot to load data from fixture files.
 """
 title = self.tr("Load Data")
 try:
 wd = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 from .DjangoLoaddataDataDialog import DjangoLoaddataDataDialog
 dlg = DjangoLoaddataDataDialog(self, self.__ui)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 fixtures, excludes, appLabel, ignore = dlg.getData()
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("loaddata")
 for excl in excludes:
 if appLabel:
 args.append("--app={0}".format(appLabel))
 if self.__currentDatabase:
 args.append("--database={0}".format(self.__currentDatabase))
 args += fixtures
 dia = DjangoDialog(title)
 res = dia.startProcess(args, wd)
 if res:
 dia.exec()
 def __runTestSuite(self, deprecation=False):
 """
 Private slot to run the test suite for applications or the whole site.
 @param deprecation flag indicating to test for deprecation warnings
 @type bool
 """
 consoleCmd = self.__isSpawningConsole(
-self.__plugin.getPreferences("ConsoleCommandNoClose"))[1]
+self.__plugin.getPreferences("ConsoleCommandNoClose")
+)[1]
 if consoleCmd:
 try:
 wd = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 from .DjangoTestDataDialog import DjangoTestDataDialog
 dlg = DjangoTestDataDialog(
-self, self.__plugin.getPreferences("KeepTestDatabase"),
+self, self.__plugin.getPreferences("KeepTestDatabase"), self.__ui
-self.__ui)
+)
 if dlg.exec() == QDialog.DialogCode.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])
 args.append(self.__getPythonExecutable())
 if deprecation:
 args.append("-Wall")
 if keep:
 args.append("--keepdb")
 if reverse:
 args.append("--reverse")
 args.extend(labels)
 self.__adjustWorkingDirectory(args, wd)
 started, pid = QProcess.startDetached(args[0], args[1:], wd)
 if not started:
 EricMessageBox.critical(
 None,
-self.tr('Process Generation Error'),
+self.tr("Process Generation Error"),
-self.tr('The Django process could not be started.'))
+self.tr("The Django process could not be started."),
+)
 def __runTestServer(self):
 """
 Private slot to run a development server with data from a set of
 fixtures.
 """
 consoleCmd = self.__isSpawningConsole(
-self.__plugin.getPreferences("ConsoleCommand"))[1]
+self.__plugin.getPreferences("ConsoleCommand")
+)[1]
 if consoleCmd:
-from .DjangoRunTestServerDataDialog import (
+from .DjangoRunTestServerDataDialog import DjangoRunTestServerDataDialog
-DjangoRunTestServerDataDialog
-)
 dlg = DjangoRunTestServerDataDialog(self, self.__ui)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 fixtures = dlg.getData()
 args = Utilities.parseOptionString(consoleCmd)
 args[0] = Utilities.getExecutablePath(args[0])
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("testserver")
 args.append("--ipv6")
 addr = self.__plugin.getPreferences("ServerAddress")
 if addr:
 args.append("--addrport={0}".format(addr))
 args += fixtures
-with contextlib.suppress(DjangoNoSiteSelectedException):
+with contextlib.suppress(DjangoNoSiteSelectedError):
 if Utilities.isWindowsPlatform():
 serverProcStarted, pid = QProcess.startDetached(
-args[0], args[1:], self.__sitePath())
+args[0], args[1:], self.__sitePath()
+)
 else:
 if self.__testServerProc is not None:
 self.__testServerProcFinished()
 self.__testServerProc = QProcess()
 self.__testServerProc.finished.connect(
-self.__serverProcFinished)
+self.__serverProcFinished
-self.__testServerProc.setWorkingDirectory(
+)
-self.__sitePath())
+self.__testServerProc.setWorkingDirectory(self.__sitePath())
 self.__testServerProc.start(args[0], args[1:])
-serverProcStarted = (
+serverProcStarted = self.__testServerProc.waitForStarted()
-self.__testServerProc.waitForStarted())
 if not serverProcStarted:
 EricMessageBox.critical(
 None,
-self.tr('Process Generation Error'),
+self.tr("Process Generation Error"),
-self.tr('The Django test server could not be'
+self.tr("The Django test server could not be" " started."),
-' started.'))
+)
 def __testServerProcFinished(self):
 """
 Private slot connected to the finished signal of the test server.
 """
 if (
-self.__testServerProc is not None and
+self.__testServerProc is not None
-self.__testServerProc.state() != QProcess.ProcessState.NotRunning
+and self.__testServerProc.state() != QProcess.ProcessState.NotRunning
 ):
 self.__testServerProc.terminate()
 QTimer.singleShot(2000, self.__testServerProc.kill)
 self.__testServerProc.waitForFinished(3000)
 self.__testServerProc = None
 ##################################################################
 ## slots below implement authorization functions
 ##################################################################
 def __changePassword(self):
 """
 Private slot to change the password of a user.
 """
 consoleCmd = self.__isSpawningConsole(
-self.__plugin.getPreferences("ConsoleCommandNoClose"))[1]
+self.__plugin.getPreferences("ConsoleCommandNoClose")
+)[1]
 if consoleCmd:
 userName, ok = QInputDialog.getText(
 self.__ui,
 self.tr("Change Password"),
 self.tr("Enter the name of the user:"),
-QLineEdit.EchoMode.Normal)
+QLineEdit.EchoMode.Normal,
+)
 if ok and userName != "":
 args = Utilities.parseOptionString(consoleCmd)
 args[0] = Utilities.getExecutablePath(args[0])
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("changepassword")
 args.append(userName)
-with contextlib.suppress(DjangoNoSiteSelectedException):
+with contextlib.suppress(DjangoNoSiteSelectedError):
 wd = self.__sitePath()
 self.__adjustWorkingDirectory(args, wd)
-started, pid = QProcess.startDetached(
+started, pid = QProcess.startDetached(args[0], args[1:], wd)
-args[0], args[1:], wd)
 if not started:
 EricMessageBox.critical(
 None,
-self.tr('Process Generation Error'),
+self.tr("Process Generation Error"),
-self.tr('The Django process could not be'
+self.tr("The Django process could not be" " started."),
-' started.'))
+)
 def __createSuperUser(self):
 """
 Private slot to create a super user account.
 """
 consoleCmd = self.__isSpawningConsole(
-self.__plugin.getPreferences("ConsoleCommandNoClose"))[1]
+self.__plugin.getPreferences("ConsoleCommandNoClose")
+)[1]
 if consoleCmd:
 args = Utilities.parseOptionString(consoleCmd)
 args[0] = Utilities.getExecutablePath(args[0])
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("createsuperuser")
-with contextlib.suppress(DjangoNoSiteSelectedException):
+with contextlib.suppress(DjangoNoSiteSelectedError):
 wd = self.__sitePath()
 self.__adjustWorkingDirectory(args, wd)
 started, pid = QProcess.startDetached(args[0], args[1:], wd)
 if not started:
 EricMessageBox.critical(
 None,
-self.tr('Process Generation Error'),
+self.tr("Process Generation Error"),
-self.tr('The Django process could not be started.'))
+self.tr("The Django process could not be started."),
+)
 ##################################################################
 ## slots below implement session functions
 ##################################################################
 def __clearSessions(self):
 """
 Private slot to clear expired sessions.
 """
 title = self.tr("Clear Sessions")
 try:
 wd = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("clearsessions")
 dia = DjangoDialog(
-title,
+title, msgSuccess=self.tr("Expired sessions cleared successfully.")
-msgSuccess=self.tr("Expired sessions cleared successfully."))
+)
 res = dia.startProcess(args, wd)
 if res:
 dia.exec()
 ##################################################################
 ## slots below implement translation functions
 ##################################################################
 def __getLocale(self, filename):
 """
 Private method to extract the locale out of a file name.
 @param filename name of the file used for extraction
 @type str
 @return extracted locale or None
 @rtype str
 """
 if self.__ericProject.getTranslationPattern():
-pattern = (
+pattern = self.__ericProject.getTranslationPattern().replace(
-self.__ericProject.getTranslationPattern()
+"%language%", "(.*?)"
-.replace("%language%", "(.*?)")
 )
 match = re.search(pattern, filename)
 if match is not None:
 loc = match.group(1)
 return loc
 else:
 loc = None
 else:
 loc = None
 return loc
 def __normalizeList(self, filenames):
 """
 Private method to normalize a list of file names.
 @param filenames list of file names to normalize
 @type list of str
 @return normalized file names
 @rtype list of str
 """
 for filename in filenames:
 if filename.endswith(".mo"):
 filename = filename.replace(".mo", ".po")
 if filename not in nfilenames:
 nfilenames.append(filename)
 return nfilenames
 def __siteFilteredList(self, filenames):
 """
 Private method to filter a list of file names by site.
 @param filenames list of file names to be filtered
 @type list of str
 @return file names belonging to the current site
 @rtype list of str
 """
 site = self.__site()
 nfilenames = []
 for filename in filenames:
 if site == "" or filename.startswith(site + os.sep):
 nfilenames.append(filename)
 return nfilenames
 def __projectLanguageAdded(self, code):
 """
 Private slot handling the addition of a new language.
 @param code language code of the new language
 @type str
 """
-title = (
+title = self.tr("Initializing message catalog for '{0}'").format(code)
-self.tr("Initializing message catalog for '{0}'")
-.format(code)
-)
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("makemessages")
 args.append("--locale={0}".format(code))
 try:
 wd = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 EricMessageBox.warning(
 None,
 title,
-self.tr('No current site selected or no site created yet.'
+self.tr(
-' Aborting...'))
+"No current site selected or no site created yet." " Aborting..."
+),
+)
 return
 dia = DjangoDialog(
-title,
+title, msgSuccess=self.tr("\nMessage catalog initialized successfully.")
-msgSuccess=self.tr(
+)
-"\nMessage catalog initialized successfully."))
 res = dia.startProcess(args, wd)
 if res:
 dia.exec()
-langFile = (
+langFile = self.__ericProject.getTranslationPattern().replace(
-self.__ericProject.getTranslationPattern()
+"%language%", code
-.replace("%language%", code)
 )
 self.__ericProject.appendFile(langFile)
 def updateSelectedCatalogs(self, filenames):
 """
 Public method to update the message catalogs.
 @param filenames list of file names
 @type list of str
 """
 title = self.tr("Updating message catalogs")
 try:
 wd = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 EricMessageBox.warning(
 None,
 title,
-self.tr('No current site selected or no site created yet.'
+self.tr(
-' Aborting...'))
+"No current site selected or no site created yet." " Aborting..."
+),
+)
 return
 argsLists = []
-for filename in self.__normalizeList(
+for filename in self.__normalizeList(self.__siteFilteredList(filenames)):
-self.__siteFilteredList(filenames)):
 locale = self.__getLocale(filename)
 if locale:
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("makemessages")
 args.append("--no-obsolete")
 args.append("--locale={0}".format(locale))
 argsLists.append(args)
 if len(argsLists) == 0:
+EricMessageBox.warning(
+None, title, self.tr("No locales detected. Aborting...")
+)
+return
+dia = DjangoDialog(
+title, msgSuccess=self.tr("\nMessage catalogs updated successfully.")
+)
+res = dia.startBatchProcesses(argsLists, wd)
+if res:
+dia.exec()
+def updateSelectedCatalogsWithObsolete(self, filenames):
+"""
+Public method to update the message catalogs keeping obsolete messages.
+@param filenames list of filenames
+@type list of str
+"""
+title = self.tr("Updating message catalogs (keeping obsolete" " messages)")
+try:
+wd = self.__sitePath()
+except DjangoNoSiteSelectedError:
 EricMessageBox.warning(
 None,
 title,
-self.tr('No locales detected. Aborting...'))
+self.tr(
+"No current site selected or no site created yet." " Aborting..."
+),
+)
 return
-dia = DjangoDialog(
-title,
-msgSuccess=self.tr("\nMessage catalogs updated successfully."))
-res = dia.startBatchProcesses(argsLists, wd)
-if res:
-dia.exec()
-def updateSelectedCatalogsWithObsolete(self, filenames):
-"""
-Public method to update the message catalogs keeping obsolete messages.
-@param filenames list of filenames
-@type list of str
-"""
-title = self.tr("Updating message catalogs (keeping obsolete"
-" messages)")
-try:
-wd = self.__sitePath()
-except DjangoNoSiteSelectedException:
-EricMessageBox.warning(
-None,
-title,
-self.tr('No current site selected or no site created yet.'
-' Aborting...'))
-return
 argsLists = []
-for filename in self.__normalizeList(
+for filename in self.__normalizeList(self.__siteFilteredList(filenames)):
-self.__siteFilteredList(filenames)):
 locale = self.__getLocale(filename)
 if locale:
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("makemessages")
 args.append("--locale={0}".format(locale))
 argsLists.append(args)
 if len(argsLists) == 0:
 EricMessageBox.warning(
-None,
+None, title, self.tr("No locales detected. Aborting...")
-title,
+)
-self.tr('No locales detected. Aborting...'))
 return
 dia = DjangoDialog(
-title,
+title, msgSuccess=self.tr("\nMessage catalogs updated successfully.")
-msgSuccess=self.tr("\nMessage catalogs updated successfully."))
+)
 res = dia.startBatchProcesses(argsLists, wd)
 if res:
 dia.exec()
 def updateCatalogs(self, filenames):
 """
 Public method to update the message catalogs.
 @param filenames list of filenames (not used)
 @type list of str
 """
 title = self.tr("Updating message catalogs")
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("makemessages")
 args.append("--all")
 args.append("--no-obsolete")
 try:
 wd = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 EricMessageBox.warning(
 None,
 title,
-self.tr('No current site selected or no site created yet.'
+self.tr(
-' Aborting...'))
+"No current site selected or no site created yet." " Aborting..."
+),
+)
 return
 dia = DjangoDialog(
-title,
+title, msgSuccess=self.tr("\nMessage catalogs updated successfully.")
-msgSuccess=self.tr("\nMessage catalogs updated successfully."))
+)
 res = dia.startProcess(args, wd)
 if res:
 dia.exec()
 def updateCatalogsWithObsolete(self, filenames):
 """
 Public method to update the message catalogs keeping obsolete messages.
 @param filenames list of filenames (not used)
 @type list of str
 """
-title = self.tr("Updating message catalogs (keeping obsolete"
+title = self.tr("Updating message catalogs (keeping obsolete" " messages)")
-" messages)")
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("makemessages")
 args.append("--all")
 try:
 wd = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 EricMessageBox.warning(
 None,
 title,
-self.tr('No current site selected or no site created yet.'
+self.tr(
-' Aborting...'))
+"No current site selected or no site created yet." " Aborting..."
+),
+)
 return
 dia = DjangoDialog(
-title,
+title, msgSuccess=self.tr("\nMessage catalogs updated successfully.")
-msgSuccess=self.tr("\nMessage catalogs updated successfully."))
+)
 res = dia.startProcess(args, wd)
 if res:
 dia.exec()
 def compileSelectedCatalogs(self, filenames):
 """
 Public method to update the message catalogs.
 @param filenames list of filenames
 @type list of str
 """
 title = self.tr("Compiling message catalogs")
 try:
 wd = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 EricMessageBox.warning(
 None,
 title,
-self.tr('No current site selected or no site created yet.'
+self.tr(
-' Aborting...'))
+"No current site selected or no site created yet." " Aborting..."
+),
+)
 return
 argsLists = []
-for filename in self.__normalizeList(
+for filename in self.__normalizeList(self.__siteFilteredList(filenames)):
-self.__siteFilteredList(filenames)):
 locale = self.__getLocale(filename)
 if locale:
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("compilemessages")
 args.append("--locale={0}".format(locale))
 if self.__plugin.getPreferences("FuzzyTranslations"):
 args.append("--use-fuzzy")
 argsLists.append(args)
 if len(argsLists) == 0:
 EricMessageBox.warning(
-None,
+None, title, self.tr("No locales detected. Aborting...")
-title,
+)
-self.tr('No locales detected. Aborting...'))
 return
 dia = DjangoDialog(
-title,
+title, msgSuccess=self.tr("\nMessage catalogs compiled successfully.")
-msgSuccess=self.tr(
+)
-"\nMessage catalogs compiled successfully."))
 res = dia.startBatchProcesses(argsLists, wd, mergedOutput=True)
 if res:
 dia.exec()
 for entry in os.walk(self.__sitePath()):
 for fileName in entry[2]:
 fullName = os.path.join(entry[0], fileName)
-if fullName.endswith('.mo'):
+if fullName.endswith(".mo"):
 self.__ericProject.appendFile(fullName)
 def compileCatalogs(self, filenames):
 """
 Public method to compile the message catalogs.
 @param filenames list of filenames (not used)
 @type list of str
 """
 title = self.tr("Compiling message catalogs")
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("compilemessages")
 if self.__plugin.getPreferences("FuzzyTranslations"):
 args.append("--use-fuzzy")
 try:
 wd = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 EricMessageBox.warning(
 None,
 title,
-self.tr('No current site selected or no site created yet.'
+self.tr(
-' Aborting...'))
+"No current site selected or no site created yet." " Aborting..."
+),
+)
 return
 dia = DjangoDialog(
-title,
+title, msgSuccess=self.tr("\nMessage catalogs compiled successfully.")
-msgSuccess=self.tr(
+)
-"\nMessage catalogs compiled successfully."))
 res = dia.startProcess(args, wd, mergedOutput=True)
 if res:
 dia.exec()
 for entry in os.walk(self.__sitePath()):
 for fileName in entry[2]:
 fullName = os.path.join(entry[0], fileName)
-if fullName.endswith('.mo'):
+if fullName.endswith(".mo"):
 self.__ericProject.appendFile(fullName)
 def openPOEditor(self, poFile):
 """
 Public method to edit the given file in an external .po editor.
 @param poFile name of the .po file
 @type str
 """
 editor = self.__plugin.getPreferences("TranslationsEditor")
 if poFile.endswith(".po") and editor:
 try:
 wd = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 wd = ""
 started, pid = QProcess.startDetached(editor, [poFile], wd)
 if not started:
 EricMessageBox.critical(
 None,
-self.tr('Process Generation Error'),
+self.tr("Process Generation Error"),
-self.tr('The translations editor process ({0}) could'
+self.tr(
-' not be started.')
+"The translations editor process ({0}) could" " not be started."
-.format(os.path.basename(editor)))
+).format(os.path.basename(editor)),
+)
 ##################################################################
 ## slots below implement check functions
 ##################################################################
 def __performCheck(self):
 """
 Private slot to inspect the project for common problems.
 """
 try:
 path = self.__sitePath()
-except DjangoNoSiteSelectedException:
+except DjangoNoSiteSelectedError:
 return
 from .DjangoCheckOptionsDialog import DjangoCheckOptionsDialog
 dlg = DjangoCheckOptionsDialog(
-self.__getPythonExecutable(), path, self.getRecentApplications(),
+self.__getPythonExecutable(),
+path,
+self.getRecentApplications(),
 self.__plugin.getPreferences("CheckDeployMode"),
 )
 if dlg.exec() == QDialog.DialogCode.Accepted:
 deploy, tags, appsStr, settingsFile = dlg.getData()
 self.__plugin.setPreferences("CheckDeployMode", deploy)
 if appsStr != "":
 self.setMostRecentApplication(appsStr)
 apps = appsStr.split()
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 args.append("check")
 for tag in tags:
 if deploy:
 args.append("--deploy")
 if settingsFile:
 args.append("--settings={0}".format(settingsFile))
 args += apps
 dia = DjangoDialog(self.tr("Check Project"))
 res = dia.startProcess(args, path, mergedOutput=True)
 if res:
 dia.exec()

Mercurial Repositories > Django Project / file comparison

comparison: ProjectDjango/Project.py

ProjectDjango/Project.py