예제 #1
0
    def testConfigurationFileExistence(self):
        """
		Test if the configuration file has been properly written.
		"""
        # activate the only loaded plugin
        self.plugin_activate()
        # get rid of the plugin manager and create a new one
        del self.pluginManager
        del self.config_parser
        self.config_parser = ConfigParser()
        self.config_parser.read(self.config_file)
        self.assertTrue(self.config_parser.has_section("Plugin Management"))
        self.assertTrue(
            self.config_parser.has_option("Plugin Management",
                                          "default_plugins_to_load"))
        self.pluginManager = ConfigurablePluginManager(
            directories_list=[
                os.path.join(os.path.dirname(os.path.abspath(__file__)),
                             "plugins")
            ],
            plugin_info_ext="yapsy-config-plugin",
            configparser_instance=self.config_parser,
            config_change_trigger=self.update_config)
        self.pluginManager.collectPlugins()
        self.plugin_loading_check()
        self.assertTrue(self.plugin_info.plugin_object.is_activated)
        self.pluginManager.deactivatePluginByName(self.plugin_info.name,
                                                  self.plugin_info.category)
        # check that activating the plugin once again, won't cause an error
        self.pluginManager.activatePluginByName(self.plugin_info.name,
                                                self.plugin_info.category)
        # Will be used later
        self.plugin_info = None
class ConfigurablePMWithDefaultChangeTriggerTestCase(unittest.TestCase, ConfigTestMixin):
	"""Test the correctness of default values of args specific to the
	ConfigurablePM in its construtor.
	"""
	
	def setUp(self):
		"""
		init
		"""
		# create a config file
		self.config_parser = ConfigParser()
		self.plugin_info = None
		# create the plugin manager
		self.pluginManager = ConfigurablePluginManager(
			directories_list=[os.path.join(
					os.path.dirname(os.path.abspath(__file__)),"plugins")],
			plugin_info_ext="yapsy-config-plugin",
			configparser_instance=self.config_parser)
		# load the plugins that may be found
		self.pluginManager.collectPlugins()

	def testPluginOptions(self):
		"""
		Test is the plugin can register and access options from the
		ConfigParser.
		"""
		self.plugin_activate()
		plugin = self.plugin_info.plugin_object
		plugin.choseTestOption("voila")
		self.assertTrue(plugin.checkTestOption())
		self.assertEqual(plugin.getTestOption(),"voila")
예제 #3
0
    def init_plugin_manager(self):
        # Configuring plugin locator
        plugin_locator = PluginFileLocator()
        plugin_locator.setPluginPlaces(PLUGIN_PLACES)

        # Initializing plugin manager...
        # categories_filter={"Default": IPlugin, "Custom": ICustomPlugin},
        self._plmanager = PluginManager(
            categories_filter={"Default": IAlgorithmPlugin},
            plugin_locator=plugin_locator)

        # decorate plugin manager with configurable feature
        self._cpmanager = ConfigurablePluginManager(
            decorated_manager=self._plmanager)

        # create parser for config file
        config_parser = ConfigParser()

        # set config file location
        config_parser.read(get_config_file_path())

        # set parser to configurable decorator
        self._cpmanager.setConfigParser(
            configparser_instance=config_parser,
            config_change_trigger=config_change_trigger)

        # plugin_manager.collectPlugins()
        # configurable_plugin_manager.loadPlugins()
        self._cpmanager.collectPlugins()

        self.plugins_info()

        for plugin_info in self._plmanager.getAllPlugins():
            if plugin_info.is_activated:
                plugin_info.plugin_object.set_image_manager(self._immanager)
예제 #4
0
class ConfigurablePMWithDefaultChangeTriggerTestCase(unittest.TestCase,
                                                     ConfigTestMixin):
    """Test the correctness of default values of args specific to the
	ConfigurablePM in its construtor.
	"""
    def setUp(self):
        """
		init
		"""
        # create a config file
        self.config_parser = ConfigParser()
        self.plugin_info = None
        # create the plugin manager
        self.pluginManager = ConfigurablePluginManager(
            directories_list=[
                os.path.join(os.path.dirname(os.path.abspath(__file__)),
                             "plugins")
            ],
            plugin_info_ext="yapsy-config-plugin",
            configparser_instance=self.config_parser)
        # load the plugins that may be found
        self.pluginManager.collectPlugins()

    def testPluginOptions(self):
        """
		Test is the plugin can register and access options from the
		ConfigParser.
		"""
        self.plugin_activate()
        plugin = self.plugin_info.plugin_object
        plugin.choseTestOption("voila")
        self.assertTrue(plugin.checkTestOption())
        self.assertEqual(plugin.getTestOption(), "voila")
