Python PluginManager.activatePluginByName方法代码示例

# 需要导入模块: from yapsy.PluginManager import PluginManager [as 别名]
# 或者: from yapsy.PluginManager.PluginManager import activatePluginByName [as 别名]
def run():
    logging.basicConfig(level=logging.INFO)

    os.chdir('/home/mjolnir/git/PURIKURA')

    # H A N D L E  P L U G I N S
    pm = PluginManager()
    pm.setPluginPlaces(['./pyrikura/plugins'])
    pm.collectPlugins()

    for pi in pm.getAllPlugins():
        logging.info('loading plugin %s', pi.name)
        pm.activatePluginByName(pi.name)

    brokers = {}
    nodes = build()
    head = nodes[0]

    for node in nodes:
        brokers[node] = node.load(pm)

    for node, broker in brokers.items():
        for other in node._listening:
            broker.subscribe(brokers[other])

    start = time.time()
    last_time = 0
    shots = 0
    last_trigger = 0
    for broker in itertools.cycle(brokers.values()):
        broker.update()

# 需要导入模块: from yapsy.PluginManager import PluginManager [as 别名]
# 或者: from yapsy.PluginManager.PluginManager import activatePluginByName [as 别名]
class AlgorithmManager():
    def __init__(self):
        self._pluginManager = PluginManager()
        self._pluginManager.setPluginPlaces(config.PLUGIN_DIR)
        self._pluginManager.collectPlugins()
        for pluginInfo in self._pluginManager.getAllPlugins():
            self._pluginManager.activatePluginByName(pluginInfo.name)
            
    def get_alg_names(self):
        for plugin in self._pluginManager.getAllPlugins():
            plugin.plugin_object.print_name()
            
    def execute_calc(self, data):
        run = []
        if not self.__is_sequence(data):
            raise Exception('Data is no array!')
        for alg in self._pluginManager.getAllPlugins():
            result, prop = alg.plugin_object.calc(data)
            run.append({alg.name : (result, prop)})
        return run

    
    def __is_sequence(self, arg):
        return (not hasattr(arg, "strip") and
            hasattr(arg, "__getitem__") or
            hasattr(arg, "__iter__"))
                 
    
        

# 需要导入模块: from yapsy.PluginManager import PluginManager [as 别名]
# 或者: from yapsy.PluginManager.PluginManager import activatePluginByName [as 别名]
def main():
    # Read configuration
    config = SafeConfigParser(
        defaults = {'port':'15915',
                    'plugins_directory':'./plugins',
                    'plugins_enabled':'',
                   })
    config.read(['./conf/cm15d.conf',
                 '/etc/cm15d.conf',
                 '/etc/cm15d/cm15d.conf',
                 '/etc/cm15d/conf.d/local.conf',
                ])

    # Activate enabled plugins
    plugins = PluginManager()
    plugins.setPluginPlaces(config.get('cm15d', 'plugins_directory').split(','))
    plugins.collectPlugins()
    plugins_enabled = config.get('cm15d', 'plugins_enabled').split(',')

    for plugin in plugins.getAllPlugins():
        if plugin.name in plugins_enabled:
            plugins.activatePluginByName(plugin.name)
            print("Plugin %s enabled" % plugin.name)

    # Start server
    port = int(config.get('cm15d', 'port'))
    endpoint = TCP4ServerEndpoint(reactor, port)
    endpoint.listen(CM15DaemonFactory(plugins))
    print("Server listening on port %s" % port)
    reactor.run()

# 需要导入模块: from yapsy.PluginManager import PluginManager [as 别名]
# 或者: from yapsy.PluginManager.PluginManager import activatePluginByName [as 别名]
def get_plugins():
 
    plugin_analyzer = PluginFileAnalyzerWithInfoFile(name="torrentstausanalyzer", extensions="plugin-manifest")
    plugin_locator = PluginFileLocator(analyzers=[plugin_analyzer])

    extra_plugins_dir = config.getSettingsAsDict()["extra_plugins_dir"]
    plugin_extras = os.path.join(get_config_dir(), extra_plugins_dir)

    directories = [os.path.join(os.path.dirname(os.path.realpath(__file__)), "plugins")]

    ##
    ## Allow user defined plugins
    ## These plugins should be named as
    ## name.function.{py, plugin-manifest}
    ## Example:
    ## MyPlugin.onstart.py
    ## MyPlguin.onstart.plugin-manifest
    ##
    if os.path.exists(plugin_extras):
        directories.append(plugin_extras)

    manager = PluginManager(directories_list=directories, plugin_locator=plugin_locator)
    manager.collectPlugins()
    plugins = manager.getAllPlugins()

    # Activate all loaded plugins
    for pluginInfo in plugins:
        manager.activatePluginByName(pluginInfo.name)
    return plugins

