Logs a message to stderr only if verbose is enabled.
2404
def vlog(self, msg, *args):
        """"""
        if self.verbose:
            self.log(msg, *args)
697831
def _emit_error(cls, message):
        """"""
        sys.stderr.write('ERROR: {message}\n'.format(message=message))
        sys.stderr.flush()
376387
def stderr_cm(self):
        
        with open(self._get_stderr_log(), 'a+') as fh:
            msg = '### {} ###\n'.format(self._datetime)
            fh.write(msg)
            fh.flush()

            try:
                yield fh
            except Exception as e:
                self._has_error = True
                fh.write(e.message)
                fh.flush()
                raise
982419
def print_verbose(*args, **kwargs):
    
    if kwargs.pop('verbose', False) is True:
        gprint(*args, **kwargs)
714757
def my_log_message(verbose, prio, msg):
    
    syslog.syslog(prio, msg)
    if verbose or prio == syslog.LOG_ERR:
        sys.stderr.write("%s\n" % (msg))
774259
def _emit_warning(cls, message):
        """"""
        sys.stderr.write('WARNING: {message}\n'.format(message=message))
        sys.stderr.flush()
251105
def setup_logging(verbosity, filename=None):
    """"""
    levels = [logging.WARNING, logging.INFO, logging.DEBUG]
    level = levels[min(verbosity, len(levels) - 1)]
    logging.root.setLevel(level)

    fmt = logging.Formatter('%(asctime)s %(levelname)-12s %(message)-100s '
                            '[%(filename)s:%(lineno)d]')
    hdlr = logging.StreamHandler()  # stderr
    hdlr.setFormatter(fmt)
    logging.root.addHandler(hdlr)

    if filename:
        hdlr = logging.FileHandler(filename, 'a')
        hdlr.setFormatter(fmt)
        logging.root.addHandler(hdlr)
704926
def spam(self, msg, *args, **kw):
        """"""
        if self.isEnabledFor(SPAM):
            self._log(SPAM, msg, args, **kw)
416055
protected function verboseLog($message)
    {
        if (!$this->isDryRunEnabled() &&
             $this->getOutput()->getVerbosity() < OutputInterface::VERBOSITY_VERY_VERBOSE) {
            return;
        }

        $this->getOutput()->writeln($message);
    }
835274
def log(message)
      if verbose
        puts "*** #{message}"
      elsif very_verbose
        time = Time.now.strftime('%H:%M:%S %Y-%m-%d')
        puts "** [#{time}] #$$: #{message}"
      end
    end
372143
def failed(self, message):
        '''
        
        '''
        return self._log(
            message=message.upper(),
            stream=sys.stderr,
            color=Logger.COLOR_RED_BOLD,
            newline=True
        )
1003824
def verbose_message(self):
        """"""
        if self.threshold is None:
            return 'No threshold'
        return '%.1f is %s than %.1f' % (self.value,
                                         self.adjective,
                                         self.threshold)
990800
def mute_stdio(self) -> None:
        

        # The benefit of using a Filter here for disabling messages is that we do not have to restore old logging levels.
        for logger in self.loggers.values():
            if logger.hasHandlers():
                logger.handlers[0].addFilter(self.block_all_filter)
555761
def print_message(self, message, verbosity_needed=1):
        
        if self.args.verbosity >= verbosity_needed:
            print(message)
570138
def log(self, msg, error=False):
        """"""
        output = self.stdout
        if error:
            output = self.stderr

        output.write(msg)
        output.write('\n')
649354
function (msg,verbosity)
		{
			if (!_debug || verbosity>_verbosity)
				return false;
			this.e.log.apply(this,[msg||'','debug',verbosity||0]);
			return self;
		}
1146251
def _read_stderr(self):
        
        output = self._decode(self._process.readAllStandardError().data())
        if self._formatter:
            self._formatter.append_message(output, output_format=OutputFormat.ErrorMessageFormat)
        else:
            self.insertPlainText(output)