예제 #5
0
    def __init__(self, bus: Bus, config: Config, graph: Graph):
        self._bus = bus
        self._graph = graph

        logger.debug("action=init paths=%s", config.plugin_paths())
        self._plugin_manager = ConfigurablePluginManager(
            decorated_manager=VersionedPluginManager())
        self._plugin_manager.setPluginPlaces(config.plugin_paths())
        self._plugin_manager.setPluginInfoExtension("plugin")
        self._plugin_manager.setConfigParser(config.parser, config.save)
예제 #6
0
	def testConfigurationFileExistence(self):
		"""
		Test if the configuration file has been properly written.
		"""
		# activate the only loaded plugin
		self.plugin_activate()
		# get rid of the plugin manager and create a new one
		del self.pluginManager
		del self.config_parser
		self.config_parser = ConfigParser()
		self.config_parser.read(self.config_file)
		self.assertTrue(self.config_parser.has_section("Plugin Management"))
		self.assertTrue(self.config_parser.has_option("Plugin Management", 
												   "default_plugins_to_load"))
		self.pluginManager = ConfigurablePluginManager(
			directories_list=[os.path.join(
					os.path.dirname(os.path.abspath(__file__)),"plugins")],
			plugin_info_ext="yapsy-config-plugin",
			configparser_instance=self.config_parser,
			config_change_trigger=self.update_config)
		self.pluginManager.collectPlugins()
		self.plugin_loading_check()
		self.assertTrue(self.plugin_info.plugin_object.is_activated)
		self.pluginManager.deactivatePluginByName(self.plugin_info.name,
												  self.plugin_info.category)
		# check that activating the plugin once again, won't cause an error
		self.pluginManager.activatePluginByName(self.plugin_info.name,
												self.plugin_info.category)
		# Will be used later
		self.plugin_info = None
예제 #7
0
 def activatePlugin(self, pluginInfo, save_state=True, checkDependencies=True):
     from lunchinator.utilities import handleMissingDependencies
     from lunchinator import get_server
     
     if checkDependencies:
         missing = self.checkActivation([pluginInfo])
         result = handleMissingDependencies(missing)
         if result == INSTALL_FAIL:
             # maybe there were dependencies installed, better re-check
             missing = self.checkActivation([pluginInfo])
             if missing:
                 self._logCannotLoad(pluginInfo, missing)
                 get_notification_center().emitPluginDeactivated(pluginInfo.name, pluginInfo.category)
                 return
         elif result == INSTALL_CANCEL:
             # user chose not to install -> deactivate
             get_notification_center().emitPluginDeactivated(pluginInfo.name, pluginInfo.category)
             self._deactivateMissing(missing)
             return
         elif result in (INSTALL_SUCCESS, INSTALL_IGNORE):
             missing = {}
         elif result == INSTALL_RESTART:
             # store that the plugin is activated now
             self.__addPluginToConfig(pluginInfo.category, pluginInfo.name)
             return
     
     getCoreLogger().info("Activating plugin '%s' of type '%s'", pluginInfo.name, pluginInfo.category)
     try:
         pluginInfo.plugin_object.setPluginName(pluginInfo.name)
         result = ConfigurablePluginManager.activatePluginByName(self, pluginInfo.name, category_name=pluginInfo.category, save_state=save_state)
         if self._emitSignals and result != None:
             get_notification_center().emitPluginActivated(pluginInfo.name, pluginInfo.category)
     except:
         getCoreLogger().exception("Error activating plugin '%s' of type '%s'", pluginInfo.name, pluginInfo.category)
예제 #8
0
	def setUp(self):
		"""
		init
		"""
		# create a config file
 		self.config_file = self.CONFIG_FILE
		self.config_parser = ConfigParser.SafeConfigParser()
		self.plugin_info = None
		# create the plugin manager
		self.pluginManager = ConfigurablePluginManager(
			directories_list=[os.path.join(
					os.path.dirname(os.path.abspath(__file__)),"plugins")],
			plugin_info_ext="yapsy-config-plugin",
			configparser_instance=self.config_parser,
			config_change_trigger=self.update_config)
		# load the plugins that may be found
		self.pluginManager.collectPlugins()
