home *** CD-ROM | disk | FTP | other *** search
/ Freelog 116 / FreelogNo116-JuilletSeptembre2013.iso / Bureautique / gImageReader / gimagereader_0.9-1_win32.exe / bin / textwrap.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2011-03-24  |  11KB  |  308 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. '''Text wrapping and filling.
  5. '''
  6. __revision__ = '$Id: textwrap.py 74912 2009-09-18 16:19:56Z georg.brandl $'
  7. import string
  8. import re
  9. __all__ = [
  10.     'TextWrapper',
  11.     'wrap',
  12.     'fill',
  13.     'dedent']
  14. _whitespace = '\t\n\x0b\x0c\r '
  15.  
  16. class TextWrapper:
  17.     '''
  18.     Object for wrapping/filling text.  The public interface consists of
  19.     the wrap() and fill() methods; the other methods are just there for
  20.     subclasses to override in order to tweak the default behaviour.
  21.     If you want to completely replace the main wrapping algorithm,
  22.     you\'ll probably have to override _wrap_chunks().
  23.  
  24.     Several instance attributes control various aspects of wrapping:
  25.       width (default: 70)
  26.         the maximum width of wrapped lines (unless break_long_words
  27.         is false)
  28.       initial_indent (default: "")
  29.         string that will be prepended to the first line of wrapped
  30.         output.  Counts towards the line\'s width.
  31.       subsequent_indent (default: "")
  32.         string that will be prepended to all lines save the first
  33.         of wrapped output; also counts towards each line\'s width.
  34.       expand_tabs (default: true)
  35.         Expand tabs in input text to spaces before further processing.
  36.         Each tab will become 1 .. 8 spaces, depending on its position in
  37.         its line.  If false, each tab is treated as a single character.
  38.       replace_whitespace (default: true)
  39.         Replace all whitespace characters in the input text by spaces
  40.         after tab expansion.  Note that if expand_tabs is false and
  41.         replace_whitespace is true, every tab will be converted to a
  42.         single space!
  43.       fix_sentence_endings (default: false)
  44.         Ensure that sentence-ending punctuation is always followed
  45.         by two spaces.  Off by default because the algorithm is
  46.         (unavoidably) imperfect.
  47.       break_long_words (default: true)
  48.         Break words longer than \'width\'.  If false, those words will not
  49.         be broken, and some lines might be longer than \'width\'.
  50.       break_on_hyphens (default: true)
  51.         Allow breaking hyphenated words. If true, wrapping will occur
  52.         preferably on whitespaces and right after hyphens part of
  53.         compound words.
  54.       drop_whitespace (default: true)
  55.         Drop leading and trailing whitespace from lines.
  56.     '''
  57.     whitespace_trans = string.maketrans(_whitespace, ' ' * len(_whitespace))
  58.     unicode_whitespace_trans = { }
  59.     uspace = ord(u' ')
  60.     for x in map(ord, _whitespace):
  61.         unicode_whitespace_trans[x] = uspace
  62.     
  63.     wordsep_re = re.compile('(\\s+|[^\\s\\w]*\\w+[^0-9\\W]-(?=\\w+[^0-9\\W])|(?<=[\\w\\!\\"\\\'\\&\\.\\,\\?])-{2,}(?=\\w))')
  64.     wordsep_simple_re = re.compile('(\\s+)')
  65.     sentence_end_re = re.compile('[%s][\\.\\!\\?][\\"\\\']?\\Z' % string.lowercase)
  66.     
  67.     def __init__(self, width = 70, initial_indent = '', subsequent_indent = '', expand_tabs = True, replace_whitespace = True, fix_sentence_endings = False, break_long_words = True, drop_whitespace = True, break_on_hyphens = True):
  68.         self.width = width
  69.         self.initial_indent = initial_indent
  70.         self.subsequent_indent = subsequent_indent
  71.         self.expand_tabs = expand_tabs
  72.         self.replace_whitespace = replace_whitespace
  73.         self.fix_sentence_endings = fix_sentence_endings
  74.         self.break_long_words = break_long_words
  75.         self.drop_whitespace = drop_whitespace
  76.         self.break_on_hyphens = break_on_hyphens
  77.         self.wordsep_re_uni = re.compile(self.wordsep_re.pattern, re.U)
  78.         self.wordsep_simple_re_uni = re.compile(self.wordsep_simple_re.pattern, re.U)
  79.  
  80.     
  81.     def _munge_whitespace(self, text):
  82.         '''_munge_whitespace(text : string) -> string
  83.  
  84.         Munge whitespace in text: expand tabs and convert all other
  85.         whitespace characters to spaces.  Eg. " foo\tbar
  86.  
  87. baz"
  88.         becomes " foo    bar  baz".
  89.         '''
  90.         if self.expand_tabs:
  91.             text = text.expandtabs()
  92.         if self.replace_whitespace:
  93.             if isinstance(text, str):
  94.                 text = text.translate(self.whitespace_trans)
  95.             elif isinstance(text, unicode):
  96.                 text = text.translate(self.unicode_whitespace_trans)
  97.             
  98.         return text
  99.  
  100.     
  101.     def _split(self, text):
  102.         """_split(text : string) -> [string]
  103.  
  104.         Split the text to wrap into indivisible chunks.  Chunks are
  105.         not quite the same as words; see _wrap_chunks() for full
  106.         details.  As an example, the text
  107.           Look, goof-ball -- use the -b option!
  108.         breaks into the following chunks:
  109.           'Look,', ' ', 'goof-', 'ball', ' ', '--', ' ',
  110.           'use', ' ', 'the', ' ', '-b', ' ', 'option!'
  111.         if break_on_hyphens is True, or in:
  112.           'Look,', ' ', 'goof-ball', ' ', '--', ' ',
  113.           'use', ' ', 'the', ' ', '-b', ' ', option!'
  114.         otherwise.
  115.         """
  116.         if isinstance(text, unicode):
  117.             if self.break_on_hyphens:
  118.                 pat = self.wordsep_re_uni
  119.             else:
  120.                 pat = self.wordsep_simple_re_uni
  121.         elif self.break_on_hyphens:
  122.             pat = self.wordsep_re
  123.         else:
  124.             pat = self.wordsep_simple_re
  125.         chunks = pat.split(text)
  126.         chunks = filter(None, chunks)
  127.         return chunks
  128.  
  129.     
  130.     def _fix_sentence_endings(self, chunks):
  131.         '''_fix_sentence_endings(chunks : [string])
  132.  
  133.         Correct for sentence endings buried in \'chunks\'.  Eg. when the
  134.         original text contains "... foo.
  135. Bar ...", munge_whitespace()
  136.         and split() will convert that to [..., "foo.", " ", "Bar", ...]
  137.         which has one too few spaces; this method simply changes the one
  138.         space to two.
  139.         '''
  140.         i = 0
  141.         patsearch = self.sentence_end_re.search
  142.         while i < len(chunks) - 1:
  143.             if chunks[i + 1] == ' ' and patsearch(chunks[i]):
  144.                 chunks[i + 1] = '  '
  145.                 i += 2
  146.                 continue
  147.             i += 1
  148.  
  149.     
  150.     def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width):
  151.         '''_handle_long_word(chunks : [string],
  152.                              cur_line : [string],
  153.                              cur_len : int, width : int)
  154.  
  155.         Handle a chunk of text (most likely a word, not whitespace) that
  156.         is too long to fit in any line.
  157.         '''
  158.         if width < 1:
  159.             space_left = 1
  160.         else:
  161.             space_left = width - cur_len
  162.         if self.break_long_words:
  163.             cur_line.append(reversed_chunks[-1][:space_left])
  164.             reversed_chunks[-1] = reversed_chunks[-1][space_left:]
  165.         elif not cur_line:
  166.             cur_line.append(reversed_chunks.pop())
  167.  
  168.     
  169.     def _wrap_chunks(self, chunks):
  170.         '''_wrap_chunks(chunks : [string]) -> [string]
  171.  
  172.         Wrap a sequence of text chunks and return a list of lines of
  173.         length \'self.width\' or less.  (If \'break_long_words\' is false,
  174.         some lines may be longer than this.)  Chunks correspond roughly
  175.         to words and the whitespace between them: each chunk is
  176.         indivisible (modulo \'break_long_words\'), but a line break can
  177.         come between any two chunks.  Chunks should not have internal
  178.         whitespace; ie. a chunk is either all whitespace or a "word".
  179.         Whitespace chunks will be removed from the beginning and end of
  180.         lines, but apart from that whitespace is preserved.
  181.         '''
  182.         lines = []
  183.         if self.width <= 0:
  184.             raise ValueError('invalid width %r (must be > 0)' % self.width)
  185.         chunks.reverse()
  186.         while chunks:
  187.             cur_line = []
  188.             cur_len = 0
  189.             if lines:
  190.                 indent = self.subsequent_indent
  191.             else:
  192.                 indent = self.initial_indent
  193.             width = self.width - len(indent)
  194.             if self.drop_whitespace and chunks[-1].strip() == '' and lines:
  195.                 del chunks[-1]
  196.             while chunks:
  197.                 l = len(chunks[-1])
  198.                 if cur_len + l <= width:
  199.                     cur_line.append(chunks.pop())
  200.                     cur_len += l
  201.                     continue
  202.                 break
  203.             if chunks and len(chunks[-1]) > width:
  204.                 self._handle_long_word(chunks, cur_line, cur_len, width)
  205.             if self.drop_whitespace and cur_line and cur_line[-1].strip() == '':
  206.                 del cur_line[-1]
  207.             if cur_line:
  208.                 lines.append(indent + ''.join(cur_line))
  209.                 continue
  210.             return lines
  211.  
  212.     
  213.     def wrap(self, text):
  214.         """wrap(text : string) -> [string]
  215.  
  216.         Reformat the single paragraph in 'text' so it fits in lines of
  217.         no more than 'self.width' columns, and return a list of wrapped
  218.         lines.  Tabs in 'text' are expanded with string.expandtabs(),
  219.         and all other whitespace characters (including newline) are
  220.         converted to space.
  221.         """
  222.         text = self._munge_whitespace(text)
  223.         chunks = self._split(text)
  224.         if self.fix_sentence_endings:
  225.             self._fix_sentence_endings(chunks)
  226.         return self._wrap_chunks(chunks)
  227.  
  228.     
  229.     def fill(self, text):
  230.         """fill(text : string) -> string
  231.  
  232.         Reformat the single paragraph in 'text' to fit in lines of no
  233.         more than 'self.width' columns, and return a new string
  234.         containing the entire wrapped paragraph.
  235.         """
  236.         return '\n'.join(self.wrap(text))
  237.  
  238.  
  239.  
  240. def wrap(text, width = 70, **kwargs):
  241.     """Wrap a single paragraph of text, returning a list of wrapped lines.
  242.  
  243.     Reformat the single paragraph in 'text' so it fits in lines of no
  244.     more than 'width' columns, and return a list of wrapped lines.  By
  245.     default, tabs in 'text' are expanded with string.expandtabs(), and
  246.     all other whitespace characters (including newline) are converted to
  247.     space.  See TextWrapper class for available keyword args to customize
  248.     wrapping behaviour.
  249.     """
  250.     w = TextWrapper(width = width, **kwargs)
  251.     return w.wrap(text)
  252.  
  253.  
  254. def fill(text, width = 70, **kwargs):
  255.     """Fill a single paragraph of text, returning a new string.
  256.  
  257.     Reformat the single paragraph in 'text' to fit in lines of no more
  258.     than 'width' columns, and return a new string containing the entire
  259.     wrapped paragraph.  As with wrap(), tabs are expanded and other
  260.     whitespace characters converted to space.  See TextWrapper class for
  261.     available keyword args to customize wrapping behaviour.
  262.     """
  263.     w = TextWrapper(width = width, **kwargs)
  264.     return w.fill(text)
  265.  
  266. _whitespace_only_re = re.compile('^[ \t]+$', re.MULTILINE)
  267. _leading_whitespace_re = re.compile('(^[ \t]*)(?:[^ \t\n])', re.MULTILINE)
  268.  
  269. def dedent(text):
  270.     '''Remove any common leading whitespace from every line in `text`.
  271.  
  272.     This can be used to make triple-quoted strings line up with the left
  273.     edge of the display, while still presenting them in the source code
  274.     in indented form.
  275.  
  276.     Note that tabs and spaces are both treated as whitespace, but they
  277.     are not equal: the lines "  hello" and "\thello" are
  278.     considered to have no common leading whitespace.  (This behaviour is
  279.     new in Python 2.5; older versions of this module incorrectly
  280.     expanded tabs before searching for common leading whitespace.)
  281.     '''
  282.     margin = None
  283.     text = _whitespace_only_re.sub('', text)
  284.     indents = _leading_whitespace_re.findall(text)
  285.     for indent in indents:
  286.         if margin is None:
  287.             margin = indent
  288.             continue
  289.         if indent.startswith(margin):
  290.             continue
  291.         if margin.startswith(indent):
  292.             margin = indent
  293.             continue
  294.         margin = ''
  295.         break
  296.     
  297.     if 0 and margin:
  298.         for line in text.split('\n'):
  299.             if not not line and line.startswith(margin):
  300.                 raise AssertionError, 'line = %r, margin = %r' % (line, margin)
  301.         
  302.     if margin:
  303.         text = re.sub('(?m)^' + margin, '', text)
  304.     return text
  305.  
  306. if __name__ == '__main__':
  307.     print dedent('Hello there.\n  This is indented.')
  308.