ó
|
M\¬Qc @ sì d Z d Z d d l Z d d l Z y
|
e Z Wn' e k
|
rW d e f d YZ n Xd d d d g Z d
|
Z d f d YZ
|
d d Z d d Z e j d e j Z e j d e j Z d Z e d k rè e d GHn d S( s Text wrapping and filling.
|
s $Id$iÿÿÿÿNt _unicodec B s e Z RS( ( t __name__t
|
__module__( ( ( sP /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/textwrap.pyR s t TextWrappert wrapt fillt dedents
|
c
|
B s÷ e Z d Z e j e d e e Z i Z e d Z
|
x! e e e D] Z e
|
e e <qJ We j d Z e j d Z e j d e j Z d d d e e e e e e d Z d Z d
|
Z d Z d Z d Z d Z d Z RS( s÷
|
Object for wrapping/filling text. The public interface consists of
|
the wrap() and fill() methods; the other methods are just there for
|
subclasses to override in order to tweak the default behaviour.
|
If you want to completely replace the main wrapping algorithm,
|
you'll probably have to override _wrap_chunks().
|
|
Several instance attributes control various aspects of wrapping:
|
width (default: 70)
|
the maximum width of wrapped lines (unless break_long_words
|
is false)
|
initial_indent (default: "")
|
string that will be prepended to the first line of wrapped
|
output. Counts towards the line's width.
|
subsequent_indent (default: "")
|
string that will be prepended to all lines save the first
|
of wrapped output; also counts towards each line's width.
|
expand_tabs (default: true)
|
Expand tabs in input text to spaces before further processing.
|
Each tab will become 1 .. 8 spaces, depending on its position in
|
its line. If false, each tab is treated as a single character.
|
replace_whitespace (default: true)
|
Replace all whitespace characters in the input text by spaces
|
after tab expansion. Note that if expand_tabs is false and
|
replace_whitespace is true, every tab will be converted to a
|
single space!
|
fix_sentence_endings (default: false)
|
Ensure that sentence-ending punctuation is always followed
|
by two spaces. Off by default because the algorithm is
|
(unavoidably) imperfect.
|
break_long_words (default: true)
|
Break words longer than 'width'. If false, those words will not
|
be broken, and some lines might be longer than 'width'.
|
break_on_hyphens (default: true)
|
Allow breaking hyphenated words. If true, wrapping will occur
|
preferably on whitespaces and right after hyphens part of
|
compound words.
|
drop_whitespace (default: true)
|
Drop leading and trailing whitespace from lines.
|
t u sL (\s+|[^\s\w]*\w+[^0-9\W]-(?=\w+[^0-9\W])|(?<=[\w\!\"\'\&\.\,\?])-{2,}(?=\w))s (\s+)s [%s][\.\!\?][\"\']?\ZiF t c
|
|
C s | | _ | | _ | | _ | | _ | | _ | | _ | | _ | | _ | | _ t j
|
| j j t j | _ t j
|
| j j t j | _ d S( N( t widtht initial_indentt subsequent_indentt expand_tabst replace_whitespacet fix_sentence_endingst break_long_wordst drop_whitespacet break_on_hyphenst ret compilet
|
wordsep_ret patternt Ut wordsep_re_unit wordsep_simple_ret wordsep_simple_re_uni(
|
t selfR R
|
R R R R R R R ( ( sP /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/textwrap.pyt __init__s s
|
c C sp | j r | j } n | j rl t | t rE | j | j } ql t | t rl | j | j } ql n | S( sÚ _munge_whitespace(text : string) -> string
|
|
Munge whitespace in text: expand tabs and convert all other
|
whitespace characters to spaces. Eg. " foo bar
|
|
baz"
|
becomes " foo bar baz".
|
( R t
|
expandtabsR t
|
isinstancet strt translatet whitespace_transR t unicode_whitespace_trans( R t text( ( sP /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/textwrap.pyt _munge_whitespace s c C sp t | t r0 | j r$ | j } qN | j } n | j rE | j } n | j } | j | } t d | } | S( sN _split(text : string) -> [string]
|
|
Split the text to wrap into indivisible chunks. Chunks are
|
not quite the same as words; see _wrap_chunks() for full
|
details. As an example, the text
|
Look, goof-ball -- use the -b option!
|
breaks into the following chunks:
|
'Look,', ' ', 'goof-', 'ball', ' ', '--', ' ',
|
'use', ' ', 'the', ' ', '-b', ' ', 'option!'
|
if break_on_hyphens is True, or in:
|
'Look,', ' ', 'goof-ball', ' ', '--', ' ',
|
'use', ' ', 'the', ' ', '-b', ' ', option!'
|
otherwise.
|
N(
|
R R R R R R R t splitt filtert None( R R" t patt chunks( ( sP /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/textwrap.pyt _split£ s c C s| d } | j j } xc | t | d k rw | | d d k rj | | | rj d | | d <| d 7} q | d 7} q Wd S( sf _fix_sentence_endings(chunks : [string])
|
|
Correct for sentence endings buried in 'chunks'. Eg. when the
|
original text contains "... foo.
|
Bar ...", munge_whitespace()
|
and split() will convert that to [..., "foo.", " ", "Bar", ...]
|
which has one too few spaces; this method simply changes the one
|
space to two.
|
i i R s i N( t sentence_end_ret searcht len( R R( t it patsearch( ( sP /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/textwrap.pyt _fix_sentence_endingsÀ s $ c C sr | d k r d } n
|
| | } | j rR | j | d | | d | | d <n | sn | j | j n d S( s
|
_handle_long_word(chunks : [string],
|
cur_line : [string],
|
cur_len : int, width : int)
|
|
Handle a chunk of text (most likely a word, not whitespace) that
|
is too long to fit in any line.
|
i iÿÿÿÿN( R t appendt pop( R t reversed_chunkst cur_linet cur_lenR t
|
space_left( ( sP /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/textwrap.pyt _handle_long_wordÒ s
|
|
c C s g } | j d k r+ t d | j n | j xH| rg } d } | r\ | j } n | j } | j t | } | j r§ | d j d k r§ | r§ | d =n xK | rô t | d } | | | k rð | j | j | | 7} qª Pqª W| r*t | d | k r*| j
|
| | | | n | j rY| rY| d j d k rY| d =n | r8 | j | d j | q8 q8 W| S( s _wrap_chunks(chunks : [string]) -> [string]
|
|
Wrap a sequence of text chunks and return a list of lines of
|
length 'self.width' or less. (If 'break_long_words' is false,
|
some lines may be longer than this.) Chunks correspond roughly
|
to words and the whitespace between them: each chunk is
|
indivisible (modulo 'break_long_words'), but a line break can
|
come between any two chunks. Chunks should not have internal
|
whitespace; ie. a chunk is either all whitespace or a "word".
|
Whitespace chunks will be removed from the beginning and end of
|
lines, but apart from that whitespace is preserved.
|
i s invalid width %r (must be > 0)iÿÿÿÿR ( R t
|
ValueErrort reverseR R
|
R, R t stripR0 R1 R6 t join( R R( t linesR3 R4 t indentR t l( ( sP /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/textwrap.pyt _wrap_chunksó s4
|
%
|
%
|
!c C sD | j | } | j | } | j r7 | j | n | j | S( s^ wrap(text : string) -> [string]
|
|
Reformat the single paragraph in 'text' so it fits in lines of
|
no more than 'self.width' columns, and return a list of wrapped
|
lines. Tabs in 'text' are expanded with string.expandtabs(),
|
and all other whitespace characters (including newline) are
|
converted to space.
|
( R# R) R R/ R> ( R R" R( ( ( sP /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/textwrap.pyR < s
|
c C s d j | j | S( sÞ fill(text : string) -> string
|
|
Reformat the single paragraph in 'text' to fit in lines of no
|
more than 'self.width' columns, and return a new string
|
containing the entire wrapped paragraph.
|
s
|
( R: R ( R R" ( ( sP /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/textwrap.pyR K s ( R R t __doc__t stringt maketranst _whitespaceR, R R! t ordt uspacet mapt xR R R R t lowercaseR* t Truet FalseR R# R) R/ R6 R> R R ( ( ( sP /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/textwrap.pyR ( s6 ( ! I iF c K s t d | | } | j | S( sÈ Wrap a single paragraph of text, returning a list of wrapped lines.
|
|
Reformat the single paragraph in 'text' so it fits in lines of no
|
more than 'width' columns, and return a list of wrapped lines. By
|
default, tabs in 'text' are expanded with string.expandtabs(), and
|
all other whitespace characters (including newline) are converted to
|
space. See TextWrapper class for available keyword args to customize
|
wrapping behaviour.
|
R ( R R ( R" R t kwargst w( ( sP /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/textwrap.pyR W s
|
c K s t d | | } | j | S( s Fill a single paragraph of text, returning a new string.
|
|
Reformat the single paragraph in 'text' to fit in lines of no more
|
than 'width' columns, and return a new string containing the entire
|
wrapped paragraph. As with wrap(), tabs are expanded and other
|
whitespace characters converted to space. See TextWrapper class for
|
available keyword args to customize wrapping behaviour.
|
R ( R R ( R" R RJ RK ( ( sP /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/textwrap.pyR d s s ^[ ]+$s (^[ ]*)(?:[^
|
])c C sÍ d } t j d | } t j | } xT | D]L } | d k rI | } q. | j | r[ q. | j | rs | } q. d } Pq. Wd r§ | r§ x | j d D] } q Wn | rÉ t j d | d | } n | S( s9 Remove any common leading whitespace from every line in `text`.
|
|
This can be used to make triple-quoted strings line up with the left
|
edge of the display, while still presenting them in the source code
|
in indented form.
|
|
Note that tabs and spaces are both treated as whitespace, but they
|
are not equal: the lines " hello" and " hello" are
|
considered to have no common leading whitespace. (This behaviour is
|
new in Python 2.5; older versions of this module incorrectly
|
expanded tabs before searching for common leading whitespace.)
|
R i s
|
s (?m)^N( R& t _whitespace_only_ret subt _leading_whitespace_ret findallt
|
startswithR$ R ( R" t margint indentsR< t line( ( sP /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/textwrap.pyR v s$ t __main__s Hello there.
|
This is indented.( R? t __revision__R@ R t unicodeR t NameErrort objectt __all__RB R R R R t MULTILINERL RN R R ( ( ( sP /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/textwrap.pyt <module> s"
|
|
ÿ 0 0
|