예제 #9
0
	def testConfigurationFileExistence(self):
		"""
		Test if the configuration file has been properly written.
		"""
		# activate the only loaded plugin
		self.plugin_activate()
		# get rid of the plugin manager and create a new one
		del self.pluginManager
		del self.config_parser
		self.config_parser = ConfigParser.SafeConfigParser()
		self.config_parser.read(self.config_file)
		self.assert_(self.config_parser.has_section("Plugin Management"))
		self.assert_(self.config_parser.has_option("Plugin Management", 
												   "default_plugins_to_load"))
		self.pluginManager = ConfigurablePluginManager(
			directories_list=[os.path.join(
					os.path.dirname(os.path.abspath(__file__)),"plugins")],
			plugin_info_ext="yapsy-config-plugin",
			configparser_instance=self.config_parser,
			config_change_trigger=self.update_config)
		# Will be used later
		self.plugin_info = None
예제 #10
0
	def setUp(self):
		"""
		init
		"""
		# create a config file
		self.config_parser = ConfigParser()
		self.plugin_info = None
		# create the plugin manager
		self.pluginManager = ConfigurablePluginManager(
			directories_list=[os.path.join(
					os.path.dirname(os.path.abspath(__file__)),"plugins")],
			plugin_info_ext="yapsy-config-plugin",
			configparser_instance=self.config_parser)
		# load the plugins that may be found
		self.pluginManager.collectPlugins()
예제 #11
0
 def deactivatePlugins(self, pluginInfos, save_state=True):
     # first, unload regular plugins (no database, no force activation)
     # second, also unload force activated non-db plugins
     # last, unload db plugins
     unloadFirst = []
     unloadSecond = []
     unloadThird = []
     for pluginInfo in pluginInfos:
         if pluginInfo is None or not pluginInfo.plugin_object.is_activated:
             continue
         if pluginInfo.category == "db":
             unloadThird.append(pluginInfo)
         elif pluginInfo.plugin_object.force_activation:
             unloadSecond.append(pluginInfo)
         else:
             unloadFirst.append(pluginInfo)
             
     for piList in (unloadFirst, unloadSecond, unloadThird):
         # first, inform about deactivation
         for pluginInfo in piList:
             getCoreLogger().info("Preparing to deactivate plugin '%s' of type '%s'", pluginInfo.name, pluginInfo.category)
             try:
                 # this is a direct connection, exception will be propagated here
                 get_notification_center().emitPluginWillBeDeactivated(pluginInfo.name, pluginInfo.category)
             except:
                 getCoreLogger().exception("An error occured while deactivating %s", pluginInfo.name)
                     
         # then deactivate plugins
         for pluginInfo in piList:
             getCoreLogger().info("Deactivating plugin '%s' of type '%s'", pluginInfo.name, pluginInfo.category)
             try:
                 result = ConfigurablePluginManager.deactivatePluginByName(self, pluginInfo.name, category_name=pluginInfo.category, save_state=save_state)
                 if self._emitSignals and result != None:
                     get_notification_center().emitPluginDeactivated(pluginInfo.name, pluginInfo.category)
             except:
                 getCoreLogger().exception("An error occured while deactivating plugin '%s' of type '%s'", pluginInfo.name, pluginInfo.category)
