Python textwrap.wrap函数代码示例

    def formatDocumentation(self, node, indent=''):
        """Generate a Python docstring from a Node.

        The returned value includes quotes begin and end double-quotes. 
        Multi-line documentation will be wrapped and combined with raw '\n' characters as
        separators (so newlines will be interpreted by the C++ compiler not the code generator).
        """
        lines = []
        if node.brief:
            for item in node.brief:
                if hasattr(item, "tag"):
                    lines.extend(self.formatCode(item))
                else:
                    lines.extend(textwrap.wrap(item, width=settings.docwidth))
                lines.append("")
        if hasattr(node, "params") and node.params:
            name_width = 0
            for param in node.params:
                if param.name and param.brief and len(param.name) > name_width:
                    name_width = len(param.name)
            if name_width > 0:
                lines.append("Arguments:")
                wrapper = textwrap.TextWrapper(
                    initial_indent="  ",
                    subsequent_indent=(" " * (name_width + 5)),
                    width=settings.docwidth
                    )
                for param in node.params:
                    if not param.name or len(param.name) == 0: continue
                    sep = "-" * (name_width + 1 - len(param.name))
                    if param.brief:
                        lines.extend(
                            wrapper.wrap(
                                "{name} {sep} {descr}".format(
                                    name=param.name, sep=sep, descr=param.brief[0])
                                )
                            )
                    if len(param.brief) > 1:
                        for item in param.brief[1:]:
                            if hasattr(item, "tag"):
                                lines.extend(self.formatCode(item))
                            else:
                                lines.extend(textwrap.wrap(item, width=settings.docwidth))
                lines.append("")
        if node.detailed:
            for item in node.detailed:
                if hasattr(item, "tag"):
                    lines.extend(self.formatCode(item))
                else:
                    lines.extend(textwrap.wrap(item, width=settings.docwidth))
                lines.append("")
        if not lines:
            return '""'
        lines = [line.replace('\\', r'\\') for line in lines]
        lines = [line.replace('"', r'\"') for line in lines]
        template = '{indent}"{line}\\n"'
        return "\n".join(
            [template.format(indent="", line=lines[0])] 
            + [template.format(indent=indent, line=line) for line in lines[1:]]
            )

    def format_private_key(key, heads=True):
        """
        Returns a private key (adding header & footer if required).

        :param key A private key
        :type: string

        :param heads: True if we want to include head and footer
        :type: boolean

        :returns: Formated private key
        :rtype: string
        """
        private_key = key.replace('\x0D', '')
        private_key = private_key.replace('\r', '')
        private_key = private_key.replace('\n', '')
        if len(private_key) > 0:
            if private_key.find('-----BEGIN PRIVATE KEY-----') != -1:
                private_key = private_key.replace('-----BEGIN PRIVATE KEY-----', '')
                private_key = private_key.replace('-----END PRIVATE KEY-----', '')
                private_key = private_key.replace(' ', '')
                if heads:
                    private_key = "-----BEGIN PRIVATE KEY-----\n" + "\n".join(wrap(private_key, 64)) + "\n-----END PRIVATE KEY-----\n"
            else:
                private_key = private_key.replace('-----BEGIN RSA PRIVATE KEY-----', '')
                private_key = private_key.replace('-----END RSA PRIVATE KEY-----', '')
                private_key = private_key.replace(' ', '')
                if heads:
                    private_key = "-----BEGIN RSA PRIVATE KEY-----\n" + "\n".join(wrap(private_key, 64)) + "\n-----END RSA PRIVATE KEY-----\n"
        return private_key

def _CheckAndHandleCredentialException(e, args):
  # Provide detail to users who have no boto config file (who might previously
  # have been using gsutil only for accessing publicly readable buckets and
  # objects).
  # pylint: disable=g-import-not-at-top
  from gslib.util import HasConfiguredCredentials
  if (not HasConfiguredCredentials() and
      not boto.config.get_value('Tests', 'bypass_anonymous_access_warning',
                                False)):
    # The check above allows tests to assert that we get a particular,
    # expected failure, rather than always encountering this error message
    # when there are no configured credentials. This allows tests to
    # simulate a second user without permissions, without actually requiring
    # two separate configured users.
    _OutputAndExit('\n'.join(textwrap.wrap(
        'You are attempting to access protected data with no configured '
        'credentials. Please visit '
        'https://cloud.google.com/console#/project and sign up for an '
        'account, and then run the "gsutil config" command to configure '
        'gsutil to use these credentials.')))
  elif (e.reason and
        (e.reason == 'AccountProblem' or e.reason == 'Account disabled.' or
         'account for the specified project has been disabled' in e.reason)
        and ','.join(args).find('gs://') != -1):
    _OutputAndExit('\n'.join(textwrap.wrap(
        _ConstructAccountProblemHelp(e.reason))))