# 需要导入模块: from yapsy.PluginManager import PluginManager [as 别名]
# 或者: from yapsy.PluginManager.PluginManager import activatePluginByName [as 别名]
def loadPlugins(root_folder, plugin_name, categories_filter):
  from yapsy.PluginManager import PluginManager

  plugin_dirs = []
  plugin_dirs.append(configuration.fabfile_basedir + '/.fabalicious/plugins')
  plugin_dirs.append(expanduser("~") + '/.fabalicious/plugins')
  plugin_dirs.append(root_folder + '/plugins')

  log.debug("Looking for %s-plugins in %s" % (plugin_name, ", ".join(plugin_dirs)))

  manager = PluginManager()
  manager.setPluginPlaces(plugin_dirs)
  manager.setCategoriesFilter(categories_filter)
  manager.collectPlugins()

  # Activate all loaded plugins
  for pluginInfo in manager.getAllPlugins():
    manager.activatePluginByName(pluginInfo.name)

  result = {}
  for plugin in manager.getAllPlugins():

    if hasattr(plugin.plugin_object, 'aliases') and isinstance(plugin.plugin_object.aliases, list):
      for alias in plugin.plugin_object.aliases:
        result[alias] = plugin.plugin_object
    elif hasattr(plugin.plugin_object, 'alias'):
      result[plugin.plugin_object.alias] = plugin.plugin_object
    else:
      result[plugin.name] = plugin.plugin_object
  return result

# 需要导入模块: from yapsy.PluginManager import PluginManager [as 别名]
# 或者: from yapsy.PluginManager.PluginManager import activatePluginByName [as 别名]
class PluginHandler:
    def __init__(self):
        self._plugin_manager = PluginManager()
        self._category_active = {"Modifier": False, "Analyzer": False, "Comparator": False}
        self._plugin_from_category = {"Modifier": [], "Analyzer": [], "Comparator": []}
        self._modifier_plugins = []
        self._analyzer_plugins = []
        self._collect_all_plugins()

    def _collect_all_plugins(self):
        self._plugin_manager.setPluginPlaces(
            ["hugin/analyze/modifier", "hugin/analyze/analyzer", "hugin/analyze/comparator"]
        )

        # setting filter categories for pluginmanager
        self._plugin_manager.setCategoriesFilter(
            {
                # movie metadata provider
                "Modifier": IModifier,
                # movie metadata provider
                "Comparator": IComparator,
                # sub metadata provider
                "Analyzer": IAnalyzer,
            }
        )
        self._plugin_manager.collectPlugins()

    def activate_plugins_by_category(self, category):
        self._toggle_activate_plugins_by_category(category)

    def deactivate_plugins_by_category(self, category):
        self._toggle_activate_plugins_by_category(category)

    def _toggle_activate_plugins_by_category(self, category):
        plugins = self._plugin_manager.getPluginsOfCategory(category)
        is_active = self._category_active[category]
        for pluginInfo in plugins:
            if is_active:
                self._plugin_manager.deactivatePluginByName(name=pluginInfo.name, category=category)
                self._plugin_from_category[category].remove(pluginInfo)
            else:
                self._plugin_manager.activatePluginByName(name=pluginInfo.name, category=category)
                self._plugin_from_category[category].append(pluginInfo)
        self._category_active[category] = not is_active

    def get_plugins_from_category(self, category):
        plugins = []
        for plugin in self._plugin_from_category[category]:
            plugin.plugin_object.name = plugin.name
            plugin.plugin_object.description = plugin.description
            plugins.append(plugin.plugin_object)
        return plugins

    def is_activated(self, category):
        """ True if category is activated. """
        return self._category_active[category]