예제 #12
0
class ConfigTestCase(unittest.TestCase):
	"""
	Test the correct loading of a plugin that uses a configuration
	file through a ConfigurablePluginManager as well as basic
	commands.
	"""

	CONFIG_FILE = test_settings.TEMP_CONFIG_FILE_NAME
	
	def setUp(self):
		"""
		init
		"""
		# create a config file
		self.config_file = self.CONFIG_FILE
		self.config_parser = ConfigParser()
		self.plugin_info = None
		# create the plugin manager
		self.pluginManager = ConfigurablePluginManager(
			directories_list=[os.path.join(
					os.path.dirname(os.path.abspath(__file__)),"plugins")],
			plugin_info_ext="yapsy-config-plugin",
			configparser_instance=self.config_parser,
			config_change_trigger=self.update_config)
		# load the plugins that may be found
		self.pluginManager.collectPlugins()

	def tearDown(self):
		"""
		When the test has been performed erase the temp file.
		"""
		if os.path.isfile(self.config_file):
			os.remove(self.config_file)

	def testConfigurationFileExistence(self):
		"""
		Test if the configuration file has been properly written.
		"""
		# activate the only loaded plugin
		self.plugin_activate()
		# get rid of the plugin manager and create a new one
		del self.pluginManager
		del self.config_parser
		self.config_parser = ConfigParser()
		self.config_parser.read(self.config_file)
		self.assertTrue(self.config_parser.has_section("Plugin Management"))
		self.assertTrue(self.config_parser.has_option("Plugin Management", 
												   "default_plugins_to_load"))
		self.pluginManager = ConfigurablePluginManager(
			directories_list=[os.path.join(
					os.path.dirname(os.path.abspath(__file__)),"plugins")],
			plugin_info_ext="yapsy-config-plugin",
			configparser_instance=self.config_parser,
			config_change_trigger=self.update_config)
		self.pluginManager.collectPlugins()
		self.plugin_loading_check()
		self.assertTrue(self.plugin_info.plugin_object.is_activated)
		self.pluginManager.deactivatePluginByName(self.plugin_info.name,
												  self.plugin_info.category)
		# check that activating the plugin once again, won't cause an error
		self.pluginManager.activatePluginByName(self.plugin_info.name,
												self.plugin_info.category)
		# Will be used later
		self.plugin_info = None


	def testLoaded(self):
		"""
		Test if the correct plugin has been loaded.
		"""
		self.plugin_loading_check()
		
	def testActivationAndDeactivation(self):
		"""
		Test if the activation/deactivaion procedures work.
		"""
		self.plugin_activate()
		self.pluginManager.deactivatePluginByName(self.plugin_info.name,
												  self.plugin_info.category)
		self.assertTrue(not self.plugin_info.plugin_object.is_activated)

	def testPluginOptions(self):
		"""
		Test is the plugin can register and access options from the
		ConfigParser.
		"""
		self.plugin_activate()
		plugin = self.plugin_info.plugin_object
		plugin.choseTestOption("voila")
		self.assertTrue(plugin.checkTestOption())
		self.assertEqual(plugin.getTestOption(),"voila")


	#--- UTILITIES

	def plugin_loading_check(self):
		"""
		Test if the correct plugin has been loaded.
		"""
		if self.plugin_info is None:
			# check nb of categories
			self.assertEqual(len(self.pluginManager.getCategories()),1)
			sole_category = self.pluginManager.getCategories()[0]
			# check the number of plugins
			self.assertEqual(len(self.pluginManager.getPluginsOfCategory(sole_category)),1)
			self.plugin_info = self.pluginManager.getPluginsOfCategory(sole_category)[0]
			# test that the name of the plugin has been correctly defined
			self.assertEqual(self.plugin_info.name,"Config Plugin")
			self.assertEqual(sole_category,self.plugin_info.category)
		else:
			self.assertTrue(True)
		
	def plugin_activate(self):
		"""
		Activate the plugin with basic checking
		"""
		self.plugin_loading_check()
		self.assertTrue(not self.plugin_info.plugin_object.is_activated)
		self.pluginManager.activatePluginByName(self.plugin_info.name,
												self.plugin_info.category)
		self.assertTrue(self.plugin_info.plugin_object.is_activated)
		

	def update_config(self):
		"""
		Write the content of the ConfigParser in a file.
		"""
		cf = open(self.config_file,"a")
		self.config_parser.write(cf)
		cf.close()
