prints some single-line infos according to `disp_annotation()`,
        if ``iteration_counter % modulo == 0``
503821
def disp(self, modulo=None):  # TODO: rather assign opt['verb_disp'] as default?
        
        if modulo is None:
            modulo = self.opts['verb_disp']

        # console display
        if modulo:
            if (self.countiter - 1) % (10 * modulo) < 1:
                self.disp_annotation()
            if self.countiter > 0 and (self.stop() or self.countiter < 4
                              or self.countiter % modulo < 1):
                if self.opts['verb_time']:
                    toc = self.elapsed_time()
                    stime = str(int(toc // 60)) + ':' + str(round(toc % 60, 1))
                else:
                    stime = ''
                print(' '.join((repr(self.countiter).rjust(5),
                                repr(self.countevals).rjust(6),
                                '%.15e' % (min(self.fit.fit)),
                                '%4.1e' % (self.D.max() / self.D.min()),
                                '%6.2e' % self.sigma,
                                '%6.0e' % (self.sigma * min(self.sigma_vec * sqrt(self.dC))),
                                '%6.0e' % (self.sigma * max(self.sigma_vec * sqrt(self.dC))),
                                stime)))
                # if self.countiter < 4:
                sys.stdout.flush()
        return self
918313
def debug(value):
    
    print("%s %s: " % (type(value), value))
    print(dir(value))
    print('\n\n')
    return ''
587697
def _print_lines(self, lines, start, breaks=(), frame=None):
        """"""
        if frame:
            current_lineno = frame.f_lineno
            exc_lineno = self.tb_lineno.get(frame, -1)
        else:
            current_lineno = exc_lineno = -1
        for lineno, line in enumerate(lines, start):
            s = str(lineno).rjust(3)
            if len(s) < 4:
                s += ' '
            if lineno in breaks:
                s += 'B'
            else:
                s += ' '
            if lineno == current_lineno:
                s += '->'
            elif lineno == exc_lineno:
                s += '>>'
            self.message(s + '\t' + line.rstrip())
1205018
def pprint(self, seconds):
        
        return ("%d:%02d:%02d.%03d", reduce(lambda ll, b: divmod(ll[0], b) + ll[1:], [(seconds * 1000,), 1000, 60, 60]))
20287
def printSequence(x, formatString="%d"):
  
  numElements = len(x)
  s = ""
  for j in range(numElements):
    s += formatString % x[j]
  print s
339323
def printif(self, obj_print, tipo_print=None):
        """"""
        if self.verbose:
            print(obj_print)
        if tipo_print == 'ok':
            logging.info(obj_print)
        elif tipo_print == 'error':
            logging.error(obj_print)
        elif tipo_print == 'warning':
            logging.warning(obj_print)
1356352
def OLD_printDebug(s, style=None):
    
    if style == "comment":
        s = Style.DIM + s + Style.RESET_ALL
    elif style == "important":
        s = Style.BRIGHT + s + Style.RESET_ALL
    elif style == "normal":
        s = Style.RESET_ALL + s + Style.RESET_ALL
    elif style == "red":
        s = Fore.RED + s + Style.RESET_ALL
    elif style == "green":
        s = Fore.GREEN + s + Style.RESET_ALL
    try:
        print(s, file=sys.stderr)
    except:
        pass
758685
def show(self):
        
        off = 0
        for n, i in enumerate(self.get_instructions()):
            print("{:8d} (0x{:08x}) {:04x} {:30} {}".format(n, off, i.get_op_value(), i.get_name(), i.get_output(self.idx)))
            off += i.get_length()
182206
def do_info(self, arg, arguments):
        
        if arguments["--all"]:
            Console.ok(70 * "-")
            Console.ok('DIR')
            Console.ok(70 * "-")
            for element in dir(self):
                Console.ok(str(element))
            Console.ok(70 * "-")
        self.print_info()
140352
def dprint(s):
    ''''''

    import inspect

    frameinfo = inspect.stack()[1]
    callerframe = frameinfo.frame
    d = callerframe.f_locals

    if (isinstance(s,str)):
        val = eval(s, d)
    else:
        val = s
        cc = frameinfo.code_context[0]
        import re
        regex = re.compile("dprint\((.*)\)")
        res = regex.search(cc)
        s = res.group(1)

    text = ''
    text += bcolors.OKBLUE + "At <{}>\n".format(str(frameinfo)) + bcolors.ENDC
    text += bcolors.WARNING + "{}:  ".format(s) + bcolors.ENDC
    text += str(val)
    text += str()

    print(text)
1144756
def printSequences(x, formatString="%d"):
  
  [seqLen, numElements] = x.shape
  for i in range(seqLen):
    s = ""
    for j in range(numElements):
      s += formatString % x[i][j]
    print s
891743
def print_descr(rect, annot):
    """"""
    annot.parent.insertText(rect.br + (10, 0),
                    "'%s' annotation" % annot.type[1], color = red)
717179
def __PrintMessageDocstringLines(self, message_type):
        """"""
        description = message_type.description or '%s message type.' % (
            message_type.name)
        short_description = (
            _EmptyMessage(message_type) and
            len(description) < (self.__printer.CalculateWidth() - 6))
        with self.__printer.CommentContext():
            if short_description:
                # Note that we use explicit string interpolation here since
                # we're in comment context.
                self.__printer('r"""%s"""' % description)
                return
            for line in textwrap.wrap('r"""%s' % description,
                                      self.__printer.CalculateWidth()):
                self.__printer(line)

            PrintIndentedDescriptions(self.__printer, message_type.enum_types,
                                      'Enums')
            PrintIndentedDescriptions(
                self.__printer, message_type.message_types, 'Messages')
            PrintIndentedDescriptions(
                self.__printer, message_type.fields, 'Fields')
            self.__printer('"""')
            self.__printer()
362760
def on_assert_failed_print_details(actual, expected):
    
    try:
        yield
    except AssertionError:
        # diff = difflib.unified_diff(expected.splitlines(), actual.splitlines(),
        #                            "expected", "actual")
        diff = difflib.ndiff(expected.splitlines(), actual.splitlines())
        diff_text = u"\n".join(diff)
        print(u"DIFF (+ ACTUAL, - EXPECTED):\n{0}\n".format(diff_text))
        if DEBUG:
            print(u"expected:\n{0}\n".format(expected))
            print(u"actual:\n{0}\n".format(actual))
        raise
642411
def _print_refs(self, refs, total, prefix='    ',
                    level=1, minsize=0, minpct=0.1):
        
        lrefs = list(refs)
        lrefs.sort(key=lambda x: x.size)
        lrefs.reverse()
        for ref in lrefs:
            if ref.size > minsize and (ref.size*100.0/total) > minpct:
                self.stream.write('%-50s %-14s %3d%% [%d]\n' % (
                    trunc(prefix+str(ref.name), 50),
                    pp(ref.size),
                    int(ref.size*100.0/total),
                    level
                ))
                self._print_refs(ref.refs, total, prefix=prefix+'  ',
                                 level=level+1)
407937
@Override
    public void printThreadInfo(final StringBuilder sb) {
        StringBuilders.appendDqValue(sb, name).append(Chars.SPACE);
        if (isDaemon) {
            sb.append("daemon ");
        }
        sb.append("prio=").append(priority).append(" tid=").append(id).append(' ');
        if (threadGroupName != null) {
            StringBuilders.appendKeyDqValue(sb, "group", threadGroupName);
        }
        sb.append('\n');
        sb.append("\tThread state: ").append(state.name()).append('\n');
    }
757412
def print(self):
        """"""
        if self.supported:
            print('  AF',  end='')
        else:
            print('  //', end='')
        fn_num = self.fn_num
        if fn_num is None:
            fn_num = 0
        print('({:2d}, {:8s}, {:2d}, {:10s}, {:8s}), // {:s}'.format(self.idx,
              self.func, fn_num, self.pin_type, self.ptr(), self.af_str))