Django Project: comparison ProjectDjango/Project.py

-:af99f0984f20
+:ea7980ded4f3
 import os
 import re
 import shutil
 import contextlib
-from PyQt5.QtCore import QObject, QTimer, QUrl, QFileInfo
+from PyQt6.QtCore import QObject, QTimer, QUrl, QFileInfo, QIODeviceBase
-from PyQt5.QtGui import QDesktopServices
+from PyQt6.QtGui import QDesktopServices
-from PyQt5.QtWidgets import QMenu, QInputDialog, QLineEdit, QDialog
+from PyQt6.QtWidgets import QMenu, QInputDialog, QLineEdit, QDialog
-from PyQt5.QtCore import QProcess as QProcessPyQt
+from PyQt6.QtCore import QProcess as QProcessPyQt
-from E5Gui.E5Application import e5App
+from EricWidgets.EricApplication import ericApp
-from E5Gui import E5MessageBox, E5FileDialog
+from EricWidgets import EricMessageBox, EricFileDialog
-from E5Gui.E5Action import E5Action
+from EricGui.EricAction import EricAction
 from Globals import isWindowsPlatform
 from .DjangoDialog import DjangoDialog
 class QProcess(QProcessPyQt):
 """
 Class transforming the call arguments in case of gnome-terminal.
 """
