eric: comparison src/eric7/PluginManager/PluginManager.py

-:1444b4bee64b
+:093dcebe5ecb
 """
 import contextlib
 import datetime
 import importlib
+import itertools
 import os
 import pathlib
 import sys
 import types
 import zipfile
 def finalizeSetup(self):
 """
 Public method to finalize the setup of the plugin manager.
 """
-for module in list(self.__onDemandInactiveModules.values()) + list(
+for module in itertools.chain(
-self.__onDemandActiveModules.values()
+self.__onDemandInactiveModules.values(),
+self.__onDemandActiveModules.values(),
 ):
 if hasattr(module, "moduleSetup"):
 module.moduleSetup()
 def getPluginDir(self, key):
 """
 packages = [package] + internalPackages
 found = False
 if not package:
 package = "__None__"
-for moduleName in list(sys.modules.keys())[:]:
+for moduleName in list(sys.modules):
 if moduleName == pluginName or moduleName.split(".")[0] in packages:
 found = True
 del sys.modules[moduleName]
 return found
 """
 Public method to create plugin objects for all on demand plugins.
 Note: The plugins are not activated.
 """
-names = sorted(self.__onDemandInactiveModules.keys())
+names = sorted(self.__onDemandInactiveModules)
 for name in names:
 self.initOnDemandPlugin(name)
 def initOnDemandPlugin(self, name):
 """
 if (
 self.__develPluginName is not None
 and self.__develPluginName in inactiveList
 ):
 inactiveList.remove(self.__develPluginName)
-names = sorted(self.__inactiveModules.keys())
+names = sorted(self.__inactiveModules)
 for name in names:
 if name not in inactiveList:
 self.activatePlugin(name)
 self.allPlugginsActivated.emit()
 already
 @type bool
 @return reference to the initialized plugin object and an error string
 @rtype tuple of (QObject, str)
 """
-for name, module in list(self.__onDemandInactiveModules.items()):
+for name, module in self.__onDemandInactiveModules.items():
 if (
 getPluginHeaderEntry(module, "pluginType", "") == type_
 and getPluginHeaderEntry(module, "pluginTypename", "") == typename
 ):
 return self.activatePlugin(name, onDemand=True)
 if maybeActive:
-for name, module in list(self.__onDemandActiveModules.items()):
+for name, module in self.__onDemandActiveModules.items():
 if (
 getPluginHeaderEntry(module, "pluginType", "") == type_
 and getPluginHeaderEntry(module, "pluginTypename", "") == typename
 ):
 self.deactivatePlugin(name, onDemand=True)
 "short_desc": str, "error": bool)
 """
 infos = []
 # 1. active, non-on-demand modules
-for name in list(self.__activeModules.keys()):
+for name in self.__activeModules:
 info = self.__getShortInfo(self.__activeModules[name])
 info.update(
 {
 "module_name": name,
 "auto_activate": True,
 }
 )
 infos.append(info)
 # 2. inactive, non-on-demand modules
-for name in list(self.__inactiveModules.keys()):
+for name in self.__inactiveModules:
 info = self.__getShortInfo(self.__inactiveModules[name])
 info.update(
 {
 "module_name": name,
 "auto_activate": True,
 }
 )
 infos.append(info)
 # 3. active, on-demand modules
-for name in list(self.__onDemandActiveModules.keys()):
+for name in self.__onDemandActiveModules:
 info = self.__getShortInfo(self.__onDemandActiveModules[name])
 info.update(
 {
 "module_name": name,
 "auto_activate": False,
 }
 )
 infos.append(info)
 # 4. inactive, non-on-demand modules
-for name in list(self.__onDemandInactiveModules.keys()):
+for name in self.__onDemandInactiveModules:
 info = self.__getShortInfo(self.__onDemandInactiveModules[name])
 info.update(
 {
 "module_name": name,
 "auto_activate": False,
 }
 )
 infos.append(info)
 # 5. failed modules
-for name in list(self.__failedModules.keys()):
+for name in self.__failedModules:
 info = self.__getShortInfo(self.__failedModules[name])
 info.update(
 {
 "module_name": name,
 "auto_activate": False,
 def doShutdown(self):
 """
 Public method called to perform actions upon shutdown of the IDE.
 """
 names = []
-for name in list(self.__inactiveModules.keys()):
+for name in self.__inactiveModules:
 names.append(name)
 Preferences.getSettings().setValue(self.__inactivePluginsKey, names)
 self.shutdown.emit()
 @return dictionary with name as key and display string as value
 @rtype dict
 """
 pluginDict = {}