# 需要导入模块: from yapsy.PluginManager import PluginManager [as 别名]
# 或者: from yapsy.PluginManager.PluginManager import activatePluginByName [as 别名]
    def __init__(self, manager=None, name=None):
        """
        Create the plugin object

        :param manager: Manager instance
        :type manager: :class:`biomajmanager.manager.Manager`
        :param name: Name of the plugin to load. [DEFAULT: load all plugins]
        :type name: String
        :raises SystemExit: If 'manager' arg is not given
        :raises SystemExit: If 'PLUGINS' section not found in :py:data:`manager.properties`
        :raises SystemExit: If 'plugins.dir' not set in :py:data:`manager.properties`
        :raises SystemExit: If 'plugins.list' not set in :py:data:`manager.properties`
        :raises SystemExit: If 'plugins.dir' does not exist
        """
        self.pm = None
        self.name = None
        self.config = None
        self.manager = None
        if not manager:
            Utils.error("'manager' is required")
        self.manager = manager
        self.config = self.manager.config

        if not self.config.has_section('PLUGINS'):
            Utils.error("Can't load plugins, no section found!")
        if not self.config.has_option('MANAGER', 'plugins.dir'):
            Utils.error("plugins.dir not defined!")
        if not self.config.has_option('PLUGINS', 'plugins.list'):
            Utils.error("plugins.list is not defined!")

        if not os.path.isdir(self.config.get('MANAGER', 'plugins.dir')):
            Utils.error("Can't find plugins.dir")
        plugin_manager = PluginManager(directories_list=[self.config.get('MANAGER', 'plugins.dir')],
                                       categories_filter={Plugins.CATEGORY: BMPlugin})
        plugin_manager.collectPlugins()
        self.pm = plugin_manager
        self.name = name
        user_plugins = []

        # Load user wanted plugin(s)
        for plugin in self.config.get('PLUGINS', 'plugins.list').split(','):
            plugin.strip()
            # We need to lower the plugin name
            user_plugins.append(plugin)

        # This means that all plugins must inherits from BMPlugin
        for pluginInfo in plugin_manager.getPluginsOfCategory(Plugins.CATEGORY):
            Utils.verbose("[manager] plugin name => %s" % pluginInfo.name)
            if pluginInfo.name in user_plugins:
                if not pluginInfo.is_activated:
                    Utils.verbose("[manager] plugin %s activated" % pluginInfo.name)
                    plugin_manager.activatePluginByName(pluginInfo.name)
                setattr(self, pluginInfo.name, pluginInfo.plugin_object)
                pluginInfo.plugin_object.set_config(self.config)
                pluginInfo.plugin_object.set_manager(self.manager)

# 需要导入模块: from yapsy.PluginManager import PluginManager [as 别名]
# 或者: from yapsy.PluginManager.PluginManager import activatePluginByName [as 别名]
class MUCBot(sleekxmpp.ClientXMPP):

    def __init__(self, jid, password, room, nick):
        sleekxmpp.ClientXMPP.__init__(self, jid, password)

        self.room = room
        self.nick = nick

        # Load plugins
        self.plugin_manager = PluginManager()
        self.plugin_manager.setPluginPlaces(["plugins_enabled"])
        self.plugin_manager.setCategoriesFilter({
            "Message" : MessagePlugin,
            "Presence": PresencePlugin
        })
        self.plugin_manager.collectPlugins()
        # Activate all loaded plugins
        for pluginInfo in self.plugin_manager.getAllPlugins():
           self.plugin_manager.activatePluginByName(pluginInfo.name)

        self.add_event_handler("session_start", self.start)
        self.add_event_handler("message", self.message)
        self.add_event_handler("groupchat_message", self.muc_message)
        self.add_event_handler("muc::%s::got_online" % self.room, self.muc_online)
        self.add_event_handler("muc::%s::got_offline" % self.room, self.muc_offline)

    def start(self, event):
        self.get_roster()
        self.send_presence()
        if self.room and len(self.room) > 0:
            self.plugin['xep_0045'].joinMUC(self.room,
                                            self.nick,
                                            wait=True)

    def message(self, msg):
        if msg['type'] in ('chat', 'normal'):
            for pluginInfo in self.plugin_manager.getPluginsOfCategory("Message"):
                pluginInfo.plugin_object.message_received(msg)

    def muc_message(self, msg):
        if msg['mucnick'] != self.nick:
            for pluginInfo in self.plugin_manager.getPluginsOfCategory("Message"):
                pluginInfo.plugin_object.message_received(msg, nick=self.nick)

    def muc_online(self, presence):
        if presence['muc']['nick'] != self.nick:
            for pluginInfo in self.plugin_manager.getPluginsOfCategory("Presence"):
                pluginInfo.plugin_object.got_online(self, presence)

    def muc_offline(self, presence):
        if presence['muc']['nick'] != self.nick:
            for pluginInfo in self.plugin_manager.getPluginsOfCategory("Presence"):
                pluginInfo.plugin_object.got_offline(self, presence)

