Returns the names of frontend-aware plugs.
352000
def get_frontend_aware_plug_names(self):
    """"""
    return [name for name, plug in six.iteritems(self._plugs_by_name)
            if isinstance(plug, FrontendAwareBasePlug)]
1227149
def _plugin_name(self, path):
        ""
        base = os.path.basename(path)
        name, ext = os.path.splitext(base)
        return name
516559
def get_stat_name(self, header=""):
        """""""
        ret = self.plugin_name
        if header != "":
            ret += '_' + header
        return ret
996474
def get_plug_mro(self, plug_type):
    
    ignored_classes = (BasePlug, FrontendAwareBasePlug)
    return [
        self.get_plug_name(base_class) for base_class in plug_type.mro()
        if (issubclass(base_class, BasePlug) and
            base_class not in ignored_classes)
    ]
825377
protected function collectPlugins() {
		$plugins = Configure::read('plugins');

		$names = array_keys($plugins);

		sort($names);

		return $names;
	}
489706
def get_flagged_names():
    """"""

    l = []
    for w in _widget_cache.values():
        if w.flagged:
            l.append(w.get_node().get_value())
    return l
1026999
def get_plugins() -> Dict[str, pkg_resources.EntryPoint]:
        
        return {entry.name: entry for entry in pkg_resources.iter_entry_points('unidown.plugin')}
216154
def plugins(self):
        
        from fluent_contents import extensions   # Avoid circular reference because __init__.py imports subfolders too
        if self._plugins is None:
            return extensions.plugin_pool.get_plugins()
        else:
            return extensions.plugin_pool.get_plugins_by_name(*self._plugins)
292426
def plugins(flags=None):
        
        XExporter.init()
        
        plugs = XExporter._plugins[:]
        if flags is not None:
            return filter(lambda x: x.testFlag(flags), plugs)
        return plugs
1016479
def _get_help_names(self):
        """"""
        # Determine the additional help topics, if any.
        help_names = {}
        token2cmdname = self._get_canonical_map()
        for attrname, attr in self._gen_names_and_attrs():
            if not attrname.startswith("help_"): continue
            help_name = attrname[5:]
            if help_name not in token2cmdname:
                help_names[help_name] = attr
        return help_names
683981
def GetNamesOfParsersWithPlugins(cls):
    
    parser_names = []

    for parser_name, parser_class in cls.GetParsers():
      if parser_class.SupportsPlugins():
        parser_names.append(parser_name)

    return sorted(parser_names)
511923
function resolvePluginsForBrowsers(browsers) {
  const plugins = [];

  if (!Array.isArray(browsers)) browsers = [browsers];

  browsers.forEach(browser => {
    const name = Object.keys(browser)[0];
    const version = browser[name];

    for (const pluginName in babelPluginsByEnvironmentVersion) {
      if (
        !babelPluginsByEnvironmentVersion[pluginName][name] ||
        babelPluginsByEnvironmentVersion[pluginName][name] > version
      ) {
        plugins.push(`babel-plugin-${pluginName}`);
      }
    }
  });

  return plugins;
}
707790
def get_plugins(cls, *args, **kwargs):
        
        return [plugin(*args, **kwargs) for plugin in cls.plugins]
1019171
def smartplugs(self):
        """"""
        return [SmartPlug(self, plug.get('name'))
                for plug in self._state.get('deviceStatusInfo',
                                            {}).get('device', [])
                if plug.get('networkHealthState')]
1056157
def get_enabled_plugins():
    '''
    
    '''
    plugins = entrypoints.get_enabled('udata.preview', current_app).values()
    valid = [p for p in plugins if issubclass(p, PreviewPlugin)]
    for plugin in plugins:
        if plugin not in valid:
            clsname = plugin.__name__
            msg = '{0} is not a valid preview plugin'.format(clsname)
            warnings.warn(msg, PreviewWarning)
    return [p() for p in sorted(valid, key=lambda p: 1 if p.fallback else 0)]
577615
def get_plugins_by_feature(features):
    
    if not features:
        return get_all_plugins()
    plugins = PluginLoader.load_all().items()
    names = set([f.__name__ for f in features])
    return [e for e, plugin in plugins if names & set(plugin.__dict__.keys())]
332362
def _default_plugins(self):
        
        plugins = {}
        try:
            with open('entry_points.json') as f:
                entry_points = json.load(f)
            for ep, obj in entry_points.items():
                plugins[ep] = []
                for name, src in obj.items():
                    plugins[ep].append(Plugin(name=name, source=src))
        except Exception as e:
            print("Failed to load entry points {}".format(e))
        return plugins