Ejemplo n.º 1
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)
Ejemplo n.º 2
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