# 需要导入模块: from yapsy.PluginManager import PluginManager [as 别名]
# 或者: from yapsy.PluginManager.PluginManager import activatePluginByName [as 别名]
def main():
    fps = 30  # FPS for the generated video(s)
    set_size = 500  # Size for the sorting set

    # Parse the arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("-f", "--fps", help="The desired FPS of the video to be outputted.", type=int)
    parser.add_argument("-s", "--size", help="The desired size of the sorting set.", type=int)
    parser.add_argument("sorters", help="The sorters to run. Type 'all' to run all available sorters.")

    args = parser.parse_args()
    if args.fps:
        fps = args.fps
    if args.size:
        set_size = args.size

    # Get a manager
    plugin_manager = PluginManager()

    # Give it a folder to look in, sorters
    plugin_manager.setPluginPlaces(["sorters"])

    # Load 'em
    plugin_manager.collectPlugins()

    # TODO: Add flag for how many numbers it should sort

    # Activate 'em and run 'em
    for plugin in plugin_manager.getAllPlugins():
        if "all" not in sys.argv:
            if plugin.name not in sys.argv:
                continue
        plugin_manager.activatePluginByName(plugin.name)
        folder_name = plugin.name
        temp, _ = os.path.split(os.path.abspath(__file__))
        folder_path = os.path.join(temp, folder_name)
        try:
            os.makedirs(folder_path)
        except:
            shutil.rmtree(folder_name)  # Remove the folder, we're going to remake it
            os.makedirs(folder_path)
        a = range(set_size)
        shuffle(a)
        plot = Plotter()
        plugin.plugin_object.prepare(a, partial(plot.plot, folder_path))
        plugin.plugin_object.sort()
        create_movie(folder_name, plugin.plugin_object.counter, fps)

# 需要导入模块: from yapsy.PluginManager import PluginManager [as 别名]
# 或者: from yapsy.PluginManager.PluginManager import activatePluginByName [as 别名]
    def initialize_plugins(self):
        self.__log.info("Collecting and loading plugins")

        try:
            plugin_manager = PluginManager()
            # TODO: change plugin descriptor extensions, plugin_manager.setPluginInfoExtension(AGENT_PLUGIN_EXT)
            plugin_manager.setCategoriesFilter({
                CARTRIDGE_AGENT_PLUGIN: ICartridgeAgentPlugin,
                ARTIFACT_MGT_PLUGIN: IArtifactManagementPlugin
            })

            plugin_manager.setPluginPlaces([self.__config.read_property(constants.PLUGINS_DIR)])

            plugin_manager.collectPlugins()

            # activate cartridge agent plugins
            plugins = plugin_manager.getPluginsOfCategory(CARTRIDGE_AGENT_PLUGIN)
            grouped_plugins = {}
            for plugin_info in plugins:
                self.__log.debug("Found plugin [%s] at [%s]" % (plugin_info.name, plugin_info.path))
                plugin_manager.activatePluginByName(plugin_info.name)
                self.__log.info("Activated plugin [%s]" % plugin_info.name)

                mapped_events = plugin_info.description.split(",")
                for mapped_event in mapped_events:
                    if mapped_event.strip() != "":
                        if grouped_plugins.get(mapped_event) is None:
                            grouped_plugins[mapped_event] = []

                        grouped_plugins[mapped_event].append(plugin_info)

            # activate artifact management plugins
            artifact_mgt_plugins = plugin_manager.getPluginsOfCategory(ARTIFACT_MGT_PLUGIN)
            for plugin_info in artifact_mgt_plugins:
                self.__log.debug("Found artifact management plugin [%s] at [%s]" % (plugin_info.name, plugin_info.path))
                plugin_manager.activatePluginByName(plugin_info.name)
                self.__log.info("Activated artifact management plugin [%s]" % plugin_info.name)

            return plugin_manager, grouped_plugins, artifact_mgt_plugins
        except ParameterNotFoundException as e:
            self.__log.exception("Could not load plugins. Plugins directory not set: %s" % e)
            return None, None, None
        except Exception as e:
            self.__log.exception("Error while loading plugin: %s" % e)
            return None, None, None