-def start(self, cmd, args=None, mode=QProcessPyQt.ReadWrite):
+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 (string)
+@param cmd start the given program cmd
-@keyparam args list of parameters (list of strings)
+@type str
-@keyparam mode access mode (QIODevice.OpenMode)
+@param args list of parameters
+@type list of str
+@param mode access mode
+@type QIODeviceBase.OpenMode
 """
 if args is None:
 args = []
 if (
 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 (string)
+@param cmd start the given program cmd
-@keyparam args list of parameters (list of strings)
+@type str
-@keyparam path new working directory (string)
+@param args list of parameters
-@return tuple of successful start and process id (boolean, integer)
+@type list of str
+@param path new working directory
+@type str
+@return tuple of successful start and process id
+@rtype tuple of (bool, int)
 """
 if args is None:
 args = []
 if (
 self.__plugin = plugin
 self.__iconSuffix = iconSuffix
 self.__ui = parent
-self.__e5project = e5App().getObject("Project")
+self.__ericProject = ericApp().getObject("Project")
-self.__virtualEnvManager = e5App().getObject("VirtualEnvManager")
+self.__virtualEnvManager = ericApp().getObject("VirtualEnvManager")
 self.__hooksInstalled = False
 self.__menus = {}   # dictionary with references to menus
 self.__serverProc = None
 """
 Public method to define the Django actions.
 """
 self.actions = []
-self.selectSiteAct = E5Action(
+self.selectSiteAct = EricAction(
 self.tr('Current Project'),
 "",
 0, 0,
 self, 'django_current_project')
 self.selectSiteAct.setStatusTip(self.tr(
 ##############################
 ## start actions below      ##
 ##############################
-self.startProjectAct = E5Action(
+self.startProjectAct = EricAction(
 self.tr('Start Project'),
 self.tr('Start &Project'),
 0, 0,
 self, 'django_start_project')
 self.startProjectAct.setStatusTip(self.tr(
 """ startproject".</p>"""
 ))
 self.startProjectAct.triggered.connect(self.__startProject)
 self.actions.append(self.startProjectAct)
-self.startGlobalApplicationAct = E5Action(
+self.startGlobalApplicationAct = EricAction(
 self.tr('Start Application (global)'),
 self.tr('Start Application (&global)'),
 0, 0,
 self, 'django_start_global_application')
 self.startGlobalApplicationAct.setStatusTip(self.tr(
 ))
 self.startGlobalApplicationAct.triggered.connect(
 self.__startGlobalApplication)
 self.actions.append(self.startGlobalApplicationAct)
-self.startLocalApplicationAct = E5Action(
+self.startLocalApplicationAct = EricAction(
 self.tr('Start Application (local)'),
 self.tr('Start Application (&local)'),
 0, 0,
 self, 'django_start_local_application')
 self.startLocalApplicationAct.setStatusTip(self.tr(
 ##############################
 ## run actions below        ##
 ##############################
-self.runServerAct = E5Action(
+self.runServerAct = EricAction(
 self.tr('Run Server'),
 self.tr('Run &Server'),
 0, 0,
 self, 'django_run_server')
 self.runServerAct.setStatusTip(self.tr(
 """ runserver".</p>"""
 ))
 self.runServerAct.triggered.connect(self.__runServer)
 self.actions.append(self.runServerAct)
-self.runBrowserAct = E5Action(
+self.runBrowserAct = EricAction(
 self.tr('Run Web-Browser'),
 self.tr('Run &Web-Browser'),
 0, 0,
 self, 'django_run_browser')
 self.runBrowserAct.setStatusTip(self.tr(
 ##############################
 ## caching actions below    ##
 ##############################
-self.createCacheTableAct = E5Action(
+self.createCacheTableAct = EricAction(
 self.tr('Create Cache Tables'),
 self.tr('C&reate Cache Tables'),
 0, 0,
 self, 'django_create_cache_tables')
 self.createCacheTableAct.setStatusTip(self.tr(
 ##############################
 ## help action below        ##
 ##############################
-self.helpAct = E5Action(
+self.helpAct = EricAction(
 self.tr('Help'),
 self.tr('&Help'),
 0, 0,
 self, 'django_help')
 self.helpAct.setStatusTip(self.tr(
 ##############################
 ## about action below       ##
 ##############################
-self.aboutDjangoAct = E5Action(
+self.aboutDjangoAct = EricAction(
 self.tr('About Django'),
 self.tr('About D&jango'),
 0, 0,
 self, 'django_about')
 self.aboutDjangoAct.setStatusTip(self.tr(
 ##############################
 ## check action below       ##
 ##############################
-self.checkAct = E5Action(
+self.checkAct = EricAction(
 self.tr('Check Project'),
 self.tr('Check Project'),
 0, 0,
 self, 'django_check_project')
 self.checkAct.setStatusTip(self.tr(
 def __initDatabaseActions(self):
 """
 Private method to define the database related actions.
 """
-self.selectDatabaseNameAct = E5Action(
+self.selectDatabaseNameAct = EricAction(
 self.tr('Current Database'),
 "",
 0, 0,
 self, 'django_current_database')
 self.selectDatabaseNameAct.setStatusTip(self.tr(
 ))
 self.selectDatabaseNameAct.triggered.connect(self.__selectDatabaseName)
 self.actions.append(self.selectDatabaseNameAct)
 self.__setCurrentDatabase(None)
-self.inspectDatabaseAct = E5Action(
+self.inspectDatabaseAct = EricAction(
 self.tr('Introspect'),
 self.tr('&Introspect'),
 0, 0,
 self, 'django_database_inspect')
 self.inspectDatabaseAct.setStatusTip(self.tr(
 """Django model module.</p>"""
 ))
 self.inspectDatabaseAct.triggered.connect(self.__databaseInspect)
 self.actions.append(self.inspectDatabaseAct)
-self.flushDatabaseAct = E5Action(
+self.flushDatabaseAct = EricAction(
 self.tr('Flush'),
 self.tr('&Flush'),
 0, 0,
 self, 'django_database_flush')
 self.flushDatabaseAct.setStatusTip(self.tr(
 """just after their installation.</p>"""
 ))
 self.flushDatabaseAct.triggered.connect(self.__databaseFlush)
 self.actions.append(self.flushDatabaseAct)
-self.databaseClientAct = E5Action(
+self.databaseClientAct = EricAction(
 self.tr('Start Client Console'),
 self.tr('Start &Client Console'),
 0, 0,
 self, 'django_database_client')
 self.databaseClientAct.setStatusTip(self.tr(
 def __initDatabaseSqlActions(self):
 """
 Private method to define the database SQL related actions.
 """
-self.databaseSqlFlushAct = E5Action(
+self.databaseSqlFlushAct = EricAction(
 self.tr('Flush Database'),
 self.tr('&Flush Database'),
 0, 0,
 self, 'django_database_sql_flush_database')
 self.databaseSqlFlushAct.setStatusTip(self.tr(
 ))
 self.databaseSqlFlushAct.triggered.connect(
 self.__databaseSqlFlushDatabase)
 self.actions.append(self.databaseSqlFlushAct)
-self.databaseSqlResetSeqAct = E5Action(
+self.databaseSqlResetSeqAct = EricAction(
 self.tr('Reset Sequences'),
 self.tr('Reset &Sequences'),
 0, 0,
 self, 'django_database_sql_reset_sequences')
 self.databaseSqlResetSeqAct.setStatusTip(self.tr(
 ))
 self.databaseSqlResetSeqAct.triggered.connect(
 self.__databaseSqlResetSequences)
 self.actions.append(self.databaseSqlResetSeqAct)
-self.databaseSqlMigrateAct = E5Action(
+self.databaseSqlMigrateAct = EricAction(
 self.tr('Apply Migration'),
 self.tr('&Apply Migration'),
 0, 0,
 self, 'django_database_sql_apply_migration')
 self.databaseSqlMigrateAct.setStatusTip(self.tr(
 ))
 self.databaseSqlMigrateAct.triggered.connect(
 self.__databaseSqlMigrate)
 self.actions.append(self.databaseSqlMigrateAct)
-self.databaseSqlMigrateBackwardsAct = E5Action(
+self.databaseSqlMigrateBackwardsAct = EricAction(
 self.tr('Unapply Migration'),
 self.tr('&Unapply Migration'),
 0, 0,
 self, 'django_database_sql_unapply_migration')
 self.databaseSqlMigrateBackwardsAct.setStatusTip(self.tr(
 def __initToolsActions(self):
 """
 Private method to define the tool actions.
 """
-self.diffSettingsAct = E5Action(
+self.diffSettingsAct = EricAction(
 self.tr('Diff Settings'),
 self.tr('&Diff Settings'),
 0, 0,
 self, 'django_tools_diffsettings')
 self.diffSettingsAct.setStatusTip(self.tr(
 """<p>Shows the modification made to the settings.</p>"""
 ))
 self.diffSettingsAct.triggered.connect(self.__diffSettings)
 self.actions.append(self.diffSettingsAct)
-self.runPythonShellAct = E5Action(
+self.runPythonShellAct = EricAction(
 self.tr('Start Python Console'),
 self.tr('Start &Python Console'),
 0, 0,
 self, 'django_tools_pythonconsole')
 self.runPythonShellAct.setStatusTip(self.tr(
 """<p>Starts a Python interactive interpreter.</p>"""
 ))
 self.runPythonShellAct.triggered.connect(self.__runPythonShell)
 self.actions.append(self.runPythonShellAct)
-self.testEmailAct = E5Action(
+self.testEmailAct = EricAction(
 self.tr('Send Test Email'),
 self.tr('Send Test &Email'),
 0, 0,
 self, 'django_tools_sendtestemail')
 self.testEmailAct.setStatusTip(self.tr(
 def __initTestingActions(self):
 """
 Private method to define the testing actions.
 """
-self.dumpDataAct = E5Action(
+self.dumpDataAct = EricAction(
 self.tr('Dump Data'),
 self.tr('&Dump Data'),
 0, 0,
 self, 'django_tools_dumpdata')
 self.dumpDataAct.setStatusTip(self.tr(
 """<p>Dump the database data to a fixture.</p>"""
 ))
 self.dumpDataAct.triggered.connect(self.__dumpData)
 self.actions.append(self.dumpDataAct)
-self.loadDataAct = E5Action(
+self.loadDataAct = EricAction(
 self.tr('Load Data'),
 self.tr('&Load Data'),
 0, 0,
 self, 'django_tools_loaddata')
 self.loadDataAct.setStatusTip(self.tr(
 """<p>Load data from fixture files.</p>"""
 ))
 self.loadDataAct.triggered.connect(self.__loadData)
 self.actions.append(self.loadDataAct)
-self.runTestAct = E5Action(
+self.runTestAct = EricAction(
 self.tr('Run Testsuite'),
 self.tr('Run &Testsuite'),
 0, 0,
 self, 'django_tools_run_test')
 self.runTestAct.setStatusTip(self.tr(
 """<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 = E5Action(
+self.runDeprecationTestAct = EricAction(
 self.tr('Run Testsuite (-Wall)'),
 self.tr('Run Testsuite (-Wall)'),
 0, 0,
 self, 'django_tools_run_deprecation_test')
 self.runDeprecationTestAct.setStatusTip(self.tr(
 ))
 self.runDeprecationTestAct.triggered.connect(
 lambda: self.__runTestSuite(deprecation=True))
 self.actions.append(self.runDeprecationTestAct)
-self.runTestServerAct = E5Action(
+self.runTestServerAct = EricAction(
 self.tr('Run Testserver'),
 self.tr('Run Test&server'),
 0, 0,
 self, 'django_tools_run_test_server')
 self.runTestServerAct.setStatusTip(self.tr(
 def __initAuthorizationActions(self):
 """
 Private method to define the authorization actions.
 """
-self.changePasswordAct = E5Action(
+self.changePasswordAct = EricAction(
 self.tr('Change Password'),
 self.tr('Change &Password'),
 0, 0,
 self, 'django_auth_changepassword')
 self.changePasswordAct.setStatusTip(self.tr(
 """<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 = E5Action(
+self.createSuperUserAct = EricAction(
 self.tr('Create Superuser'),
 self.tr('Create &Superuser'),
 0, 0,
 self, 'django_auth_createsuperuser')
 self.createSuperUserAct.setStatusTip(self.tr(
 def __initSessionActions(self):
 """
 Private method to define the session actions.
 """
-self.clearSessionsAct = E5Action(
+self.clearSessionsAct = EricAction(
 self.tr('Clear Sessions'),
 self.tr('Clear &Sessions'),
 0, 0,
 self, 'django_session_clearsessions')
 self.clearSessionsAct.setStatusTip(self.tr(
 def __initMigrationActions(self):
 """
 Private method to define the migration actions.
 """
-self.showMigrationsAct = E5Action(
+self.showMigrationsAct = EricAction(
 self.tr('Show Migrations'),
 self.tr('&Show Migrations'),
 0, 0,
 self, 'django_migration_show')
 self.showMigrationsAct.setStatusTip(self.tr(
 """ project and their status.</p>"""
 ))
 self.showMigrationsAct.triggered.connect(self.__showMigrationsList)
 self.actions.append(self.showMigrationsAct)
-self.showMigrationsPlanAct = E5Action(
+self.showMigrationsPlanAct = EricAction(
 self.tr('Show Migrations Plan'),
 self.tr('Show Migrations &Plan'),
 0, 0,
 self, 'django_migration_show_plan')
 self.showMigrationsPlanAct.setStatusTip(self.tr(
 """ project.</p>"""
 ))
 self.showMigrationsPlanAct.triggered.connect(self.__showMigrationsPlan)
 self.actions.append(self.showMigrationsPlanAct)
-self.migrateAllAct = E5Action(
+self.migrateAllAct = EricAction(
 self.tr('Apply All Migrations'),
 self.tr('&Apply All Migrations'),
 0, 0,
 self, 'django_migration_apply_all')
 self.migrateAllAct.setStatusTip(self.tr(
 """<p>This applies all migrations of the Django project.</p>"""
 ))
 self.migrateAllAct.triggered.connect(self.__applyAllMigrations)
 self.actions.append(self.migrateAllAct)
-self.migrateSelectedAct = E5Action(
+self.migrateSelectedAct = EricAction(
 self.tr('Apply Selected Migrations'),
 self.tr('Apply Selected Migrations'),
 0, 0,
 self, 'django_migration_apply_selected')
 self.migrateSelectedAct.setStatusTip(self.tr(
 ))
 self.migrateSelectedAct.triggered.connect(
 self.__applySelectedMigrations)
 self.actions.append(self.migrateSelectedAct)
-self.unmigrateAct = E5Action(
+self.unmigrateAct = EricAction(
 self.tr('Unapply Migrations'),
 self.tr('&Unapply Migrations'),
 0, 0,
 self, 'django_migration_unapply')
 self.unmigrateAct.setStatusTip(self.tr(
 """ project.</p>"""
 ))
 self.unmigrateAct.triggered.connect(self.__unapplyMigrations)
 self.actions.append(self.unmigrateAct)
-self.makeMigrationsAct = E5Action(
+self.makeMigrationsAct = EricAction(
 self.tr('Make Migrations'),
 self.tr('&Make Migrations'),
 0, 0,
 self, 'django_migration_make')
 self.makeMigrationsAct.setStatusTip(self.tr(
 """<p>This generates migrations for the Django project.</p>"""
 ))
 self.makeMigrationsAct.triggered.connect(self.__makeMigrations)
 self.actions.append(self.makeMigrationsAct)
-self.squashMigrationsAct = E5Action(
+self.squashMigrationsAct = EricAction(
 self.tr('Squash Migrations'),
 self.tr('S&quash Migrations'),
 0, 0,
 self, 'django_migration_squash')
 self.squashMigrationsAct.setStatusTip(self.tr(
 def getMenu(self, name):
 """
 Public method to get a reference to the requested menu.
-@param name name of the menu (string)
+@param name name of the menu
-@return reference to the menu (QMenu) or None, if no
+@type str
-menu with the given name exists
+@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 (list of string)
+@return menu names
+@rtype list of str
 """
 return list(self.__menus.keys())
 ##################################################################
 ## methods below implement the various hook related functions
 def projectOpenedHooks(self):
 """
 Public method to add our hook methods.
 """
-if self.__e5project.getProjectType() == "Django":
+if self.__ericProject.getProjectType() == "Django":
 self.__formsBrowser = (
-e5App().getObject("ProjectBrowser").getProjectBrowser("forms")
+ericApp().getObject("ProjectBrowser")
+.getProjectBrowser("forms")
 )
 self.__formsBrowser.addHookMethodAndMenuEntry(
 "newForm",
 self.newForm, self.tr("New template..."))
-self.__e5project.projectLanguageAddedByCode.connect(
+self.__ericProject.projectLanguageAddedByCode.connect(
 self.__projectLanguageAdded)
 self.__translationsBrowser = (
-e5App().getObject("ProjectBrowser")
+ericApp().getObject("ProjectBrowser")
 .getProjectBrowser("translations"))
 self.__translationsBrowser.addHookMethodAndMenuEntry(
 "generateAll",
 self.updateCatalogs, self.tr("Update all catalogs"))
 self.__translationsBrowser.addHookMethodAndMenuEntry(
 """
 if self.__hooksInstalled:
 self.__formsBrowser.removeHookMethod("newForm")
 self.__formsBrowser = None
-self.__e5project.projectLanguageAddedByCode.disconnect(
+self.__ericProject.projectLanguageAddedByCode.disconnect(
 self.__projectLanguageAdded)
 self.__translationsBrowser.removeHookMethod(
 "generateAll")
 self.__translationsBrowser.removeHookMethod(
 "generateSelected")
 def newForm(self, path):
 """
 Public method to create a new form.
-@param path full directory path for the new form file (string)
+@param path full directory path for the new form file
-"""
+@type str
-fname, selectedFilter = E5FileDialog.getSaveFileNameAndFilter(
+"""
+fname, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
 self.__ui,
 self.tr("New Form"),
 path,
 filter,
 None,
-E5FileDialog.Options(E5FileDialog.DontConfirmOverwrite))
+EricFileDialog.DontConfirmOverwrite)
 if not fname:
 # user aborted or didn't enter a filename
 return
 ex = selectedFilter.split("(*")[1].split(")")[0]
 if ex:
 fname += ex
 if os.path.exists(fname):
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.__ui,
 self.tr("New Form"),
 self.tr("The file already exists! Overwrite it?"),
-icon=E5MessageBox.Warning)
+icon=EricMessageBox.Warning)
 if not res:
 # user selected to not overwrite
 return
 f.write('    </div>')
 f.write('  </body>\n')
 f.close()
 f.write('</html>\n')
 except OSError as e:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.__ui,
 self.tr("New Form"),
 self.tr("<p>The new form file <b>{0}</b> could not be"
 " created.<br> Problem: {1}</p>")
 .format(fname, str(e)))
 return
-self.__e5project.appendFile(fname)
+self.__ericProject.appendFile(fname)
 self.__formsBrowser.sourceFile.emit(fname)
 ##################################################################
 ## slots below implement general functionality
 ##################################################################
 def __getExecutablePaths(self, file):
 """
 Private method to build all full paths of an executable file from
 the environment.
-@param file filename of the executable (string)
+@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):
 def supportedPythonVariants(self):
 """
 Public method to get the supported Python variants.
-@return list of supported Python variants (list of strings)
+@return list of supported Python variants
+@rtype list of str
 """
 variants = []
 for variant in ['Python3']:
 virtEnv = self.__getVirtualEnvironment(variant)
 if virtEnv:
 def __getVirtualEnvironment(self, language=""):
 """
 Private method to get the path of the virtual environment.
 @param language Python variant to get the virtual environment
-for (string, one of '' or 'Python3')
+for (one of '' or 'Python3')
-@return path of the virtual environment (string)
+@type str
+@return path of the virtual environment
+@rtype str
 """
 if not language:
-language = self.__e5project.getProjectLanguage()
+language = self.__ericProject.getProjectLanguage()
 venvName = (
 self.__plugin.getPreferences("VirtualEnvironmentNamePy3")
 if language == "Python3" else
 ""
 )
 def __getDebugEnvironment(self, language=""):
 """
 Private method to get the path of the debugger environment.
 @param language Python variant to get the debugger environment
-for (string, one of '' or 'Python3')
+for (one of '' or 'Python3')
-@return path of the debugger environment (string)
+@type str
+@return path of the debugger environment
+@rtype str
 """
 if not language:
-language = self.__e5project.getProjectLanguage()
+language = self.__ericProject.getProjectLanguage()
 debugEnv = self.__getVirtualEnvironment(language)
 if not debugEnv:
 if language == "Python3":
 venvName = Preferences.getDebugger("Python3VirtualEnv")
 else:
 def __getDjangoAdminCommand(self, language=""):
 """
 Private method to build a django-admin.py command.
 @param language Python variant to get the django-admin.py
-command for (string, one of '' or 'Python3')
+command for (one of '' or 'Python3')
-@return full django-admin.py command (string)
+@type str
+@return full django-admin.py command
+@rtype str
 """
 if not language:
-language = self.__e5project.getProjectLanguage()
+language = self.__ericProject.getProjectLanguage()
 virtualEnv = self.__getVirtualEnvironment(language)
 if virtualEnv:
 if isWindowsPlatform():
 for cmd in [
 else:
 cmd = ""
 else:
 if language == "Python3":
 cmds = ["django-admin3.py", "django-admin3",
+"django-admin.py-3.10",
+"django-admin.py-3.9", "django-admin.py-3.8",
 "django-admin.py-3.7", "django-admin.py-3.6",
-"django-admin.py-3.5", "django-admin.py-3.4",
-"django-admin.py-3.3", "django-admin.py-3.2",
 ]
 else:
 cmds = []
 cmds.extend(["django-admin.py", "django-admin"])
 for cmd in cmds:
 def __getPythonExecutable(self):
 """
 Private method to build the Python command.
-@return python command (string)
+@return python command
-"""
+@rtype str
-language = self.__e5project.getProjectLanguage()
+"""
+language = self.__ericProject.getProjectLanguage()
 if language == "Python3":
 venvName = self.__plugin.getPreferences(
 "VirtualEnvironmentNamePy3")
 if not venvName:
 # if none configured, use the global one
 Private slot to show some info about Django.
 """
 version = self.getDjangoVersionString()
 url = "https://www.djangoproject.com"
-msgBox = E5MessageBox.E5MessageBox(
+msgBox = EricMessageBox.EricMessageBox(
-E5MessageBox.Question,
+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>"
 "<tr><td>URL:</td><td><a href=\"{1}\">"
 "{1}</a></td></tr>"
 "</table></p>"
 ).format(version, url),
 modal=True,
-buttons=E5MessageBox.Ok)
+buttons=EricMessageBox.Ok)
 msgBox.setIconPixmap(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 (string)
+@return Django version
+@rtype str
 """
 djangoVersion = ""
 args = ['--version']
 ioEncoding = Preferences.getSystem("IOEncoding")
 def __getApplications(self):
 """
 Private method to ask the user for a list of application names.
-@return list of application names (list of strings)
+@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."),
 def setMostRecentApplication(self, applStr):
 """
 Public method to set the most recently used applications entry.
-@param applStr applications entry (string)
+@param applStr applications entry
+@type str
 """
 if applStr in self.__recentApplications:
 self.__recentApplications.remove(applStr)
 self.__recentApplications.insert(0, applStr)
 self.__recentTestData[key][:maxRecentTestData])
 self.__saveRecentTestData()
 def getProjectPath(self):
 """
-Public method to get the path of the eric6 project.
+Public method to get the path of the eric7 project.
-@return path of the eric6 project (string)
+@return path of the eric7 project
-"""
+@rtype str
-return self.__e5project.getProjectPath()
+"""
+return self.__ericProject.getProjectPath()
 def __showHelpIndex(self):
 """
 Private slot to show the help index page.
 """
 def __isSpawningConsole(self, consoleCmd):
 """
 Private method to check, if the given console is a spawning console.
-@param consoleCmd console command (string)
+@param consoleCmd console command
+@type str
 @return tuple of two entries giving an indication, if the console
-is spawning (boolean) and the (possibly) cleaned console command
+is spawning and the (possibly) cleaned console command
-(string)
+@rtype tuple of (bool, str)
 """
 if consoleCmd and consoleCmd[0] == '@':
 return (True, consoleCmd[1:])
 else:
 return (False, consoleCmd)
 def newProjectCreated(self):
 """
 Public slot to finish up the newly generated project.
 """
-if self.__e5project.getProjectType() == "Django":
+if self.__ericProject.getProjectType() == "Django":
-ppath = self.__e5project.getProjectPath()
+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.__e5project.deleteFile("__init__.py")
+self.__ericProject.deleteFile("__init__.py")
-self.__e5project.saveProject()
+self.__ericProject.saveProject()
 def startProjectOrApplication(self):
 """
 Public slot to start a new Django project or application.
 """
-if self.__e5project.getProjectType() == "Django":
+if self.__ericProject.getProjectType() == "Django":
 projectStr = self.tr("Project")
 applStr = self.tr("Application")
 selections = ["", projectStr, applStr]
 selection, ok = QInputDialog.getItem(
 self.__ui,
 selections,
 0, False)
 if ok and bool(selection):
 if selection == projectStr:
 path, projectName = os.path.split(
-self.__e5project.getProjectPath())
+self.__ericProject.getProjectPath())
 self.__createProject(projectName, path)
 elif selection == applStr:
 path, applName = os.path.split(
-self.__e5project.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 (string)
+@param projectName name of the new project
+@type str
 @param path the directory where the project should be created
-(string)
+@type str
-@return flag indicating a successful creation (boolean)
+@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 = E5MessageBox.yesNo(
+okToRemove = EricMessageBox.yesNo(
 self.__ui,
 title,
 self.tr("""<p>The Django project path <b>{0}</b> exists"""
 """ already. Shall it be removed and recreated?"""
 """</p>""").format(ppath))
 if not okToRemove:
-E5MessageBox.information(
+EricMessageBox.information(
 self.__ui,
 title,
 self.tr("""<p>Please add the files to the eric project"""
 """ manually.</p>"""))
 return True
 if cmd:
 if Utilities.isWindowsPlatform():
 args.append(self.__getPythonExecutable())
 args.append(cmd)
 else:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.__ui,
 title,
 self.tr("""<p>The <b>django-admin.py</b> script is"""
 """ not in the path. Aborting...</p>"""))
 return False
 if not os.path.exists(i18nPath):
 os.makedirs(i18nPath)
 if (
 os.path.join(path, projectName) ==
-self.__e5project.getProjectPath()
+self.__ericProject.getProjectPath()
 ):
 self.__setCurrentSite("")
 else:
 self.__setCurrentSite(projectName)
 """
 projectName, ok = QInputDialog.getText(
 self.__ui,
 self.tr("Start Django Project"),
 self.tr("Enter the name of the new Django project."),
-QLineEdit.Normal)
+QLineEdit.EchoMode.Normal)
 if ok and projectName != "":
 res = self.__createProject(projectName,
-self.__e5project.getProjectPath())
+self.__ericProject.getProjectPath())
 if res:
 # search for new files and add them to the project
-sitePath = os.path.join(self.__e5project.getProjectPath(),
+sitePath = os.path.join(self.__ericProject.getProjectPath(),
 projectName)
 for entry in os.walk(sitePath):
 for fileName in entry[2]:
 fullName = os.path.join(entry[0], fileName)
-self.__e5project.appendFile(fullName)
+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 (string)
+@param applName name of the new application
+@type str
 @param path the directory where the application should be created
-(string)
+@type str
 @param isGlobal flag indicating a standalone Django application
-(boolean)
+@type bool
-@return flag indicating a successful creation (boolean)
+@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 cmd:
 if Utilities.isWindowsPlatform():
 args.append(self.__getPythonExecutable())
 args.append(cmd)
 else:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.__ui,
 title,
 self.tr("""<p>The <b>django-admin.py</b> script"""
 """ is not in the path."""
 """ Aborting...</p>"""))
 applName, ok = QInputDialog.getText(
 self.__ui,
 self.tr("Start Global Django Application"),
 self.tr("Enter the name of the new global Django"
 " application."),
-QLineEdit.Normal)
+QLineEdit.EchoMode.Normal)
 if ok and applName != "":
 res = self.__createApplication(applName,
-self.__e5project.getProjectPath())
+self.__ericProject.getProjectPath())
 if res:
 # search for new files and add them to the project
-appPath = os.path.join(self.__e5project.getProjectPath(),
+appPath = os.path.join(self.__ericProject.getProjectPath(),
 applName)
 for entry in os.walk(appPath):
 for fileName in entry[2]:
 fullName = os.path.join(entry[0], fileName)
-self.__e5project.appendFile(fullName)
+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.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.__e5project.appendFile(fullName)
+self.__ericProject.appendFile(fullName)
 except DjangoNoSiteSelectedException:
 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 (list of strings)
+@return list of sites
+@rtype list of str
 """
 sites = []
-for file in sorted(self.__e5project.getSources()):
+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):
 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
-@return path of the site (string)
 """
 if self.__currentSite is None:
 self.__selectSite()
 if self.__currentSite is None:
 raise DjangoNoSiteSelectedException
 else:
-path = os.path.join(self.__e5project.getProjectPath(),
+path = os.path.join(self.__ericProject.getProjectPath(),
 self.__currentSite)
 return path
 def __setCurrentSite(self, site):
 """
 Private slot to set the current site.
-@param site name of the site (string)
+@param site name of the site
+@type str
 """
 self.__currentSite = site
 if self.__currentSite is None:
 curSite = self.tr("None")
 elif self.__currentSite == "":
 curSite = self.__currentSite
 self.selectSiteAct.setText(
 self.tr('&Current Django project ({0})').format(curSite))
 if self.__currentSite is None:
-self.__e5project.setTranslationPattern("")
+self.__ericProject.setTranslationPattern("")
 else:
-self.__e5project.setTranslationPattern(
+self.__ericProject.setTranslationPattern(
 os.path.join(site, "locale", "%language%", "LC_MESSAGES",
 "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
-@return name of the site (string)
 """
 if self.__currentSite is None:
 self.__selectSite()
 if self.__currentSite is None:
 self.__serverProcFinished)
 self.__serverProc.setWorkingDirectory(self.__sitePath())
 self.__serverProc.start(args[0], args[1:])
 serverProcStarted = self.__serverProc.waitForStarted()
 if not serverProcStarted:
-E5MessageBox.critical(
+EricMessageBox.critical(
 None,
 self.tr('Process Generation Error'),
 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.state() != QProcess.NotRunning
+self.__serverProc.state() != QProcess.ProcessState.NotRunning
 ):
 self.__serverProc.terminate()
 QTimer.singleShot(2000, self.__serverProc.kill)
 self.__serverProc.waitForFinished(3000)
 self.__serverProc = None
 addr = "127.0.0.1"
 url = "http://{0}:{1}".format(addr, port)
 if self.__plugin.getPreferences("UseExternalBrowser"):
 res = QDesktopServices.openUrl(QUrl(url))
 if not res:
-E5MessageBox.critical(
+EricMessageBox.critical(
 None,
 self.tr('Run Web-Browser'),
 self.tr('Could not start the web-browser for the'
 ' url "{0}".').format(url.toString()))
 else:
 except DjangoNoSiteSelectedException:
 return
 title = self.tr("Flush Database")
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.__ui,
 title,
 self.tr("""Flushing the database will destroy all data."""
 """ Are you sure?"""))
 if res:
 with contextlib.suppress(DjangoNoSiteSelectedException):
 wd = self.__sitePath()
 self.__adjustWorkingDirectory(args, wd)
 started, pid = QProcess.startDetached(args[0], args[1:], wd)
 if not started:
-E5MessageBox.critical(
+EricMessageBox.critical(
 None,
 self.tr('Process Generation Error'),
 self.tr('The Django process could not be started.'))
 #######################################################################
 def __sqlCommand(self, title, command, requestApps=True):
 """
 Private method to perform an SQL creation function.
-@param title dialog title (string)
+@param title dialog title
-@param command Django sql... command (string)
+@type str
+@param command Django sql... command
+@type str
 @param requestApps flag indicating to request a list of applications
-to work on (boolean)
+to work on
+@type bool
 """
 try:
 path = self.__sitePath()
 except DjangoNoSiteSelectedException:
 return
 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 unapply
+@param backwards flag indicating to generate the SQL code to revert
 a migration
 @type bool
 """
 try:
 path = self.__sitePath()
 except DjangoNoSiteSelectedException:
 return
 migrations = self.__getMigrations()
 if not migrations:
-E5MessageBox.information(
+EricMessageBox.information(
 None,
 self.tr("SQL Migrate"),
 self.tr("""No migrations available."""))
 return
 DjangoMigrationSelectionDialog
 )
 dlg = DjangoMigrationSelectionDialog(migrations,
 migrationRequired=True,
 suffix=self.__iconSuffix)
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 app, migration = dlg.getData()
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 """
 Private slot to apply selected migrations of a selected app.
 """
 migrations = self.__getMigrations()
 if not migrations:
-E5MessageBox.information(
+EricMessageBox.information(
 None,
 self.tr("Apply Selected Migrations"),
 self.tr("""No migrations available."""))
 return
 from .DjangoMigrationSelectionDialog import (
 DjangoMigrationSelectionDialog
 )
 dlg = DjangoMigrationSelectionDialog(migrations,
 suffix=self.__iconSuffix)
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 app, migration = dlg.getData()
 self.applyMigrations(app=app, migration=migration)
 def applyMigrations(self, app=None, migration=None):
 """
 if res:
 dia.exec()
 def __unapplyMigrations(self):
 """
-Private slot to un-apply all migrations of an application.
+Private slot to revert all migrations of an application.
 """
 apps = list(sorted(self.__getMigrations().keys()))
 if not apps:
-E5MessageBox.information(
+EricMessageBox.information(
 None,
 self.tr("Unapply Migrations"),
 self.tr("""No migrations available."""))
 return
 """
 Private slot to generate migrations for the Django project.
 """
 from .DjangoMakeMigrationsDialog import DjangoMakeMigrationsDialog
 dlg = DjangoMakeMigrationsDialog(self.getRecentApplications())
-if dlg.exec() == QDialog.Accepted:
+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)
 """
 Private slot to squash migrations.
 """
 migrations = self.__getMigrations()
 if not migrations:
-E5MessageBox.information(
+EricMessageBox.information(
 None,
 self.tr("Squash Migrations"),
 self.tr("""No migrations available."""))
 return
 from .DjangoSquashMigrationSelectionDialog import (
 DjangoSquashMigrationSelectionDialog
 )
 dlg = DjangoSquashMigrationSelectionDialog(
 migrations, self, self.__iconSuffix)
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 app, start, end, noOptimize, name = dlg.getData()
 title = self.tr("Squash Migrations")
 try:
 """
 title = self.tr("Diff Settings")
 from .DjangoDiffsettingsDataDialog import DjangoDiffsettingsDataDialog
 dlg = DjangoDiffsettingsDataDialog(self, self.__ui)
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 showAll, defaultModule, outputFormat = dlg.getData()
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 with contextlib.suppress(DjangoNoSiteSelectedException):
 wd = self.__sitePath()
 self.__adjustWorkingDirectory(args, wd)
 started, pid = QProcess.startDetached(args[0], args[1:], wd)
 if not started:
-E5MessageBox.critical(
+EricMessageBox.critical(
 None,
 self.tr('Process Generation Error'),
 self.tr('The Django process could not be started.'))
 def __sendTestEmail(self):
 from .DjangoSendTestEmailDataDialog import (
 DjangoSendTestEmailDataDialog
 )
 dlg = DjangoSendTestEmailDataDialog(self.__ui)
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 managers, admins, recipients = dlg.getData()
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 except DjangoNoSiteSelectedException:
 return
 from .DjangoDumpdataDataDialog import DjangoDumpdataDataDialog
 dlg = DjangoDumpdataDataDialog(self, self.__ui)
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 appls, excls, dumpFormat, indent = dlg.getData()
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 except DjangoNoSiteSelectedException:
 return
 from .DjangoLoaddataDataDialog import DjangoLoaddataDataDialog
 dlg = DjangoLoaddataDataDialog(self, self.__ui)
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 fixtures, excludes, appLabel, ignore = dlg.getData()
 args = []
 args.append(self.__getPythonExecutable())
 args.append("manage.py")
 from .DjangoTestDataDialog import DjangoTestDataDialog
 dlg = DjangoTestDataDialog(
 self, self.__plugin.getPreferences("KeepTestDatabase"),
 self.__ui)
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 labels, pattern, tags, excludeTags, keep, reverse = (
 dlg.getData())
 self.__plugin.setPreferences("KeepTestDatabase", keep)
 args.extend(labels)
 self.__adjustWorkingDirectory(args, wd)
 started, pid = QProcess.startDetached(args[0], args[1:], wd)
 if not started:
-E5MessageBox.critical(
+EricMessageBox.critical(
 None,
 self.tr('Process Generation Error'),
 self.tr('The Django process could not be started.'))
 def __runTestServer(self):
 if consoleCmd:
 from .DjangoRunTestServerDataDialog import (
 DjangoRunTestServerDataDialog
 )
 dlg = DjangoRunTestServerDataDialog(self, self.__ui)
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 fixtures = dlg.getData()
 args = Utilities.parseOptionString(consoleCmd)
 args[0] = Utilities.getExecutablePath(args[0])
 args.append(self.__getPythonExecutable())
 self.__sitePath())
 self.__testServerProc.start(args[0], args[1:])
 serverProcStarted = (
 self.__testServerProc.waitForStarted())
 if not serverProcStarted:
-E5MessageBox.critical(
+EricMessageBox.critical(
 None,
 self.tr('Process Generation Error'),
 self.tr('The Django test server could not be'
 ' started.'))
 """
 Private slot connected to the finished signal of the test server.
 """
 if (
 self.__testServerProc is not None and
-self.__testServerProc.state() != QProcess.NotRunning
+self.__testServerProc.state() != QProcess.ProcessState.NotRunning
 ):
 self.__testServerProc.terminate()
 QTimer.singleShot(2000, self.__testServerProc.kill)
 self.__testServerProc.waitForFinished(3000)
 self.__testServerProc = None
 if consoleCmd:
 userName, ok = QInputDialog.getText(
 self.__ui,
 self.tr("Change Password"),
 self.tr("Enter the name of the user:"),
-QLineEdit.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")
 wd = self.__sitePath()
 self.__adjustWorkingDirectory(args, wd)
 started, pid = QProcess.startDetached(
 args[0], args[1:], wd)
 if not started:
-E5MessageBox.critical(
+EricMessageBox.critical(
 None,
 self.tr('Process Generation Error'),
 self.tr('The Django process could not be'
 ' started.'))
 with contextlib.suppress(DjangoNoSiteSelectedException):
 wd = self.__sitePath()
 self.__adjustWorkingDirectory(args, wd)
 started, pid = QProcess.startDetached(args[0], args[1:], wd)
 if not started:
-E5MessageBox.critical(
+EricMessageBox.critical(
 None,
 self.tr('Process Generation Error'),
 self.tr('The Django process could not be started.'))
 ##################################################################
 def __getLocale(self, filename):
 """
 Private method to extract the locale out of a file name.
-@param filename name of the file used for extraction (string)
+@param filename name of the file used for extraction
-@return extracted locale (string) or None
+@type str
-"""
+@return extracted locale or None
-if self.__e5project.getTranslationPattern():
+@rtype str
+"""
+if self.__ericProject.getTranslationPattern():
 pattern = (
-self.__e5project.getTranslationPattern()
+self.__ericProject.getTranslationPattern()
 .replace("%language%", "(.*?)")
 )
 match = re.search(pattern, filename)
 if match is not None:
 loc = match.group(1)
 def __normalizeList(self, filenames):
 """
 Private method to normalize a list of file names.
-@param filenames list of file names to normalize (list of strings)
+@param filenames list of file names to normalize
-@return normalized file names (list of strings)
+@type list of str
+@return normalized file names
+@rtype list of str
 """
 nfilenames = []
 for filename in filenames:
 if filename.endswith(".mo"):
 filename = filename.replace(".mo", ".po")
 def __siteFilteredList(self, filenames):
 """
 Private method to filter a list of file names by site.
-@param filenames list of file names to be filtered (list of strings)
+@param filenames list of file names to be filtered
-@return file names belonging to the current site (list of strings)
+@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):
 def __projectLanguageAdded(self, code):
 """
 Private slot handling the addition of a new language.
-@param code language code of the new language (string)
+@param code language code of the new language
+@type str
 """
 title = (
 self.tr("Initializing message catalog for '{0}'")
 .format(code)
 )
 args.append("--locale={0}".format(code))
 try:
 wd = self.__sitePath()
 except DjangoNoSiteSelectedException:
-E5MessageBox.warning(
+EricMessageBox.warning(
 None,
 title,
 self.tr('No current site selected or no site created yet.'
 ' Aborting...'))
 return
 res = dia.startProcess(args, wd)
 if res:
 dia.exec()
 langFile = (
-self.__e5project.getTranslationPattern()
+self.__ericProject.getTranslationPattern()
 .replace("%language%", code)
 )
-self.__e5project.appendFile(langFile)
+self.__ericProject.appendFile(langFile)
 def updateSelectedCatalogs(self, filenames):
 """
 Public method to update the message catalogs.
-@param filenames list of file names (list of strings)
+@param filenames list of file names
+@type list of str
 """
 title = self.tr("Updating message catalogs")
 try:
 wd = self.__sitePath()
 except DjangoNoSiteSelectedException:
-E5MessageBox.warning(
+EricMessageBox.warning(
 None,
 title,
 self.tr('No current site selected or no site created yet.'
 ' Aborting...'))
 return
 args.append("--no-obsolete")
 args.append("--locale={0}".format(locale))
 argsLists.append(args)
 if len(argsLists) == 0:
-E5MessageBox.warning(
+EricMessageBox.warning(
 None,
 title,
 self.tr('No locales detected. Aborting...'))
 return
 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:
-E5MessageBox.warning(
+EricMessageBox.warning(
 None,
 title,
 self.tr('No current site selected or no site created yet.'
 ' Aborting...'))
 return
 args.append("makemessages")
 args.append("--locale={0}".format(locale))
 argsLists.append(args)
 if len(argsLists) == 0:
-E5MessageBox.warning(
+EricMessageBox.warning(
 None,
 title,
 self.tr('No locales detected. Aborting...'))
 return
 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("--no-obsolete")
 try:
 wd = self.__sitePath()
 except DjangoNoSiteSelectedException:
-E5MessageBox.warning(
+EricMessageBox.warning(
 None,
 title,
 self.tr('No current site selected or no site created yet.'
 ' Aborting...'))
 return
 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"
 " messages)")
 args = []
 args.append("--all")
 try:
 wd = self.__sitePath()
 except DjangoNoSiteSelectedException:
-E5MessageBox.warning(
+EricMessageBox.warning(
 None,
 title,
 self.tr('No current site selected or no site created yet.'
 ' Aborting...'))
 return
 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:
-E5MessageBox.warning(
+EricMessageBox.warning(
 None,
 title,
 self.tr('No current site selected or no site created yet.'
 ' Aborting...'))
 return
 if self.__plugin.getPreferences("FuzzyTranslations"):
 args.append("--use-fuzzy")
 argsLists.append(args)
 if len(argsLists) == 0:
-E5MessageBox.warning(
+EricMessageBox.warning(
 None,
 title,
 self.tr('No locales detected. Aborting...'))
 return
 for entry in os.walk(self.__sitePath()):
 for fileName in entry[2]:
 fullName = os.path.join(entry[0], fileName)
 if fullName.endswith('.mo'):
-self.__e5project.appendFile(fullName)
+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("--use-fuzzy")
 try:
 wd = self.__sitePath()
 except DjangoNoSiteSelectedException:
-E5MessageBox.warning(
+EricMessageBox.warning(
 None,
 title,
 self.tr('No current site selected or no site created yet.'
 ' Aborting...'))
 return
 for entry in os.walk(self.__sitePath()):
 for fileName in entry[2]:
 fullName = os.path.join(entry[0], fileName)
 if fullName.endswith('.mo'):
-self.__e5project.appendFile(fullName)
+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 (string)
+@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:
 wd = ""
 started, pid = QProcess.startDetached(editor, [poFile], wd)
 if not started:
-E5MessageBox.critical(
+EricMessageBox.critical(
 None,
 self.tr('Process Generation Error'),
 self.tr('The translations editor process ({0}) could'
 ' not be started.')
 .format(os.path.basename(editor)))
 from .DjangoCheckOptionsDialog import DjangoCheckOptionsDialog
 dlg = DjangoCheckOptionsDialog(
 self.__getPythonExecutable(), path, self.getRecentApplications(),
 self.__plugin.getPreferences("CheckDeployMode"),
 )
-if dlg.exec() == QDialog.Accepted:
+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()

Mercurial Repositories > Django Project / file comparison

comparison: ProjectDjango/Project.py

ProjectDjango/Project.py