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

-:8f69edb4ad73
+:1f7d52f024b1
 def getPluginDir(self, key):
 """
 Public method to get the path of a plugin directory.
-@param key key of the plug-in directory (string)
+@param key key of the plug-in directory
-@return path of the requested plugin directory (string)
+@type str
+@return path of the requested plugin directory
+@rtype str
 """
 if key not in ["global", "user"]:
 return None
 else:
 try:
 Private method to check, if the plugin folders exist.
 If the plugin folders don't exist, they are created (if possible).
 @return tuple of a flag indicating existence of any of the plugin
-directories (boolean) and a message (string)
+directories and a message
+@rtype tuple of (bool, str)
 """
 if self.__develPluginFile:
 path = FileSystemUtilities.splitPath(self.__develPluginFile)[0]
 fname = os.path.join(path, "__init__.py")
 if not os.path.exists(fname):
 def __pluginModulesExist(self):
 """
 Private method to check, if there are plugins available.
-@return flag indicating the availability of plugins (boolean)
+@return flag indicating the availability of plugins
+@rtype bool
 """
 if self.__develPluginFile and not os.path.exists(self.__develPluginFile):
 return False
 self.__foundCoreModules = self.getPluginModules(self.pluginDirs["eric7"])
 def getPluginModules(self, pluginPath):
 """
 Public method to get a list of plugin modules.
-@param pluginPath name of the path to search (string)
+@param pluginPath name of the path to search
-@return list of plugin module names (list of string)
+@type str
+@return list of plugin module names
+@rtype list of str
 """
 pluginFiles = [
 f[:-3] for f in os.listdir(pluginPath) if self.isValidPluginName(f)
 ]
 return pluginFiles[:]
 """
 Public method to check, if a file name is a valid plugin name.
 Plugin modules must start with "Plugin" and have the extension ".py".
-@param pluginName name of the file to be checked (string)
+@param pluginName name of the file to be checked
-@return flag indicating a valid plugin name (boolean)
+@type str
+@return flag indicating a valid plugin name
+@rtype bool
 """
 return pluginName.startswith("Plugin") and pluginName.endswith(".py")
 def __insertPluginsPaths(self):
 """
-Private method to insert the valid plugin paths intos the search path.
+Private method to insert the valid plugin paths into the search path.
 """
 for key in self.__priorityOrder:
 if key in self.pluginDirs:
 if self.pluginDirs[key] not in sys.path:
 sys.path.insert(2, self.pluginDirs[key])
 def unloadPlugin(self, name):
 """
 Public method to unload a plugin module.
-@param name name of the module to be unloaded (string)
+@param name name of the module to be unloaded
-@return flag indicating success (boolean)
+@type str
+@return flag indicating success
+@rtype bool
 """
 if name in self.__onDemandActiveModules:
 # cannot unload an ondemand plugin, that is in use
 return False
 def removePluginFromSysModules(self, pluginName, package, internalPackages):
 """
 Public method to remove a plugin and all related modules from
 sys.modules.
-@param pluginName name of the plugin module (string)
+@param pluginName name of the plugin module
-@param package name of the plugin package (string)
+@type str
-@param internalPackages list of intenal packages (list of string)
+@param package name of the plugin package
+@type str
+@param internalPackages list of intenal packages
+@type list of str
 @return flag indicating the plugin module was found in sys.modules
-(boolean)
+@rtype bool
 """
 packages = [package] + internalPackages
 found = False
 if not package:
 package = "__None__"
 """
 Public method to create a plugin object for the named on demand plugin.
 Note: The plug-in is not activated.
-@param name name of the plug-in (string)
+@param name name of the plug-in
+@type str
 @exception PluginActivationError raised to indicate an issue during the
 plug-in activation
 """
 try:
 try:
 def initPluginToolbars(self, toolbarManager):
 """
 Public method to initialize plug-in toolbars.
 @param toolbarManager reference to the toolbar manager object