def wrap_columns(col1, col2, width1=24, width2=40, indent=31):
    """
    Takes two strings of text and turns them into nicely formatted column output.

    Used by display_module()
    """
    
    lines1 = textwrap.wrap(textwrap.dedent(col1).strip(), width=width1)
    lines2 = textwrap.wrap(textwrap.dedent(col2).strip(), width=width2)

    result = ''

    limit = max(len(lines1), len(lines2))

    for x in xrange(limit):

        if x < len(lines1):
            if x != 0:
                result +=  ' '*indent
            result += '{line: <0{width}s}'.format(width=width1, line=lines1[x])
        else:
            if x == 0:
                result += ' '*width1
            else:
                result += ' '*(indent + width1)

        if x < len(lines2):
            result +=  '  ' + '{line: <0{width}s}'.format(width=width2, line=lines2[x])

        if x != limit-1:
            result += "\n"

    return result

    def formatMessage(msgline, width=70):
        """Format a long single line message so that it is easier to read.

        msgline is a string containing a single message. It can either be
        a plain message string which is reformatted using the textwrap
        module or it can be of the form <decl>;<msg> where <decl> is the
        declaration string and <msg> an arbitrary message. Lines of this
        form will be separated so that the declaration and the message
        appear in individual text blocks, where every line of message will start
        with '>' character.

        width is the maximum width of any text blocks (without indendation).
        """
        txts = msgline.split(";")
        # Ensure that there are no more than two items in txts
        if len( txts ) != 2:
            #If message is not in format we expected, just return it
            return os.linesep.join( textwrap.wrap( msgline, width ) )
            
        lines = [ txts[0] ] #I don't want to break declaration string to few lines
        
        # Insert a separator if there are two parts (=decl and msg)
        # Apply the text wrapper to shorten the maximum line length
        wrapped_lines = textwrap.wrap( txts[1], width )
        lines.extend( map( lambda s: "> " + s.strip(), wrapped_lines ) )
        
        return os.linesep.join(lines)

	def __init__(self, prog='', description=None, epilog=None):
		self.prog = prog
		self.description = '\n'.join(textwrap.wrap((description or ''), MAX_WIDTH))
		self.epilog = '\n'.join(textwrap.wrap((epilog or ''), MAX_WIDTH))
		self.__arguments__ = {}
		self.__positionals__ = []
		self.ignore_urls = True

def __get_docstr(text, indent=0):
    """ Format a docstring. Take the first sentence (. followed by a space)
        and use it for the brief. Then put the rest of the text after a blank
        line if there is text there
    """
    text = text.strip().encode("utf-8")
    dotpos = text.find(". ")
    if dotpos > 0:
        brief = text[:dotpos+1]
        content = text[dotpos+2:]
    else:
        brief = text
        content = ""
    if indent == 0:
        istr = ""
    else:
        istr = "{0:{1}}".format(" ", indent)
    
    brief = "\n{0} *  ".format(istr).join(textwrap.wrap(brief, 80))
    content = "\n{0} *  ".format(istr).join(textwrap.wrap(content, 80))
    docstr = "{0}/** \\brief {1}".format(istr, brief)
    if len(content) > 0:
        docstr += "\n{0} * \n{0} *  {1}".format(istr, content)
    docstr += "\n{0} */".format(istr)
    return docstr