# 需要导入模块: from yapsy.PluginManager import PluginManager [as 别名]
# 或者: from yapsy.PluginManager.PluginManager import activatePluginByName [as 别名]
    def _tryLoad(self, schema_name, num_colors):
        plugin_manager = PluginManager()
        plugin_manager.getPluginLocator().setPluginInfoExtension("ini")
        plugin_manager.setPluginPlaces([paths.pluginsDir("user", "syntaxcolors"), paths.pluginsDir("system", "syntaxcolors")])
        plugin_manager.collectPlugins()

        for plugin_info in plugin_manager.getAllPlugins():

            # Useless, but let's activate them
            plugin_manager.activatePluginByName(plugin_info.name)

            plugin_object = plugin_info.plugin_object
            if plugin_object.name() == schema_name and plugin_object.supportsNumColors(num_colors):

                self._color_map.update(_parseColorSchema(plugin_object.colorSchema(num_colors)))
                return True

        return False

# 需要导入模块: from yapsy.PluginManager import PluginManager [as 别名]
# 或者: from yapsy.PluginManager.PluginManager import activatePluginByName [as 别名]
def main(target_dir=None):
    if not target_dir:
        target_dir = os.path.abspath(os.curdir)

    user_config_dir = os.path.expanduser('~/.grumpy')
    user_config_path = os.path.join(user_config_dir, 'conf')

    user_plugin_base_dir = os.path.join(user_config_dir, 'plugins')
    user_plugin_dirs = None
    try:
        user_plugin_dirs = [os.path.join(user_plugin_base_dir, plugin_dir)
                            for plugin_dir in os.listdir(user_plugin_base_dir)]
    except FileNotFoundError:
        pass

    default_plugin_base_dir = os.path.join(os.path.dirname(__file__), "plugins")
    default_plugin_dirs = [os.path.join(default_plugin_base_dir, plugin_dir)
                           for plugin_dir in os.listdir(default_plugin_base_dir)]

    plugin_dirs = user_plugin_dirs + default_plugin_dirs

    print(plugin_dirs)

    conf = Configuration.parse_file(user_config_path)

    # Build the manager
    simplePluginManager = PluginManager()
    # Tell it the default place(s) where to find plugins
    simplePluginManager.setPluginPlaces(plugin_dirs)
    # Load all plugins
    simplePluginManager.collectPlugins()

    # Activate all loaded plugins
    for pluginInfo in simplePluginManager.getAllPlugins():
        simplePluginManager.activatePluginByName(pluginInfo.name)

    # pipeline = [simplePluginManager.getPluginByName(name).plugin_object.run for name in parse_pipeline(conf.get("Pipeline", "Default"))]

    # output = 0
    # output = reduce(lambda x,y: y(x), pipeline, output)
    # print(next(output))

    print(os.path.dirname(__file__))