-(EricToolBarManager)
+@type EricToolBarManager
 """
 self.initOnDemandPlugins()
 for pluginObject in self.__onDemandInactivePlugins.values():
 with contextlib.suppress(AttributeError):
 pluginObject.initToolbar(self.__ui, toolbarManager)
 def __canActivatePlugin(self, module):
 """
 Private method to check, if a plugin can be activated.
 @param module reference to the module to be activated
+@type Module
 @return flag indicating, if the module satisfies all requirements
-for being activated (boolean)
+for being activated
+@rtype bool
 @exception PluginModuleFormatError raised to indicate an invalid
 plug-in module format
 @exception PluginClassFormatError raised to indicate an invalid
 plug-in class format
 """
 def deactivatePlugin(self, name, onDemand=False):
 """
 Public method to deactivate a plugin.
 @param name name of the module to be deactivated
+@type str
 @param onDemand flag indicating deactivation of an
-on demand plugin (boolean)
+on demand plugin
+@type bool
 """
 try:
 module = (
 self.__onDemandActiveModules[name]
 if onDemand
 def __canDeactivatePlugin(self, module):
 """
 Private method to check, if a plugin can be deactivated.
 @param module reference to the module to be deactivated
+@type Module
 @return flag indicating, if the module satisfies all requirements
-for being deactivated (boolean)
+for being deactivated
+@rtype bool
 """
 return getPluginHeaderEntry(module, "deactivateable", True)
 def getPluginObject(self, type_, typename, maybeActive=False):
 """