def create_image(message, user, location):

	font = ImageFont.truetype(os.path.join(font_path, Font), int(font_size))
	margin = offset = 20

	if watermark_logo:
		wrap = textwrap.wrap(message,width=50)
	else:
		# No logo then make the lines a bit wider
		wrap = textwrap.wrap(message,width=55)

	line_height = font.getsize(wrap[0])[1]
	print "line height: " + str(line_height)
	print wrap

	# Make the image double the size to start with, so that we can apply a anti-alias function when we scale down. Text looks better (I think)
	# enough space for "margin" at the top and bottom and also a .5 margin between the comment and the attribution
	img=Image.new("RGBA", (900,int(2.5*margin+line_height*(len(wrap)+1))),(background_color))
	draw = ImageDraw.Draw(img)
	wrap_text(wrap,font,draw)
	draw.text((margin,int(1.5*margin+line_height*len(wrap))), u" \u2014 "  + user + ", " + location,font=font,fill=font_color)

	if watermark_logo:
		# If there's a logo file provided then make space for it and paste it into the upper right corner.
		logo = Image.open(watermark_logo)
		box = (800, 0, 900, 100)
		img.paste(logo, box)

	img_resized = img.resize((450, int(2.5*.5*margin+(line_height * .5)*(len(wrap)+1))), Image.ANTIALIAS)
	draw = ImageDraw.Draw(img_resized)
	img_resized.save("test_tweet_reply.png")

def format_bundle_info(log, descriptor):
    """
    Formats a release notes summary output for an app, engine or core
    """
    
    # yay we can install! - get release notes
    (summary, url) = descriptor.get_changelog()
    if summary is None:
        summary = "No details provided."
    
    
    log.info("/%s" % ("-" * 70))
    log.info("| Item:        %s" % descriptor)
    log.info("|")
    
    str_to_wrap = "Description: %s" % descriptor.get_description()
    for x in textwrap.wrap(str_to_wrap, width=68, initial_indent="| ", subsequent_indent="|              "):
        log.info(x)
    log.info("|")
    
    str_to_wrap = "Change Log:  %s" % summary
    for x in textwrap.wrap(str_to_wrap, width=68, initial_indent="| ", subsequent_indent="|              "):
        log.info(x)
    
    log.info("\%s" % ("-" * 70))

def save_fig(y, summary_index, total_matrix, gene_matrix, t, ARS, plottitle, filetitle, tumor_name):


	df_high, df_low, total_number = divide_into_two(gene_matrix, total_matrix, t)
	
	fig = plt.figure()
	fig.suptitle("\n".join(wrap(('Expression of ' + str(ARS) + ' in ' + tumor_name))), fontsize = 13)
	if (y == "TCGA-CESC") or (y == "TCGA-DLBC"):
		fig.subplots_adjust(top = 0.80)
	else:
		fig.subplots_adjust(top = 0.85)
	ax = plt.subplot(111)
	ax.set_title("\n".join(wrap(plottitle)), fontsize = 11)
	plt.ylim(0, 1)
	p_value, hm5, hm10, lm5, lm10 = kmplot(df_high, df_low, ax)
	favorable5y = survival_compare(hm5, lm5)
	favorable10y = survival_compare(hm10, lm10)
	df = pd.DataFrame()
	rows = []
	rows.append([ARS, plottitle, total_number, favorable5y, favorable10y, p_value])
	df = pd.DataFrame(rows, columns = cols)
	summary_index = summary_index.append(df)
	fig.savefig('X:\\Su Lab\\TCGA\\Data\\Plot\\' + y + "\\" + ARS + "\\" + y + '-' + ARS + '-' + filetitle + '.png')
	plt.close("all")
	return(summary_index)

