Print the disclaimers once. If they've already been shown, skip over.

    :return none:
557386
def __disclaimer(opt=""):
    
    global settings
    if opt is "update":
        print("Disclaimer: LiPD files may be updated and modified to adhere to standards\n")
        settings["note_update"] = False
    if opt is "validate":
        print("Note: Use lipd.validate() or www.LiPD.net/create "
              "to ensure that your new LiPD file(s) are valid")
        settings["note_validate"] = False
    return
856494
def show_notes(self):
        
        if self.notes:
            bytecode._PrintSubBanner("Notes")
            for i in self.notes:
                bytecode._PrintNote(i)
            bytecode._PrintSubBanner()
839943
def should_skip_logging(func):
    
    disabled = strtobool(request.headers.get("x-request-nolog", "false"))
    return disabled or getattr(func, SKIP_LOGGING, False)
916685
def _print mode, text, opts, caler, bind, cfg
      log_ = opts&NOLOG==0
      print_ = opts&NOPRINT==0
      str = cfg.fmt.dup
      str.gsub! "%mode", @highlight[mode]
      if bind
        text = bind.report text
      elsif !text.is String
        text = text.inspect
      elsif cfg.detect_comments and text =~ /\A[ \t]*#[ \t]+\S/
        text = "\n" + @c.green(text.gsub(/^([ \t]*#[ \t])?/, cfg.precede_comments).chop)
      end
      out = cfg.out
      if cfg._time or cfg.path_format
        now = Time.now
        if cfg._time
          time = now.strftime cfg.tf[0]
          time << ".#{cfg.tf[1]%[now.usec/1000]}" if cfg.tf[1]
          str.gsub! "%time", time
        end
        out = now.strftime cfg.out if cfg.path_format
      end
      if caler
        caler.sub!(/block (?:\((\d+) levels\) )?in/) {"{#{$1||1}}"}
        str.gsub! "%caller", caler.sub(String::SIMPLE_CALLER_RE, cfg.cf)
      end
      str.gsub! "%text", text
      str << "\n" if opts&INLINE==0
      log_str = cfg.color_out ? str : @c.clean(str)
      RMTools.write out, log_str if log_
      Kernel::print str if print_
    end
74983
def will_print(level=1):
    
    if level == 1:
        #We only affect printability using the quiet setting.
        return quiet is None or quiet == False
    else:
        return ((isinstance(verbosity, int) and level <= verbosity) or
                (isinstance(verbosity, bool) and verbosity == True))
1092304
def warning(self, amplexception):
        
        msg = '\t'+str(amplexception).replace('\n', '\n\t')
        print('Warning:\n{:s}'.format(msg))
360552
def print_help(self):
        

        print('\n  %s %s' % (self._title or self._name, self._version or ''))

        if self._usage:
            print('\n  %s' % self._usage)
        else:
            cmd = self._name
            if hasattr(self, '_parent') and isinstance(self._parent, Command):
                cmd = '%s %s' % (self._parent._name, cmd)

            if self._command_list:
                usage = 'Usage: %s <command> [option]' % cmd
            else:
                usage = 'Usage: %s [option]' % cmd

            pos = ' '.join(['<%s>' % name for name in self._positional_list])
            print('\n  %s %s' % (usage, pos))

        arglen = max(len(o.name) for o in self._option_list)
        arglen += 2

        self.print_title('\n  Options:\n')
        for o in self._option_list:
            print('    %s %s' % (_pad(o.name, arglen), o.description or ''))
        print('')

        if self._command_list:
            self.print_title('  Commands:\n')
            for cmd in self._command_list:
                if isinstance(cmd, Command):
                    name = _pad(cmd._name, arglen)
                    desc = cmd._description or ''
                    print('    %s %s' % (_pad(name, arglen), desc))

            print('')

        if self._help_footer:
            print(self._help_footer)
            print('')

        return self
761595
def choices(self):
        
        if isinstance(self.validator, list):
            return self.validator[0].print_choices()
        return self.validator.print_choices()
918344
def msg(cls, error=None, debug=True, trace=True):
        
        if debug and error is not None:
            print(error)
        # TODO: BUG: trace should only be printed if debug is true
        if trace:
            print(traceback.format_exc())
428117
def print_options
      return unless self[:verbose]

      Helper.log.info "Using these options:"
      # For ruby 2.5.0+
      censored_values.each do |key, value|
        print(key.inspect, "=>", value.inspect)
        puts ""
      end
      puts ""
    end
565675
def _skip_newlines(self):
        """"""
        while self._cur_token['type'] is TT.lbreak and not self._finished:
            self._increment()
239880
def print_traceback(self):
        
        traceback.print_exception(self.etype, self.value, self.traceback)
826022
def print_declarations(
        decls,
        detailed=True,
        recursive=True,
        writer=lambda x: sys.stdout.write(x + os.linesep),
        verbose=True):
    
    prn = decl_printer_t(0, detailed, recursive, writer, verbose=verbose)
    if not isinstance(decls, list):
        decls = [decls]
    for d in decls:
        prn.level = 0
        prn.instance = d
        algorithm.apply_visitor(prn, d)
36426
def print(formatted = false)
      result = "#{rule}, #{description}"
      if formatted
        if failure
          result = "#{FORMATTING_BALL} #{result}".colorize(:red)
        else
          result = "#{FORMATTING_WARNING} #{result}".colorize(:yellow)
        end
      end
      result += "\n#{location.print}" unless location.nil?
      result += "\nRECOMMENDATION: #{recommendation}" unless recommendation.nil?
      result
    end
1170634
def print_markdown(data, title=None):
    
    def excl_value(value):
        # contains path, i.e. personal info
        return isinstance(value, basestring_) and Path(value).exists()

    if isinstance(data, dict):
        data = list(data.items())
    markdown = ["* **{}:** {}".format(l, unicode_(v))
                for l, v in data if not excl_value(v)]
    if title:
        print("\n## {}".format(title))
    print('\n{}\n'.format('\n'.join(markdown)))
1137383
def verbose(self_,msg,*args,**kw):
        
        self_.__db_print(VERBOSE,msg,*args,**kw)
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);
	}
}