-for module in list(self.__onDemandActiveModules.values()) + list(
+for module in itertools.chain(
-self.__onDemandInactiveModules.values()
+self.__onDemandActiveModules.values(),
+self.__onDemandInactiveModules.values(),
 ):
 if (
 getPluginHeaderEntry(module, "pluginType", "") == type_
 and getPluginHeaderEntry(module, "error", "") == ""
 ):
 @param name name of the plugin type
 @type str
 @return preview pixmap
 @rtype QPixmap
 """
-for module in list(self.__onDemandActiveModules.values()) + list(
+for module in itertools.chain(
-self.__onDemandInactiveModules.values()
+self.__onDemandActiveModules.values(),
+self.__onDemandInactiveModules.values(),
 ):
 if (
 getPluginHeaderEntry(module, "pluginType", "") == type_
 and getPluginHeaderEntry(module, "pluginTypename", "") == name
 ):
 @return list of API filenames
 @rtype list of str
 """
 apis = []
-for module in list(self.__activeModules.values()) + list(
+for module in itertools.chain(
-self.__onDemandActiveModules.values()
+self.__activeModules.values(),
+self.__onDemandActiveModules.values(),
 ):
 if hasattr(module, "apiFiles"):
 apis.extend(module.apiFiles(language))
 return apis
 @return dictionary with documentation type as key and list of files
 as value
 @rtype dict (key: str, value: list of str)
 """
 helpFiles = {}
-for module in list(self.__activeModules.values()) + list(
+for module in itertools.chain(
-self.__onDemandActiveModules.values()
+self.__activeModules.values(),
+self.__onDemandActiveModules.values(),
 ):
 if hasattr(module, "helpFiles"):
 helpFiles.update(module.helpFiles())
 return helpFiles
 </ul>
 @rtype list of dict
 """
 infos = []
-for module in list(self.__activeModules.values()) + list(
+for module in itertools.chain(
-self.__inactiveModules.values()
+self.__activeModules.values(),
-):
+self.__inactiveModules.values(),
-if hasattr(module, "exeDisplayDataList"):
+self.__onDemandActiveModules.values(),
-infos.extend(module.exeDisplayDataList())
+self.__onDemandInactiveModules.values(),
-elif hasattr(module, "exeDisplayData"):
-infos.append(module.exeDisplayData())
-for module in list(self.__onDemandActiveModules.values()) + list(
-self.__onDemandInactiveModules.values()
 ):
 if hasattr(module, "exeDisplayDataList"):
 infos.extend(module.exeDisplayDataList())
 elif hasattr(module, "exeDisplayData"):
 infos.append(module.exeDisplayData())
 @return plug-in configuration data
 @rtype dict
 """
 configData = {}
-for module in (
+for module in itertools.chain(
-list(self.__activeModules.values())
+self.__activeModules.values(),
-+ list(self.__onDemandActiveModules.values())
+self.__onDemandActiveModules.values(),
-+ list(self.__onDemandInactiveModules.values())
+self.__onDemandInactiveModules.values(),
 ):
 if hasattr(module, "getConfigData"):
 configData.update(module.getConfigData())
 return configData
 string (str).
 @rtype dict
 """
 vcsDict = {}
-for module in list(self.__onDemandActiveModules.values()) + list(
+for module in itertools.chain(
-self.__onDemandInactiveModules.values()
+self.__onDemandActiveModules.values(),
+self.__onDemandInactiveModules.values(),
 ):
 if getPluginHeaderEntry(
 module, "pluginType", ""
 ) == "version_control" and hasattr(module, "getVcsSystemIndicator"):
 res = module.getVcsSystemIndicator()
-for indicator, vcsData in list(res.items()):
+for indicator, vcsData in res.items():
 if indicator in vcsDict:
 vcsDict[indicator].append(vcsData)
 else:
 vcsDict[indicator] = [vcsData]
 clearPrivateData() and have the module level attribute pluginType.
 @param type_ type of the plugin to clear private data for
 @type str
 """
-for module in (
+for module in itertools.chain(
-list(self.__onDemandActiveModules.values())
+self.__onDemandActiveModules.values(),
-+ list(self.__onDemandInactiveModules.values())
+self.__onDemandInactiveModules.values(),
-+ list(self.__activeModules.values())
+self.__activeModules.values(),
-+ list(self.__inactiveModules.values())
+self.__inactiveModules.values(),
 ):
 if getPluginHeaderEntry(module, "pluginType", "") == type_ and hasattr(
 module, "clearPrivateData"
 ):
 module.clearPrivateData()

Mercurial Repositories > eric / file comparison

comparison: src/eric7/PluginManager/PluginManager.py

src/eric7/PluginManager/PluginManager.py