Print to the error console the plugins that are available without their corresponding extension point.
490839
public static void logRemainingPlugins() {
		Logger logger = LCCore.getApplication().getDefaultLogger();
		if (!logger.warn())
			return;
		synchronized (points) {
			for (Plugin pi : waitingPlugins)
				logger.warn("Plugin ignored because extension point is not loaded: " + pi.getClass().getName());
		}
	}
268184
def print_info(self):
        """"""
        
        d = dir(self)
        self.plugins = []
        for key in d:
            if key.startswith("info_"):
                self.plugins.append(key)

        for key in self.plugins:
            if self.echo:
                Console.ok("> {0}".format(key.replace("_", " ", 1)))
            exec("self.%s()" % key)
363014
void pluginMessage(Throwable ex) {
        log.printLines(PrefixKind.JAVAC, "msg.plugin.uncaught.exception");
        ex.printStackTrace(log.getWriter(WriterKind.NOTICE));
    }
1284203
function printWarning(context, kind, err)
{
	if (context !== null) {
		console.error('warn: %s: %s', context.label(), err.message);
	} else {
		console.error('warn: %s', err.message);
	}
}
480474
def get_plugin(name):
    """"""
    for plugin in IPluginRegistry.plugins:
        if name in plugin.__name__:
            return plugin
    raise ValueError("The plugin %s cannot be found." % name)
227964
def printUnusedImports(self):
        """"""
        for module in self.listModules():
            names = [(unused.lineno, unused.name)
                     for unused in module.unused_names]
            names.sort()
            for lineno, name in names:
                if not self.all_unused:
                    line = linecache.getline(module.filename, lineno)
                    if '#' in line:
                        # assume there's a comment explaining why it's not used
                        continue
                print("%s:%s: %s not used" % (module.filename, lineno, name))
523984
def get_plugin_modules(plugins):
    
    if not plugins:
        raise MissingPluginNames("input plugin names are required")

    modules = []

    for plugin in plugins:
        short_name = PLUGIN_MAPPING.get(plugin.lower(), plugin.lower())
        full_path = '%s%s' % (module_prefix, short_name)
        modules.append(importlib.import_module(full_path))

    return tuple(modules)
356962
private static void printHelp(final IPluginRepository pr, final String pluginName) {
        try {
            PluginProxy pp = (PluginProxy) pr.getPlugin(pluginName);

            // CPluginProxy pp =
            // CPluginFactory.getInstance().getPlugin(sPluginName);
            if (pp == null) {
                System.out.println("Plugin " + pluginName + " does not exists.");
            } else {
                pp.printHelp();
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.exit(0);
    }
321407
def unload_plugins(self, ):
        
        for p in self.__plugins.values():
            if p.is_loaded():
                try:
                    p._unload()
                    log.info('Uninitialized the plugin: %s' % p)
                except errors.PluginUninitError:
                    log.error('Uninitialization of the plugin: %s failed.' % p)
861892
def missing_fun_string(self, function_name):
        '''
        
        '''
        mod_name = function_name.split('.')[0]
        if mod_name in self.loaded_modules:
            return '\'{0}\' is not available.'.format(function_name)
        else:
            try:
                reason = self.missing_modules[mod_name]
            except KeyError:
                return '\'{0}\' is not available.'.format(function_name)
            else:
                if reason is not None:
                    return '\'{0}\' __virtual__ returned False: {1}'.format(mod_name, reason)
                else:
                    return '\'{0}\' __virtual__ returned False'.format(mod_name)
1083926
def check_plugins(self):
        
        checkers = {}
        for ep in pkg_resources.iter_entry_points(group='frosted.plugins'):
            checkers.update({ep.name: ep.load()})

        for plugin_name, plugin in checkers.items():
            if self.filename != '(none)':
                messages = plugin.check(self.filename)
                for message, loc, args, kwargs in messages:
                    self.report(message, loc, *args, **kwargs)
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)]
637260
def print_no_files_found(opts):
    
    msg =  "No files found with [" +', '.join(opts.extensions) + "] "
    msg += "extension" +("s " if len(opts.extensions) > 1 else " ")
    msg += "in " + opts.input
    # if recursive
    msg += " or any of its subdirectories"
    print(msg)
953898
def call_plugins(plugins, method, *arg, **kw):
    
    for plug in plugins:
        func = getattr(plug, method, None)
        if func is None:
            continue
        #LOG.debug("call plugin %s: %s", plug.name, method)
        result = func(*arg, **kw)
        if result is not None:
            return result
    return None
1124740
def output_traceback(ex):
    """"""
    # Dump full traceback to console.
    output = "".join(traceback.format_exc()).strip()
    for line in output.split('\n'):
        logging.error(line)
    trace_obj = traceback.extract_tb(ex.__traceback__)[-1]
    trace = [basename(trace_obj[0]), trace_obj[1]]
    name = type(ex).__name__
    output = str(ex).replace('\n', ' ')
    msg = "%s in %s on line %s: %s" % (name, trace[0], trace[1], output)
    return (msg, output)
592092
def proselint(paths=None, version=None, clean=None, debug=None,
              output_json=None, time=None, demo=None, compact=None):
    """"""
    if time:
        click.echo(timing_test())
        return

    # In debug or clean mode, delete cache & *.pyc files before running.
    if debug or clean:
        clear_cache()

    # Use the demo file by default.
    if demo:
        paths = [demo_file]

    # Expand the list of directories and files.
    filepaths = extract_files(list(paths))

    # Lint the files
    num_errors = 0

    # Use stdin if no paths were specified
    if len(paths) == 0:
        filepaths.append('-')

    for fp in filepaths:
        try:
            if fp == '-':
                fp = '<stdin>'
                f = sys.stdin
            else:
                f = click.open_file(
                    fp, 'r', encoding="utf-8", errors="replace")
            errors = lint(f, debug=debug)
            num_errors += len(errors)
            print_errors(fp, errors, output_json, compact=compact)
        except Exception:
            traceback.print_exc()

    # Return an exit code
    close_cache_shelves()
    if num_errors > 0:
        sys.exit(1)
    else:
        sys.exit(0)
291949
static function dump_errors( $emask = PLUG_ERROR_REPORTING ){
		$errs = PLUGError::get_errors( $emask );
		foreach( $errs as $Err ){
			$s = $Err->__toString(). "\n";
			if( PLUG_CLI ){
				PLUGCli::stderr( $s );
			}
			else {
				echo $s;
			}
		}
	}