예제 #13
0
class ConfigTestCase(unittest.TestCase):
	"""
	Test the correct loading of a plugin that uses a configuration
	file through a ConfigurablePluginManager as well as basic
	commands.
	"""

	CONFIG_FILE = test_settings.TEMP_CONFIG_FILE_NAME
	
	def setUp(self):
		"""
		init
		"""
		# create a config file
 		self.config_file = self.CONFIG_FILE
		self.config_parser = ConfigParser.SafeConfigParser()
		self.plugin_info = None
		# create the plugin manager
		self.pluginManager = ConfigurablePluginManager(
			directories_list=[os.path.join(
					os.path.dirname(os.path.abspath(__file__)),"plugins")],
			plugin_info_ext="yapsy-config-plugin",
			configparser_instance=self.config_parser,
			config_change_trigger=self.update_config)
		# load the plugins that may be found
		self.pluginManager.collectPlugins()

	def tearDown(self):
		"""
		When the test has been performed erase the temp file.
		"""
		if os.path.isfile(self.config_file):
			os.remove(self.config_file)

	def testConfigurationFileExistence(self):
		"""
		Test if the configuration file has been properly written.
		"""
		# activate the only loaded plugin
		self.plugin_activate()
		# get rid of the plugin manager and create a new one
		del self.pluginManager
		del self.config_parser
		self.config_parser = ConfigParser.SafeConfigParser()
		self.config_parser.read(self.config_file)
		self.assert_(self.config_parser.has_section("Plugin Management"))
		self.assert_(self.config_parser.has_option("Plugin Management", 
												   "default_plugins_to_load"))
		self.pluginManager = ConfigurablePluginManager(
			directories_list=[os.path.join(
					os.path.dirname(os.path.abspath(__file__)),"plugins")],
			plugin_info_ext="yapsy-config-plugin",
			configparser_instance=self.config_parser,
			config_change_trigger=self.update_config)
		# Will be used later
		self.plugin_info = None


	def testLoaded(self):
		"""
		Test if the correct plugin has been loaded.
		"""
		self.plugin_loading_check()
		
	def testActivationAndDeactivation(self):
		"""
		Test if the activation/deactivaion procedures work.
		"""
		self.plugin_activate()
		self.pluginManager.deactivatePluginByName(self.plugin_info.name,
												  self.plugin_info.category)
		self.assert_(not self.plugin_info.plugin_object.is_activated)

	def testPluginOptions(self):
		"""
		Test is the plugin can register and access options from the
		ConfigParser.
		"""
		self.plugin_activate()
		plugin = self.plugin_info.plugin_object
		plugin.choseTestOption("voila")
		self.assert_(plugin.checkTestOption())
		self.assertEqual(plugin.getTestOption(),"voila")


	#--- UTILITIES

	def plugin_loading_check(self):
		"""
		Test if the correct plugin has been loaded.
		"""
		if self.plugin_info is None:
			# check nb of categories
			self.assertEqual(len(self.pluginManager.getCategories()),1)
			sole_category = self.pluginManager.getCategories()[0]
			# check the number of plugins
			self.assertEqual(len(self.pluginManager.getPluginsOfCategory(sole_category)),1)
			self.plugin_info = self.pluginManager.getPluginsOfCategory(sole_category)[0]
			# test that the name of the plugin has been correctly defined
			self.assertEqual(self.plugin_info.name,"Config Plugin")
			self.assertEqual(sole_category,self.plugin_info.category)
		else:
			self.assert_(True)
		
	def plugin_activate(self):
		"""
		Activate the plugin with basic checking
		"""
		self.plugin_loading_check()
		self.assert_(not self.plugin_info.plugin_object.is_activated)
		self.pluginManager.activatePluginByName(self.plugin_info.name,
												self.plugin_info.category)
		self.assert_(self.plugin_info.plugin_object.is_activated)
		

	def update_config(self):
		"""
		Write the content of the ConfigParser in a file.
		"""
		cf = open(self.config_file,"a")
		self.config_parser.write(cf)
		cf.close()
예제 #14
0
class PluginEngine:
    @inject(bus="tomate.bus", config="tomate.config", graph=Graph)
    def __init__(self, bus: Bus, config: Config, graph: Graph):
        self._bus = bus
        self._graph = graph

        logger.debug("action=init paths=%s", config.plugin_paths())
        self._plugin_manager = ConfigurablePluginManager(
            decorated_manager=VersionedPluginManager())
        self._plugin_manager.setPluginPlaces(config.plugin_paths())
        self._plugin_manager.setPluginInfoExtension("plugin")
        self._plugin_manager.setConfigParser(config.parser, config.save)

    def collect(self) -> None:
        logger.debug("action=collect")
        self._plugin_manager.locatePlugins()
        self._plugin_manager.loadPlugins(callback_after=self._configure_plugin)

    def _configure_plugin(self, plugin: PluginInfo) -> None:
        if plugin.error is None:
            plugin.plugin_object.configure(self._bus, self._graph)

    def deactivate(self, name: str) -> None:
        self._plugin_manager.deactivatePluginByName(name)

    def activate(self, name: str) -> None:
        self._plugin_manager.activatePluginByName(name)

    def all(self) -> List[PluginInfo]:
        logger.debug("action=all")
        return sorted(self._plugin_manager.getAllPlugins(),
                      key=lambda info: info.name)

    def lookup(self, name: str, category="Default") -> Optional[PluginInfo]:
        logger.debug("action=lookup name=%s category=%s", name, category)
        return self._plugin_manager.getPluginByName(name, category)

    def has_plugins(self) -> bool:
        has = len(self.all()) > 0
        logger.debug("action=has_plugin has=%s", has)
        return has

    def remove(self, plugin: object, category="Default") -> None:
        self._plugin_manager.removePluginFromCategory(plugin, category)