# 需要导入模块: from yapsy.PluginManager import PluginManager [as 别名]
# 或者: from yapsy.PluginManager.PluginManager import activatePluginByName [as 别名]
class FakeNikola(object):
    def __init__(self):

        self.config = {'DISABLED_PLUGINS': []}
        self.debug = False
        self.loghandlers = []
        self.timeline = []
        self.plugin_manager = PluginManager(categories_filter={
            "Command": Command,
            "Task": Task,
            "LateTask": LateTask,
            "TemplateSystem": TemplateSystem,
            "PageCompiler": PageCompiler,
            "TaskMultiplier": TaskMultiplier,
            "RestExtension": RestExtension,
            "MarkdownExtension": MarkdownExtension,
            "SignalHandler": SignalHandler,
        })
        self.plugin_manager.setPluginInfoExtension('plugin')
        extra_plugins_dirs = ''
        places = [
                resource_filename('nikola', utils.sys_encode('plugins')),
                os.path.join(os.getcwd(), utils.sys_encode('plugins')),
                os.path.expanduser('~/.nikola/plugins'),
            ] + [utils.sys_encode(path) for path in extra_plugins_dirs if path]

        self.plugin_manager.setPluginPlaces(places)
        self.plugin_manager.collectPlugins()

        #self.pug = None
        #for plugin_info in self.plugin_manager.getPluginsOfCategory("PageCompiler"):
        #    if plugin_info.name == 'rest':
        #        self.plugin_manager.activatePluginByName(plugin_info.name)
        #        plugin_info.plugin_object.set_site(self)
        #        self.pug = plugin_info

        # Now we have our pug
        for plugin_info in self.plugin_manager.getPluginsOfCategory("RestExtension"):
            self.plugin_manager.activatePluginByName(plugin_info.name)
            plugin_info.plugin_object.set_site(self)
            plugin_info.plugin_object.short_help = plugin_info.description

# 需要导入模块: from yapsy.PluginManager import PluginManager [as 别名]
# 或者: from yapsy.PluginManager.PluginManager import activatePluginByName [as 别名]
class App(QtGui.QApplication):
    def __init__(self, argv):
        super(App, self).__init__(argv)
        parser = optparse.OptionParser()
        parser.add_option('-c', '--config', help='Path to a configuration', default='/etc/bonehead.cfg')
        (options, args) = parser.parse_args()

        logging.basicConfig(level=logging.DEBUG)

        self._conf = ConfigParser()
        self._conf.read(options.config)

        self._plugins = PluginManager()
        self._plugins.setPluginPlaces([
            '/usr/lib/bonehead/pages',
            './pages/'
        ])

        self._plugins.collectPlugins()

        for plugin in self._plugins.getAllPlugins():
            self._plugins.activatePluginByName(plugin.name)

        self.__ui = KioskUI()

        pages = self._conf.get('general', 'pages', []).split(',')
        for pageName in pages:
            pageConfig = {}
            for k,v in self._conf.items("page:%s"%(pageName)):
                pageConfig[k] = v
            pagePlugin = self._plugins.getPluginByName(pageConfig['plugin'])
            page = pagePlugin.plugin_object.newPage(pageName, pageConfig, self.__ui)
            self.__ui.addPage(page)

        self.__ui.showFullScreen()

    def notify(self, object, event):
        if event.type() == QtCore.QEvent.KeyPress or event.type() == QtCore.QEvent.MouseButtonPress:
            self.__ui.resetTimeout()
        return super(App, self).notify(object, event)

# 需要导入模块: from yapsy.PluginManager import PluginManager [as 别名]
# 或者: from yapsy.PluginManager.PluginManager import activatePluginByName [as 别名]
class CM15DaemonFactory(Factory):
    def buildProtocol(self, addr):
        return CM15Daemon(self)

    def startFactory(self):
        self.loadPlugins()
        self.cm15 = cm15.CM15()
        self.cm15.open()
        for plugin in self.pluginManager.getAllPlugins():
            self.cm15.subscribeToEvent("dataReceived", plugin.plugin_object.cm15DataReceivedHandler)
            self.cm15.subscribeToEvent("dataWritten", plugin.plugin_object.cm15DataWrittenHandler)
        self.cm15.startListening()

    def stopFactory(self):
        self.cm15.stopListening()
        self.cm15.close()

    def loadPlugins(self):
        self.pluginManager = PluginManager()
        self.pluginManager.setPluginPlaces(["./plugins"])
        self.pluginManager.collectPlugins()
        for plugin in self.pluginManager.getAllPlugins():
            self.pluginManager.activatePluginByName(plugin.name)