Django Project: comparison PluginProjectDjango.py

-:8413c2429808
+:64339135bd61
 deactivateable = True
 version = "10.0.1"
 className = "ProjectDjangoPlugin"
 packageName = "ProjectDjango"
 shortDescription = "Project support for Django projects."
-longDescription = (
+longDescription = """This plugin implements project support for Django projects."""
-"""This plugin implements project support for Django projects."""
-)
 needsRestart = False
 pyqtApi = 2
 # End-of-Header
 error = ""
 def apiFiles(language):
 """
 Module function to return the API files made available by this plugin.
 @param language language to get APIs for
 @type str
 @return list of API filenames
 @rtype list of str
 """
 if language in ["Python3"]:
-apisDir = os.path.join(os.path.dirname(__file__),
+apisDir = os.path.join(os.path.dirname(__file__), "ProjectDjango", "APIs")
-"ProjectDjango", "APIs")
+apis = glob.glob(os.path.join(apisDir, "*.api"))
-apis = glob.glob(os.path.join(apisDir, '*.api'))
 else:
 apis = []
 return apis
 def createDjangoPage(configDlg):
 """
 Module function to create the Django configuration page.
 @param configDlg reference to the configuration dialog
 @type ConfigurationWidget
 @return reference to the configuration page
 @rtype DjangoPage
 """
 global djangoPluginObject
 from ProjectDjango.ConfigurationPage.DjangoPage import DjangoPage
 page = DjangoPage(djangoPluginObject)
 return page
 def getConfigData():
 """
 Module function returning data as required by the configuration dialog.
 @return dictionary containing the relevant data
 @rtype dict
 """
 usesDarkPalette = ericApp().usesDarkPalette()
 iconSuffix = "dark" if usesDarkPalette else "light"
 return {
 "djangoPage": [
 QCoreApplication.translate("ProjectDjangoPlugin", "Django"),
-os.path.join("ProjectDjango", "icons",
+os.path.join("ProjectDjango", "icons", "django-{0}".format(iconSuffix)),
-"django-{0}".format(iconSuffix)),
+createDjangoPage,
-createDjangoPage, None, None],
+None,
+None,
+],
 }
 def prepareUninstall():
 """
 class ProjectDjangoPlugin(QObject):
 """
 Class implementing the Django project plugin.
 """
 PreferencesKey = "Django"
 lexerAssociations = {
 "*.htm": "Pygments|HTML+Django/Jinja",
 "*.html": "Pygments|HTML+Django/Jinja",
 }
 def __init__(self, ui):
 """
 Constructor
 @param ui reference to the user interface object
 @type UserInterface
 """
 QObject.__init__(self, ui)
 self.__ui = ui
 self.__initialize()
 self.__defaults = {
 "VirtualEnvironmentNamePy3": "",
 "Python3ConsoleType": "ipython",
 "ServerAddress": "",
 "RecentNumberApps": 10,
 "UseIPv6": False,
 "UseThreading": True,
 "TranslationsEditor": "",
 "FuzzyTranslations": False,
 "UseExternalBrowser": False,
 "CheckDeployMode": False,
 "RecentNumberTestData": 10,
 "KeepTestDatabase": False,
 "RecentNumberDatabaseNames": 10,
 }
 if isWindowsPlatform():
 self.__defaults["ConsoleCommandNoClose"] = "cmd.exe /k"
 self.__defaults["ConsoleCommand"] = "cmd.exe /c"
 self.__defaults["ConsoleCommandNoClose"] = "xterm -hold -e"
 self.__defaults["ConsoleCommand"] = "xterm -e"
 else:
 self.__defaults["ConsoleCommandNoClose"] = "konsole --noclose -e"
 self.__defaults["ConsoleCommand"] = "konsole -e"
 self.__translator = None
 self.__loadTranslator()
 def __initialize(self):
 """
 Private slot to (re)initialize the plugin.
 """
 self.__object = None
 self.__mainMenu = None
 self.__mainAct = None
 self.__separatorAct = None
 self.__ericProject = ericApp().getObject("Project")
 self.__supportedVariants = []
 def activate(self):
 """
 Public method to activate this plugin.
 @return tuple of None and activation status
 @rtype bool
 """
 global djangoPluginObject
 djangoPluginObject = self
 usesDarkPalette = ericApp().usesDarkPalette()
 iconSuffix = "dark" if usesDarkPalette else "light"
 self.__object = Project(self, iconSuffix, self.__ui)
 self.__object.initActions()
 ericApp().registerPluginObject("ProjectDjango", self.__object)
 self.__mainMenu = self.__object.initMenu()
 self.__supportedVariants = self.__object.supportedPythonVariants()
 if self.__supportedVariants:
 self.__ericProject.registerProjectType(
-"Django", self.tr("Django"),
+"Django",
+self.tr("Django"),
 self.fileTypesCallback,
 lexerAssociationCallback=self.lexerAssociationCallback,
 binaryTranslationsCallback=self.binaryTranslationsCallback,
-progLanguages=self.__supportedVariants[:])
+progLanguages=self.__supportedVariants[:],
+)
 from Project.ProjectBrowser import (
-SourcesBrowserFlag, FormsBrowserFlag, TranslationsBrowserFlag,
+SourcesBrowserFlag,
-OthersBrowserFlag
+FormsBrowserFlag,
-)
+TranslationsBrowserFlag,
+OthersBrowserFlag,
+)
 Preferences.setProjectBrowserFlagsDefault(
 "Django",
-SourcesBrowserFlag | FormsBrowserFlag |
+SourcesBrowserFlag
-TranslationsBrowserFlag | OthersBrowserFlag,
+| FormsBrowserFlag
-)
+| TranslationsBrowserFlag
+| OthersBrowserFlag,
+)
 if self.__ericProject.isOpen():
 self.__projectOpened()
 self.__object.projectOpenedHooks()
-ericApp().getObject("Project").projectOpened.connect(
+ericApp().getObject("Project").projectOpened.connect(self.__projectOpened)
-self.__projectOpened)
+ericApp().getObject("Project").projectClosed.connect(self.__projectClosed)
-ericApp().getObject("Project").projectClosed.connect(
+ericApp().getObject("Project").newProject.connect(self.__projectOpened)
-self.__projectClosed)
+ericApp().getObject("Project").projectOpenedHooks.connect(
+self.__object.projectOpenedHooks
+)
+ericApp().getObject("Project").projectClosedHooks.connect(
+self.__object.projectClosedHooks
+)
+ericApp().getObject("Project").newProjectHooks.connect(
+self.__object.projectOpenedHooks
+)
+ericApp().getObject("Project").projectAboutToBeCreated.connect(
+self.__object.startProjectOrApplication
+)
 ericApp().getObject("Project").newProject.connect(
-self.__projectOpened)
+self.__object.newProjectCreated
+)
-ericApp().getObject("Project").projectOpenedHooks.connect(
-self.__object.projectOpenedHooks)
-ericApp().getObject("Project").projectClosedHooks.connect(
-self.__object.projectClosedHooks)
-ericApp().getObject("Project").newProjectHooks.connect(
-self.__object.projectOpenedHooks)
-ericApp().getObject("Project").projectAboutToBeCreated.connect(
-self.__object.startProjectOrApplication)
-ericApp().getObject("Project").newProject.connect(
-self.__object.newProjectCreated)
 return None, True
 def deactivate(self):
 """
 Public method to deactivate this plugin.
 """
 ericApp().unregisterPluginObject("ProjectDjango")
-ericApp().getObject("Project").projectOpened.disconnect(
+ericApp().getObject("Project").projectOpened.disconnect(self.__projectOpened)
-self.__projectOpened)
+ericApp().getObject("Project").projectClosed.disconnect(self.__projectClosed)
-ericApp().getObject("Project").projectClosed.disconnect(
+ericApp().getObject("Project").newProject.disconnect(self.__projectOpened)
-self.__projectClosed)
+ericApp().getObject("Project").projectOpenedHooks.disconnect(
+self.__object.projectOpenedHooks
+)
+ericApp().getObject("Project").projectClosedHooks.disconnect(
+self.__object.projectClosedHooks
+)
+ericApp().getObject("Project").newProjectHooks.disconnect(
+self.__object.projectOpenedHooks
+)
+ericApp().getObject("Project").projectAboutToBeCreated.disconnect(
+self.__object.startProjectOrApplication
+)
 ericApp().getObject("Project").newProject.disconnect(
-self.__projectOpened)
+self.__object.newProjectCreated
+)
-ericApp().getObject("Project").projectOpenedHooks.disconnect(
-self.__object.projectOpenedHooks)
-ericApp().getObject("Project").projectClosedHooks.disconnect(
-self.__object.projectClosedHooks)
-ericApp().getObject("Project").newProjectHooks.disconnect(
-self.__object.projectOpenedHooks)
-ericApp().getObject("Project").projectAboutToBeCreated.disconnect(
-self.__object.startProjectOrApplication)
-ericApp().getObject("Project").newProject.disconnect(
-self.__object.newProjectCreated)
 self.__ericProject.unregisterProjectType("Django")
 self.__object.projectClosedHooks()
 self.__projectClosed()
 self.__initialize()
 def __loadTranslator(self):
 """
 Private method to load the translation file.
 """
 if self.__ui is not None:
 loc = self.__ui.getLocale()
 if loc and loc != "C":
 locale_dir = os.path.join(
-os.path.dirname(__file__), "ProjectDjango", "i18n")
+os.path.dirname(__file__), "ProjectDjango", "i18n"
+)
 translation = "django_{0}".format(loc)
 translator = QTranslator(None)
 loaded = translator.load(translation, locale_dir)
 if loaded:
 self.__translator = translator
 ericApp().installTranslator(self.__translator)
 else:
-print("Warning: translation file '{0}' could not be"
+print(
-" loaded.".format(translation))
+"Warning: translation file '{0}' could not be"
+" loaded.".format(translation)
+)
 print("Using default.")
 def __projectOpened(self):
 """
 Private slot to handle the projectOpened signal.
 """
 if self.__ericProject.getProjectType() == "Django":
 projectToolsMenu = self.__ui.getMenu("project_tools")
 insertBeforeAct = projectToolsMenu.actions()[0]
 self.__mainAct = projectToolsMenu.insertMenu(
-insertBeforeAct, self.__mainMenu)
+insertBeforeAct, self.__mainMenu
-self.__separatorAct = projectToolsMenu.insertSeparator(
+)
-insertBeforeAct)
+self.__separatorAct = projectToolsMenu.insertSeparator(insertBeforeAct)
 def __projectClosed(self):
 """
 Private slot to handle the projectClosed signal.
 """
 if self.__mainAct is not None:
 projectToolsMenu.removeAction(self.__separatorAct)
 projectToolsMenu.removeAction(self.__mainAct)
 self.__mainAct = None
 self.__separatorAct = None
 self.__object.projectClosed()
 def fileTypesCallback(self):
 """
 Public method get the filetype associations of the Django project type.
 @return dictionary with file type associations
 @rtype dict
 """
 fileTypes = (
 {
 "*.pot": "TRANSLATIONS",
 "*.po": "TRANSLATIONS",
 "*.mo": "TRANSLATIONS",
 "*.py": "SOURCES",
 }
-if self.__ericProject.getProjectType() == "Django" else
+if self.__ericProject.getProjectType() == "Django"
-{}
+else {}
 )
 return fileTypes
 def lexerAssociationCallback(self, filename):
 """
 Public method to get the lexer association of the Django project type
 for a file.
 @param filename name of the file
 @type str
 @return name of the lexer (Pygments lexers are prefixed with
 'Pygments|')
 @rtype str
 """
 for pattern, language in self.lexerAssociations.items():
 if fnmatch.fnmatch(filename, pattern):
 return language
 return ""
 def binaryTranslationsCallback(self, filename):
 """
 Public method to determine the filename of a compiled translation file
 given the translation source file.
 @param filename name of the translation source file
 @type str
 @return name of the binary translation file
 @rtype str
 """
 if filename.endswith(".po"):
 filename = filename.replace(".po", ".mo")
 return filename
 def getPreferences(self, key):
 """
 Public method to retrieve the various settings.
 @param key the key of the value to get
 @type str
 @return value of the requested setting
 @rtype Any
 """
 if key in ["RecentNumberApps", "RecentNumberTestData"]:
-return int(Preferences.Prefs.settings.value(
+return int(
-self.PreferencesKey + "/" + key, self.__defaults[key]))
+Preferences.Prefs.settings.value(
-elif key in ["UseIPv6", "UseThreading",
+self.PreferencesKey + "/" + key, self.__defaults[key]
-"UseExternalBrowser", "CheckDeployMode",
+)
-"KeepTestDatabase", "FuzzyTranslations", ]:
+)
-return Preferences.toBool(Preferences.Prefs.settings.value(
+elif key in [
-self.PreferencesKey + "/" + key, self.__defaults[key]))
+"UseIPv6",
+"UseThreading",
+"UseExternalBrowser",
+"CheckDeployMode",
+"KeepTestDatabase",
+"FuzzyTranslations",
+]:
+return Preferences.toBool(
+Preferences.Prefs.settings.value(
+self.PreferencesKey + "/" + key, self.__defaults[key]
+)
+)
 else:
 return Preferences.Prefs.settings.value(
-self.PreferencesKey + "/" + key, self.__defaults[key])
+self.PreferencesKey + "/" + key, self.__defaults[key]
+)
 def setPreferences(self, key, value):
 """
 Public method to store the various settings.
 @param key the key of the setting to be set
 @type str
 @param value value to be set
 @type Any
 """
-Preferences.Prefs.settings.setValue(
+Preferences.Prefs.settings.setValue(self.PreferencesKey + "/" + key, value)
-self.PreferencesKey + "/" + key, value)
 if key in ["VirtualEnvironmentNamePy3"]:
 self.__reregisterProjectType()
 elif key == "TranslationsEditor" and self.__object:
 self.__object.registerOpenHook()
 def __reregisterProjectType(self):
 """
 Private method to re-register the project type.
 """
 supportedVariants = self.__object.supportedPythonVariants()
 if supportedVariants != self.__supportedVariants:
 # step 1: unregister
 self.__ericProject.unregisterProjectType("Django")
 # step 2: register again with new language settings
 self.__supportedVariants = supportedVariants
 if self.__supportedVariants:
 self.__ericProject.registerProjectType(
-"Django", self.tr("Django"),
+"Django",
+self.tr("Django"),
 self.fileTypesCallback,
 lexerAssociationCallback=self.lexerAssociationCallback,
 binaryTranslationsCallback=self.binaryTranslationsCallback,
-progLanguages=self.__supportedVariants[:])
+progLanguages=self.__supportedVariants[:],
+)
 def getMenu(self, name):
 """
 Public method to get a reference to the requested menu.
 @param name name of the menu (string)
 @return reference to the menu (QMenu) or None, if no
 menu with the given name exists
 """
 if self.__object is not None:
 return self.__object.getMenu(name)
 else:
 return None
 def getMenuNames(self):
 """
 Public method to get the names of all menus.
 @return menu names (list of string)
 """
 if self.__object is not None:
 return list(self.__menus.keys())
 else:
 return []
 #
 # eflag: noqa = M801

Mercurial Repositories > Django Project / file comparison

comparison: PluginProjectDjango.py

PluginProjectDjango.py