예제 #15
0
class AlgorithmsManager(QObject):
    def __init__(self, imanager):
        QObject.__init__(self)
        self._plmanager = None
        self._cpmanager = None
        self._immanager = imanager
        self._algorithms = []
        self._algolist = dict()
        self._menu = QMenu(_("Algorithms"))
        self.init_plugin_manager()
        self.get_actions()
        self.get_widgets()
        self._databases = dict()
        pass

    def databases_list(self):
        return self._databases.keys()

    def database_settings(self, name, settings_type):
        return self._databases.get(name)

    def algorithms_menu(self):
        return self._menu

    def algorithms_settings(self):
        return self._algorithms

    def algorithms_list(self):
        return self._algolist.keys()

    def get_actions(self):
        for plugin_info in self._plmanager.getAllPlugins():
            if plugin_info.is_activated:
                actions = plugin_info.plugin_object.get_algorithms_actions(
                    self._menu)
                for action in actions:
                    if action and isinstance(action, QAction):
                        self._menu.addAction(action)
                    if action and isinstance(action, QMenu):
                        self._menu.addMenu(action)
                algo_list = plugin_info.plugin_object.get_algorithms_list()
                for algo in algo_list:
                    self._algolist[algo] = plugin_info.plugin_object

    def get_widgets(self):
        for plugin_info in self._plmanager.getAllPlugins():
            if plugin_info.is_activated:
                widgets = plugin_info.plugin_object.get_interfaces()
                if widgets:
                    for widget in widgets:
                        if widget:
                            self._algorithms.append(widget)

    def algosettings(self, name):
        plugin = self._algolist.get(name)
        if plugin is not None:
            return plugin.settings(name)
        return None

    def apply_algorithm(self, name, settings=dict()):
        plugin = self._algolist.get(name)
        if plugin is not None:
            return plugin.apply(name, settings)
        return None

    def init_plugin_manager(self):
        # Configuring plugin locator
        plugin_locator = PluginFileLocator()
        plugin_locator.setPluginPlaces(PLUGIN_PLACES)

        # Initializing plugin manager...
        # categories_filter={"Default": IPlugin, "Custom": ICustomPlugin},
        self._plmanager = PluginManager(
            categories_filter={"Default": IAlgorithmPlugin},
            plugin_locator=plugin_locator)

        # decorate plugin manager with configurable feature
        self._cpmanager = ConfigurablePluginManager(
            decorated_manager=self._plmanager)

        # create parser for config file
        config_parser = ConfigParser()

        # set config file location
        config_parser.read(get_config_file_path())

        # set parser to configurable decorator
        self._cpmanager.setConfigParser(
            configparser_instance=config_parser,
            config_change_trigger=config_change_trigger)

        # plugin_manager.collectPlugins()
        # configurable_plugin_manager.loadPlugins()
        self._cpmanager.collectPlugins()

        self.plugins_info()

        for plugin_info in self._plmanager.getAllPlugins():
            if plugin_info.is_activated:
                plugin_info.plugin_object.set_image_manager(self._immanager)

    def plugins_info(self):
        # Output of various information and activation of each plugin
        for plugin_info in self._plmanager.getAllPlugins():
            print "Loading plugin '%s' ..." % plugin_info.name
            # configurable_plugin_manager.activatePluginByName(plugin_info.name)
            print "      name : %s" % plugin_info.name
            print "      path : %s" % plugin_info.path
            print "      version : %s" % plugin_info.version
            print "      author : %s" % plugin_info.author
            print "      copyright : %s" % plugin_info.copyright
            print "      website : %s" % plugin_info.website
            print "      description : %s" % plugin_info.description
            print "      details : %s" % plugin_info.details
            print "      is Activated : %s" % plugin_info.is_activated
            print "      categories : %s" % plugin_info.categories
            print "      plugin object : %s" % plugin_info.plugin_object
            print "      error : %s" % plugin_info.error