-Public method to activate an ondemand plugin given by type and
+Public method to activate an on-demand plugin given by type and
-typename.
+type name.
 @param type_ type of the plugin to be activated
 @type str
 @param typename name of the plugin within the type category
 @type str
 def __getShortInfo(self, module):
 """
 Private method to extract the short info from a module.
 @param module module to extract short info from
-@return dictionay containing plug-in data
+@type Module
+@return dictionary containing plug-in data
 @rtype dict ("plugin_name": str, "version": str, "short_desc": str,
 "error": bool)
 """
 return {
 "plugin_name": getPluginHeaderEntry(module, "name", ""),
 def getPluginDetails(self, name):
 """
 Public method to get detailed information about a plugin.
-@param name name of the module to get detailed infos about (string)
+@param name name of the module to get detailed infos about
+@type str
 @return details of the plugin as a dictionary
+@rtype dict
 """
 details = {}
 autoactivate = True
 active = True
 def getPluginDisplayStrings(self, type_):
 """
 Public method to get the display strings of all plugins of a specific
 type.
-@param type_ type of the plugins (string)
+@param type_ type of the plugins
+@type str
 @return dictionary with name as key and display string as value
-(dictionary of string)
+@rtype dict
 """
 pluginDict = {}
 for module in list(self.__onDemandActiveModules.values()) + list(
 self.__onDemandInactiveModules.values()
 def getPluginPreviewPixmap(self, type_, name):
 """
 Public method to get a preview pixmap of a plugin of a specific type.
-@param type_ type of the plugin (string)
+@param type_ type of the plugin
-@param name name of the plugin type (string)
+@type str
-@return preview pixmap (QPixmap)
+@param name name of the plugin type
+@type str
+@return preview pixmap
+@rtype QPixmap
 """
 for module in list(self.__onDemandActiveModules.values()) + list(
 self.__onDemandInactiveModules.values()
 ):
 if (
 def getPluginApiFiles(self, language):
 """
 Public method to get the list of API files installed by a plugin.
-@param language language of the requested API files (string)
+@param language language of the requested API files
-@return list of API filenames (list of string)
+@type str
+@return list of API filenames
+@rtype list of str
 """
 apis = []
 for module in list(self.__activeModules.values()) + list(
 self.__onDemandActiveModules.values()
 (boolean), always False</li>
 <li>header - string to be diplayed as a header (string)</li>
 <li>text - entry text to be shown (string)</li>
 <li>version - version text to be shown (string)</li>
 </ul>
+@rtype list of dict
 """
 infos = []
 for module in list(self.__activeModules.values()) + list(
 self.__inactiveModules.values()
 <dd>This will be used by the configuration dialog and must always
 be None</dd>
 </dl>
 @return plug-in configuration data
+@rtype dict
 """
 configData = {}
 for module in (
 list(self.__activeModules.values())
 + list(self.__onDemandActiveModules.values())
 def isPluginLoaded(self, pluginName):
 """
 Public method to check, if a certain plugin is loaded.
-@param pluginName name of the plugin to check for (string)
+@param pluginName name of the plugin to check for
-@return flag indicating, if the plugin is loaded (boolean)
+@type str
+@return flag indicating, if the plugin is loaded
+@rtype bool
 """
 return (
 pluginName in self.__activeModules
 or pluginName in self.__inactiveModules
 or pluginName in self.__onDemandActiveModules
 def isPluginActive(self, pluginName):
 """
 Public method to check, if a certain plugin is active.
-@param pluginName name of the plugin to check for (string)
+@param pluginName name of the plugin to check for
-@return flag indicating, if the plugin is active (boolean)
+@type str
+@return flag indicating, if the plugin is active
+@rtype bool
 """
 return (
 pluginName in self.__activeModules
 or pluginName in self.__onDemandActiveModules
 )
 Plugins supporting this functionality must support the module function
 getVcsSystemIndicator returning a dictionary with indicator as key and
 a tuple with the vcs name (string) and vcs display string (string).
 @return dictionary with indicator as key and a list of tuples as
-values. Each tuple contains the vcs name (string) and vcs display
+values. Each tuple contains the vcs name (str) and vcs display
-string (string).
+string (str).
+@rtype dict
 """
 vcsDict = {}
 for module in list(self.__onDemandActiveModules.values()) + list(
 self.__onDemandInactiveModules.values()
 url,
 author,  # noqa: U100
 version,
 filename,
 status,  # noqa: U100
+category,  # noqa: U100
 ):
 """
 Public method to check a plug-in's data for an update.
-@param name data for the name field (string)
+@param name data for the name field
-@param short data for the short field (string)
+@type str
-@param description data for the description field (list of strings)
+@param short data for the short field
-@param url data for the url field (string)
+@type str
-@param author data for the author field (string)
+@param description data for the description field
-@param version data for the version field (string)
+@type list of str
-@param filename data for the filename field (string)
+@param url data for the url field
-@param status status of the plugin (string [stable, unstable, unknown])
+@type str
+@param author data for the author field
+@type str
+@param version data for the version field
+@type str
+@param filename data for the filename field
+@type str
+@param status status of the plugin (one of stable, unstable, unknown)
+@type str
+@param category category designation of the plugin
+@type str
 """
 # ignore hidden plug-ins
 pluginName = os.path.splitext(url.rsplit("/", 1)[1])[0]
 if pluginName in Preferences.getPluginManager("HiddenPlugins"):
 return
 def __sslErrors(self, reply, errors):
 """
 Private slot to handle SSL errors.
-@param reply reference to the reply object (QNetworkReply)
+@param reply reference to the reply object
-@param errors list of SSL errors (list of QSslError)
+@type QNetworkReply
+@param errors list of SSL errors
+@type list of QSslError
 """
 ignored = self.__sslErrorHandler.sslErrorsReply(reply, errors)[0]
 if ignored == EricSslErrorState.NOT_IGNORED:
 self.__downloadCancelled = True
 type.
 Plugins supporting this functionality must support the module function
 clearPrivateData() and have the module level attribute pluginType.
-@param type_ type of the plugin to clear private data for (string)
+@param type_ type of the plugin to clear private data for
+@type str
 """
 for module in (
 list(self.__onDemandActiveModules.values())
 + list(self.__onDemandInactiveModules.values())
 + list(self.__activeModules.values())

Mercurial Repositories > eric / file comparison

comparison: src/eric7/PluginManager/PluginManager.py

src/eric7/PluginManager/PluginManager.py