def render_article(term, html_text):
    """ Render and return html text of article as text. """
    html_renderer = html2text.HTML2Text(bodywidth=term.width - 1)
    html_renderer.ignore_links = True
    html_renderer.ignore_images = True

    text_wrapped = []
    for line in html_renderer.handle(html_text).splitlines():
        if len(line) < term.width:
            text_wrapped.append(line)
        else:
            # html2text does not always honor `bodywidth',
            # calculate indentation (line up with previous indent)
            # and textwrap again.
            _subsq_indent = 0
            for _subsq_indent, char in enumerate(line):
                if not char.isspace():
                    break
            _indent = u' ' * _subsq_indent
            text_wrapped.extend(textwrap.wrap(line, term.width - 1,
                                              subsequent_indent=_indent))
    final = [_text.rstrip() for _text in text_wrapped]

    if not final or not any(_line for _line in final):
        # no text was rendered by html2text
        final = [''] * (term.height // 2)
        final.extend(textwrap.wrap(MSG_NOTEXT, term.width - 1))
    return final

def test_encoding_detection(file_name, encoding):
    with open(file_name, 'rb') as f:
        input_bytes = f.read()
        result = chardet.detect(input_bytes)
        try:
            expected_unicode = input_bytes.decode(encoding)
        except LookupError:
            expected_unicode = ''
        try:
            detected_unicode = input_bytes.decode(result['encoding'])
        except (LookupError, UnicodeDecodeError, TypeError):
            detected_unicode = ''
    if result:
        encoding_match = (result['encoding'] or '').lower() == encoding
    else:
        encoding_match = False
    # Only care about mismatches that would actually result in different
    # behavior when decoding
    if not encoding_match and expected_unicode != detected_unicode:
        wrapped_expected = '\n'.join(textwrap.wrap(expected_unicode, 100)) + '\n'
        wrapped_detected = '\n'.join(textwrap.wrap(detected_unicode, 100)) + '\n'
        diff = ''.join(ndiff(wrapped_expected.splitlines(True),
                             wrapped_detected.splitlines(True)))
    else:
        diff = ''
        encoding_match = True
    assert encoding_match, ("Expected %s, but got %s for %s.  Character "
                            "differences: \n%s" % (encoding,
                                                   result,
                                                   file_name,
                                                   diff))

    def _get_trait_desc(self, inputs, name, spec):
        desc = spec.desc
        xor = spec.xor
        requires = spec.requires

        manhelpstr = ['\t%s' % name]
        try:
            setattr(inputs, name, None)
        except TraitError as excp:
            def_val = ''
            if getattr(spec, 'usedefault'):
                def_val = ', nipype default value: %s' % str(getattr(spec, 'default_value')()[1])
            line = "(%s%s)" % (excp.info, def_val)
            manhelpstr = wrap(line, 90, initial_indent=manhelpstr[0]+': ',
                              subsequent_indent='\t\t ')
        if desc:
            for line in desc.split('\n'):
                manhelpstr += wrap(line, 90, initial_indent='\t\t',
                                   subsequent_indent='\t\t')
        if xor:
            line = '%s' % ', '.join(xor)
            manhelpstr += wrap(line, 90, initial_indent='\t\tmutually_exclusive: ',
                               subsequent_indent='\t\t ')
        if requires: # and name not in xor_done:
            others = [field for field in requires if field != name]
            line = '%s' % ', '.join(others)
            manhelpstr += wrap(line, 90, initial_indent='\t\trequires: ',
                               subsequent_indent='\t\t ')
        return manhelpstr

def hanging_indent(text, intro, termwidth=None, change_spaces=True,
                   introwidth=None):
    """Produce text with a hanging indent.

    .. versionadded:: 3.3.0
    .. versionchanged:: 4.0.0
    """
    if termwidth is None:
        termwidth = get_termwidth() or 9001
    if introwidth is None:
        introwidth = len(intro)
    nowrap = intro + text
    if intro:
        wrapv = textwrap.wrap(nowrap, termwidth,
                              break_on_hyphens=False)
    else:
        wrapv = textwrap.wrap(nowrap, termwidth - introwidth,
                              break_on_hyphens=False)
    wrap0 = wrapv[0]
    wraprest = textwrap.wrap('\n'.join(wrapv[1:]), termwidth -
                             introwidth,
                             break_on_hyphens=False)
    if change_spaces:
        wraprest = [i.replace('  ', ' ').replace(' ', '  ') for i
                    in wraprest]
    buf = wrap0
    for i in wraprest:
        buf += '\n' + introwidth * ' ' + i

    return buf

    def showPlugins(self):
        """Print list of available plugins.
        """
        import textwrap

        class DummyParser:
            def __init__(self):
                self.options = []
            def add_option(self, *arg, **kw):
                self.options.append((arg, kw.pop('help', '')))
        
        v = self.config.verbosity
        self.config.plugins.sort()
        for p in self.config.plugins:            
            print "Plugin %s" % p.name
            if v >= 2:
                print "  score: %s" % p.score
                print '\n'.join(textwrap.wrap(p.help().strip(),
                                              initial_indent='  ',
                                              subsequent_indent='  '))
                if v >= 3:
                    print
                    print "  Options:"
                    parser = DummyParser()
                    p.addOptions(parser)
                    for opts, help in parser.options:
                        print '  %s' % (', '.join(opts))
                        if help:
                            print '\n'.join(
                                textwrap.wrap(help.strip(),
                                              initial_indent='    ',
                                              subsequent_indent='    '))
                print