Ignore:
Timestamp:
12/29/08 12:24:05 (6 years ago)
Author:
xi
Message:

Added basic support for Python 3 (Thanks idadesub(at)users(dot)sourceforge(dot)net).

Location:
pyyaml/trunk/lib3
Files:
1 edited
1 copied

Legend:

Unmodified
Added
Removed
  • pyyaml/trunk/lib3/yaml/emitter.py

    r313 r328  
    99__all__ = ['Emitter', 'EmitterError'] 
    1010 
    11 from error import YAMLError 
    12 from events import * 
     11from .error import YAMLError 
     12from .events import * 
    1313 
    1414class EmitterError(YAMLError): 
    1515    pass 
    1616 
    17 class ScalarAnalysis(object): 
     17class ScalarAnalysis: 
    1818    def __init__(self, scalar, empty, multiline, 
    1919            allow_flow_plain, allow_block_plain, 
     
    2929        self.allow_block = allow_block 
    3030 
    31 class Emitter(object): 
     31class Emitter: 
    3232 
    3333    DEFAULT_TAG_PREFIXES = { 
    34         u'!' : u'!', 
    35         u'tag:yaml.org,2002:' : u'!!', 
     34        '!' : '!', 
     35        'tag:yaml.org,2002:' : '!!', 
    3636    } 
    3737 
     
    8989        if width and width > self.best_indent*2: 
    9090            self.best_width = width 
    91         self.best_line_break = u'\n' 
    92         if line_break in [u'\r', u'\n', u'\r\n']: 
     91        self.best_line_break = '\n' 
     92        if line_break in ['\r', '\n', '\r\n']: 
    9393            self.best_line_break = line_break 
    9494 
     
    155155    def expect_stream_start(self): 
    156156        if isinstance(self.event, StreamStartEvent): 
    157             if self.event.encoding: 
     157            if self.event.encoding and not hasattr(self.stream, 'encoding'): 
    158158                self.encoding = self.event.encoding 
    159159            self.write_stream_start() 
     
    174174        if isinstance(self.event, DocumentStartEvent): 
    175175            if (self.event.version or self.event.tags) and self.open_ended: 
    176                 self.write_indicator(u'...', True) 
     176                self.write_indicator('...', True) 
    177177                self.write_indent() 
    178178            if self.event.version: 
     
    194194            if not implicit: 
    195195                self.write_indent() 
    196                 self.write_indicator(u'---', True) 
     196                self.write_indicator('---', True) 
    197197                if self.canonical: 
    198198                    self.write_indent() 
     
    200200        elif isinstance(self.event, StreamEndEvent): 
    201201            if self.open_ended: 
    202                 self.write_indicator(u'...', True) 
     202                self.write_indicator('...', True) 
    203203                self.write_indent() 
    204204            self.write_stream_end() 
     
    212212            self.write_indent() 
    213213            if self.event.explicit: 
    214                 self.write_indicator(u'...', True) 
     214                self.write_indicator('...', True) 
    215215                self.write_indent() 
    216216            self.flush_stream() 
     
    235235            self.expect_alias() 
    236236        elif isinstance(self.event, (ScalarEvent, CollectionStartEvent)): 
    237             self.process_anchor(u'&') 
     237            self.process_anchor('&') 
    238238            self.process_tag() 
    239239            if isinstance(self.event, ScalarEvent): 
     
    257257        if self.event.anchor is None: 
    258258            raise EmitterError("anchor is not specified for alias") 
    259         self.process_anchor(u'*') 
     259        self.process_anchor('*') 
    260260        self.state = self.states.pop() 
    261261 
     
    269269 
    270270    def expect_flow_sequence(self): 
    271         self.write_indicator(u'[', True, whitespace=True) 
     271        self.write_indicator('[', True, whitespace=True) 
    272272        self.flow_level += 1 
    273273        self.increase_indent(flow=True) 
     
    278278            self.indent = self.indents.pop() 
    279279            self.flow_level -= 1 
    280             self.write_indicator(u']', False) 
     280            self.write_indicator(']', False) 
    281281            self.state = self.states.pop() 
    282282        else: 
     
    291291            self.flow_level -= 1 
    292292            if self.canonical: 
    293                 self.write_indicator(u',', False) 
     293                self.write_indicator(',', False) 
    294294                self.write_indent() 
    295             self.write_indicator(u']', False) 
     295            self.write_indicator(']', False) 
    296296            self.state = self.states.pop() 
    297297        else: 
    298             self.write_indicator(u',', False) 
     298            self.write_indicator(',', False) 
    299299            if self.canonical or self.column > self.best_width: 
    300300                self.write_indent() 
     
    305305 
    306306    def expect_flow_mapping(self): 
    307         self.write_indicator(u'{', True, whitespace=True) 
     307        self.write_indicator('{', True, whitespace=True) 
    308308        self.flow_level += 1 
    309309        self.increase_indent(flow=True) 
     
    314314            self.indent = self.indents.pop() 
    315315            self.flow_level -= 1 
    316             self.write_indicator(u'}', False) 
     316            self.write_indicator('}', False) 
    317317            self.state = self.states.pop() 
    318318        else: 
     
    323323                self.expect_node(mapping=True, simple_key=True) 
    324324            else: 
    325                 self.write_indicator(u'?', True) 
     325                self.write_indicator('?', True) 
    326326                self.states.append(self.expect_flow_mapping_value) 
    327327                self.expect_node(mapping=True) 
     
    332332            self.flow_level -= 1 
    333333            if self.canonical: 
    334                 self.write_indicator(u',', False) 
     334                self.write_indicator(',', False) 
    335335                self.write_indent() 
    336             self.write_indicator(u'}', False) 
     336            self.write_indicator('}', False) 
    337337            self.state = self.states.pop() 
    338338        else: 
    339             self.write_indicator(u',', False) 
     339            self.write_indicator(',', False) 
    340340            if self.canonical or self.column > self.best_width: 
    341341                self.write_indent() 
     
    344344                self.expect_node(mapping=True, simple_key=True) 
    345345            else: 
    346                 self.write_indicator(u'?', True) 
     346                self.write_indicator('?', True) 
    347347                self.states.append(self.expect_flow_mapping_value) 
    348348                self.expect_node(mapping=True) 
    349349 
    350350    def expect_flow_mapping_simple_value(self): 
    351         self.write_indicator(u':', False) 
     351        self.write_indicator(':', False) 
    352352        self.states.append(self.expect_flow_mapping_key) 
    353353        self.expect_node(mapping=True) 
     
    356356        if self.canonical or self.column > self.best_width: 
    357357            self.write_indent() 
    358         self.write_indicator(u':', True) 
     358        self.write_indicator(':', True) 
    359359        self.states.append(self.expect_flow_mapping_key) 
    360360        self.expect_node(mapping=True) 
     
    376376        else: 
    377377            self.write_indent() 
    378             self.write_indicator(u'-', True, indention=True) 
     378            self.write_indicator('-', True, indention=True) 
    379379            self.states.append(self.expect_block_sequence_item) 
    380380            self.expect_node(sequence=True) 
     
    399399                self.expect_node(mapping=True, simple_key=True) 
    400400            else: 
    401                 self.write_indicator(u'?', True, indention=True) 
     401                self.write_indicator('?', True, indention=True) 
    402402                self.states.append(self.expect_block_mapping_value) 
    403403                self.expect_node(mapping=True) 
    404404 
    405405    def expect_block_mapping_simple_value(self): 
    406         self.write_indicator(u':', False) 
     406        self.write_indicator(':', False) 
    407407        self.states.append(self.expect_block_mapping_key) 
    408408        self.expect_node(mapping=True) 
     
    410410    def expect_block_mapping_value(self): 
    411411        self.write_indent() 
    412         self.write_indicator(u':', True, indention=True) 
     412        self.write_indicator(':', True, indention=True) 
    413413        self.states.append(self.expect_block_mapping_key) 
    414414        self.expect_node(mapping=True) 
     
    429429        event = self.events[0] 
    430430        return (isinstance(event, ScalarEvent) and event.anchor is None 
    431                 and event.tag is None and event.implicit and event.value == u'') 
     431                and event.tag is None and event.implicit and event.value == '') 
    432432 
    433433    def check_simple_key(self): 
     
    474474                return 
    475475            if self.event.implicit[0] and tag is None: 
    476                 tag = u'!' 
     476                tag = '!' 
    477477                self.prepared_tag = None 
    478478        else: 
     
    537537        if major != 1: 
    538538            raise EmitterError("unsupported YAML version: %d.%d" % (major, minor)) 
    539         return u'%d.%d' % (major, minor) 
     539        return '%d.%d' % (major, minor) 
    540540 
    541541    def prepare_tag_handle(self, handle): 
    542542        if not handle: 
    543543            raise EmitterError("tag handle must not be empty") 
    544         if handle[0] != u'!' or handle[-1] != u'!': 
    545             raise EmitterError("tag handle must start and end with '!': %r" 
    546                     % (handle.encode('utf-8'))) 
     544        if handle[0] != '!' or handle[-1] != '!': 
     545            raise EmitterError("tag handle must start and end with '!': %r" % handle) 
    547546        for ch in handle[1:-1]: 
    548             if not (u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'    \ 
    549                     or ch in u'-_'): 
     547            if not ('0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'    \ 
     548                    or ch in '-_'): 
    550549                raise EmitterError("invalid character %r in the tag handle: %r" 
    551                         % (ch.encode('utf-8'), handle.encode('utf-8'))) 
     550                        % (ch, handle)) 
    552551        return handle 
    553552 
     
    557556        chunks = [] 
    558557        start = end = 0 
    559         if prefix[0] == u'!': 
     558        if prefix[0] == '!': 
    560559            end = 1 
    561560        while end < len(prefix): 
    562561            ch = prefix[end] 
    563             if u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z' \ 
    564                     or ch in u'-;/?!:@&=+$,_.~*\'()[]': 
     562            if '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ 
     563                    or ch in '-;/?!:@&=+$,_.~*\'()[]': 
    565564                end += 1 
    566565            else: 
     
    570569                data = ch.encode('utf-8') 
    571570                for ch in data: 
    572                     chunks.append(u'%%%02X' % ord(ch)) 
     571                    chunks.append('%%%02X' % ord(ch)) 
    573572        if start < end: 
    574573            chunks.append(prefix[start:end]) 
    575         return u''.join(chunks) 
     574        return ''.join(chunks) 
    576575 
    577576    def prepare_tag(self, tag): 
    578577        if not tag: 
    579578            raise EmitterError("tag must not be empty") 
    580         if tag == u'!': 
     579        if tag == '!': 
    581580            return tag 
    582581        handle = None 
     
    584583        for prefix in self.tag_prefixes: 
    585584            if tag.startswith(prefix)   \ 
    586                     and (prefix == u'!' or len(prefix) < len(tag)): 
     585                    and (prefix == '!' or len(prefix) < len(tag)): 
    587586                handle = self.tag_prefixes[prefix] 
    588587                suffix = tag[len(prefix):] 
     
    591590        while end < len(suffix): 
    592591            ch = suffix[end] 
    593             if u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z' \ 
    594                     or ch in u'-;/?:@&=+$,_.~*\'()[]'   \ 
    595                     or (ch == u'!' and handle != u'!'): 
     592            if '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ 
     593                    or ch in '-;/?:@&=+$,_.~*\'()[]'   \ 
     594                    or (ch == '!' and handle != '!'): 
    596595                end += 1 
    597596            else: 
     
    601600                data = ch.encode('utf-8') 
    602601                for ch in data: 
    603                     chunks.append(u'%%%02X' % ord(ch)) 
     602                    chunks.append('%%%02X' % ord(ch)) 
    604603        if start < end: 
    605604            chunks.append(suffix[start:end]) 
    606         suffix_text = u''.join(chunks) 
     605        suffix_text = ''.join(chunks) 
    607606        if handle: 
    608             return u'%s%s' % (handle, suffix_text) 
    609         else: 
    610             return u'!<%s>' % suffix_text 
     607            return '%s%s' % (handle, suffix_text) 
     608        else: 
     609            return '!<%s>' % suffix_text 
    611610 
    612611    def prepare_anchor(self, anchor): 
     
    614613            raise EmitterError("anchor must not be empty") 
    615614        for ch in anchor: 
    616             if not (u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'    \ 
    617                     or ch in u'-_'): 
     615            if not ('0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'    \ 
     616                    or ch in '-_'): 
    618617                raise EmitterError("invalid character %r in the anchor: %r" 
    619                         % (ch.encode('utf-8'), anchor.encode('utf-8'))) 
     618                        % (ch, anchor)) 
    620619        return anchor 
    621620 
     
    644643 
    645644        # Check document indicators. 
    646         if scalar.startswith(u'---') or scalar.startswith(u'...'): 
     645        if scalar.startswith('---') or scalar.startswith('...'): 
    647646            block_indicators = True 
    648647            flow_indicators = True 
     
    653652        # Last character or followed by a whitespace. 
    654653        followed_by_whitespace = (len(scalar) == 1 or 
    655                 scalar[1] in u'\0 \t\r\n\x85\u2028\u2029') 
     654                scalar[1] in '\0 \t\r\n\x85\u2028\u2029') 
    656655 
    657656        # The previous character is a space. 
     
    668667            if index == 0: 
    669668                # Leading indicators are special characters. 
    670                 if ch in u'#,[]{}&*!|>\'\"%@`':  
     669                if ch in '#,[]{}&*!|>\'\"%@`':  
    671670                    flow_indicators = True 
    672671                    block_indicators = True 
    673                 if ch in u'?:': 
     672                if ch in '?:': 
    674673                    flow_indicators = True 
    675674                    if followed_by_whitespace: 
    676675                        block_indicators = True 
    677                 if ch == u'-' and followed_by_whitespace: 
     676                if ch == '-' and followed_by_whitespace: 
    678677                    flow_indicators = True 
    679678                    block_indicators = True 
    680679            else: 
    681680                # Some indicators cannot appear within a scalar as well. 
    682                 if ch in u',?[]{}': 
     681                if ch in ',?[]{}': 
    683682                    flow_indicators = True 
    684                 if ch == u':': 
     683                if ch == ':': 
    685684                    flow_indicators = True 
    686685                    if followed_by_whitespace: 
    687686                        block_indicators = True 
    688                 if ch == u'#' and preceeded_by_whitespace: 
     687                if ch == '#' and preceeded_by_whitespace: 
    689688                    flow_indicators = True 
    690689                    block_indicators = True 
    691690 
    692691            # Check for line breaks, special, and unicode characters. 
    693             if ch in u'\n\x85\u2028\u2029': 
     692            if ch in '\n\x85\u2028\u2029': 
    694693                line_breaks = True 
    695             if not (ch == u'\n' or u'\x20' <= ch <= u'\x7E'): 
    696                 if (ch == u'\x85' or u'\xA0' <= ch <= u'\uD7FF' 
    697                         or u'\uE000' <= ch <= u'\uFFFD') and ch != u'\uFEFF': 
     694            if not (ch == '\n' or '\x20' <= ch <= '\x7E'): 
     695                if (ch == '\x85' or '\xA0' <= ch <= '\uD7FF' 
     696                        or '\uE000' <= ch <= '\uFFFD') and ch != '\uFEFF': 
    698697                    unicode_characters = True 
    699698                    if not self.allow_unicode: 
     
    703702 
    704703            # Detect important whitespace combinations. 
    705             if ch == u' ': 
     704            if ch == ' ': 
    706705                if index == 0: 
    707706                    leading_space = True 
     
    712711                previous_space = True 
    713712                previous_break = False 
    714             elif ch in u'\n\x85\u2028\u2029': 
     713            elif ch in '\n\x85\u2028\u2029': 
    715714                if index == 0: 
    716715                    leading_break = True 
     
    727726            # Prepare for the next character. 
    728727            index += 1 
    729             preceeded_by_whitespace = (ch in u'\0 \t\r\n\x85\u2028\u2029') 
     728            preceeded_by_whitespace = (ch in '\0 \t\r\n\x85\u2028\u2029') 
    730729            followed_by_whitespace = (index+1 >= len(scalar) or 
    731                     scalar[index+1] in u'\0 \t\r\n\x85\u2028\u2029') 
     730                    scalar[index+1] in '\0 \t\r\n\x85\u2028\u2029') 
    732731 
    733732        # Let's decide what styles are allowed. 
     
    788787        # Write BOM if needed. 
    789788        if self.encoding and self.encoding.startswith('utf-16'): 
    790             self.stream.write(u'\xFF\xFE'.encode(self.encoding)) 
     789            self.stream.write('\xFF\xFE'.encode(self.encoding)) 
    791790 
    792791    def write_stream_end(self): 
     
    798797            data = indicator 
    799798        else: 
    800             data = u' '+indicator 
     799            data = ' '+indicator 
    801800        self.whitespace = whitespace 
    802801        self.indention = self.indention and indention 
     
    814813        if self.column < indent: 
    815814            self.whitespace = True 
    816             data = u' '*(indent-self.column) 
     815            data = ' '*(indent-self.column) 
    817816            self.column = indent 
    818817            if self.encoding: 
     
    832831 
    833832    def write_version_directive(self, version_text): 
    834         data = u'%%YAML %s' % version_text 
     833        data = '%%YAML %s' % version_text 
    835834        if self.encoding: 
    836835            data = data.encode(self.encoding) 
     
    839838 
    840839    def write_tag_directive(self, handle_text, prefix_text): 
    841         data = u'%%TAG %s %s' % (handle_text, prefix_text) 
     840        data = '%%TAG %s %s' % (handle_text, prefix_text) 
    842841        if self.encoding: 
    843842            data = data.encode(self.encoding) 
     
    848847 
    849848    def write_single_quoted(self, text, split=True): 
    850         self.write_indicator(u'\'', True) 
     849        self.write_indicator('\'', True) 
    851850        spaces = False 
    852851        breaks = False 
     
    857856                ch = text[end] 
    858857            if spaces: 
    859                 if ch is None or ch != u' ': 
     858                if ch is None or ch != ' ': 
    860859                    if start+1 == end and self.column > self.best_width and split   \ 
    861860                            and start != 0 and end != len(text): 
     
    869868                    start = end 
    870869            elif breaks: 
    871                 if ch is None or ch not in u'\n\x85\u2028\u2029': 
    872                     if text[start] == u'\n': 
     870                if ch is None or ch not in '\n\x85\u2028\u2029': 
     871                    if text[start] == '\n': 
    873872                        self.write_line_break() 
    874873                    for br in text[start:end]: 
    875                         if br == u'\n': 
     874                        if br == '\n': 
    876875                            self.write_line_break() 
    877876                        else: 
     
    880879                    start = end 
    881880            else: 
    882                 if ch is None or ch in u' \n\x85\u2028\u2029' or ch == u'\'': 
     881                if ch is None or ch in ' \n\x85\u2028\u2029' or ch == '\'': 
    883882                    if start < end: 
    884883                        data = text[start:end] 
     
    888887                        self.stream.write(data) 
    889888                        start = end 
    890             if ch == u'\'': 
    891                 data = u'\'\'' 
     889            if ch == '\'': 
     890                data = '\'\'' 
    892891                self.column += 2 
    893892                if self.encoding: 
     
    896895                start = end + 1 
    897896            if ch is not None: 
    898                 spaces = (ch == u' ') 
    899                 breaks = (ch in u'\n\x85\u2028\u2029') 
     897                spaces = (ch == ' ') 
     898                breaks = (ch in '\n\x85\u2028\u2029') 
    900899            end += 1 
    901         self.write_indicator(u'\'', False) 
     900        self.write_indicator('\'', False) 
    902901 
    903902    ESCAPE_REPLACEMENTS = { 
    904         u'\0':      u'0', 
    905         u'\x07':    u'a', 
    906         u'\x08':    u'b', 
    907         u'\x09':    u't', 
    908         u'\x0A':    u'n', 
    909         u'\x0B':    u'v', 
    910         u'\x0C':    u'f', 
    911         u'\x0D':    u'r', 
    912         u'\x1B':    u'e', 
    913         u'\"':      u'\"', 
    914         u'\\':      u'\\', 
    915         u'\x85':    u'N', 
    916         u'\xA0':    u'_', 
    917         u'\u2028':  u'L', 
    918         u'\u2029':  u'P', 
     903        '\0':       '0', 
     904        '\x07':     'a', 
     905        '\x08':     'b', 
     906        '\x09':     't', 
     907        '\x0A':     'n', 
     908        '\x0B':     'v', 
     909        '\x0C':     'f', 
     910        '\x0D':     'r', 
     911        '\x1B':     'e', 
     912        '\"':       '\"', 
     913        '\\':       '\\', 
     914        '\x85':     'N', 
     915        '\xA0':     '_', 
     916        '\u2028':   'L', 
     917        '\u2029':   'P', 
    919918    } 
    920919 
    921920    def write_double_quoted(self, text, split=True): 
    922         self.write_indicator(u'"', True) 
     921        self.write_indicator('"', True) 
    923922        start = end = 0 
    924923        while end <= len(text): 
     
    926925            if end < len(text): 
    927926                ch = text[end] 
    928             if ch is None or ch in u'"\\\x85\u2028\u2029\uFEFF' \ 
    929                     or not (u'\x20' <= ch <= u'\x7E' 
     927            if ch is None or ch in '"\\\x85\u2028\u2029\uFEFF' \ 
     928                    or not ('\x20' <= ch <= '\x7E' 
    930929                        or (self.allow_unicode 
    931                             and (u'\xA0' <= ch <= u'\uD7FF' 
    932                                 or u'\uE000' <= ch <= u'\uFFFD'))): 
     930                            and ('\xA0' <= ch <= '\uD7FF' 
     931                                or '\uE000' <= ch <= '\uFFFD'))): 
    933932                if start < end: 
    934933                    data = text[start:end] 
     
    940939                if ch is not None: 
    941940                    if ch in self.ESCAPE_REPLACEMENTS: 
    942                         data = u'\\'+self.ESCAPE_REPLACEMENTS[ch] 
    943                     elif ch <= u'\xFF': 
    944                         data = u'\\x%02X' % ord(ch) 
    945                     elif ch <= u'\uFFFF': 
    946                         data = u'\\u%04X' % ord(ch) 
     941                        data = '\\'+self.ESCAPE_REPLACEMENTS[ch] 
     942                    elif ch <= '\xFF': 
     943                        data = '\\x%02X' % ord(ch) 
     944                    elif ch <= '\uFFFF': 
     945                        data = '\\u%04X' % ord(ch) 
    947946                    else: 
    948                         data = u'\\U%08X' % ord(ch) 
     947                        data = '\\U%08X' % ord(ch) 
    949948                    self.column += len(data) 
    950949                    if self.encoding: 
     
    952951                    self.stream.write(data) 
    953952                    start = end+1 
    954             if 0 < end < len(text)-1 and (ch == u' ' or start >= end)   \ 
     953            if 0 < end < len(text)-1 and (ch == ' ' or start >= end)    \ 
    955954                    and self.column+(end-start) > self.best_width and split: 
    956                 data = text[start:end]+u'\\' 
     955                data = text[start:end]+'\\' 
    957956                if start < end: 
    958957                    start = end 
     
    964963                self.whitespace = False 
    965964                self.indention = False 
    966                 if text[start] == u' ': 
    967                     data = u'\\' 
     965                if text[start] == ' ': 
     966                    data = '\\' 
    968967                    self.column += len(data) 
    969968                    if self.encoding: 
     
    971970                    self.stream.write(data) 
    972971            end += 1 
    973         self.write_indicator(u'"', False) 
     972        self.write_indicator('"', False) 
    974973 
    975974    def determine_block_hints(self, text): 
    976         hints = u'' 
     975        hints = '' 
    977976        if text: 
    978             if text[0] in u' \n\x85\u2028\u2029': 
    979                 hints += unicode(self.best_indent) 
    980             if text[-1] not in u'\n\x85\u2028\u2029': 
    981                 hints += u'-' 
    982             elif len(text) == 1 or text[-2] in u'\n\x85\u2028\u2029': 
    983                 hints += u'+' 
     977            if text[0] in ' \n\x85\u2028\u2029': 
     978                hints += str(self.best_indent) 
     979            if text[-1] not in '\n\x85\u2028\u2029': 
     980                hints += '-' 
     981            elif len(text) == 1 or text[-2] in '\n\x85\u2028\u2029': 
     982                hints += '+' 
    984983        return hints 
    985984 
    986985    def write_folded(self, text): 
    987986        hints = self.determine_block_hints(text) 
    988         self.write_indicator(u'>'+hints, True) 
    989         if hints[-1:] == u'+': 
     987        self.write_indicator('>'+hints, True) 
     988        if hints[-1:] == '+': 
    990989            self.open_ended = True 
    991990        self.write_line_break() 
     
    999998                ch = text[end] 
    1000999            if breaks: 
    1001                 if ch is None or ch not in u'\n\x85\u2028\u2029': 
    1002                     if not leading_space and ch is not None and ch != u' '  \ 
    1003                             and text[start] == u'\n': 
     1000                if ch is None or ch not in '\n\x85\u2028\u2029': 
     1001                    if not leading_space and ch is not None and ch != ' '   \ 
     1002                            and text[start] == '\n': 
    10041003                        self.write_line_break() 
    1005                     leading_space = (ch == u' ') 
     1004                    leading_space = (ch == ' ') 
    10061005                    for br in text[start:end]: 
    1007                         if br == u'\n': 
     1006                        if br == '\n': 
    10081007                            self.write_line_break() 
    10091008                        else: 
     
    10131012                    start = end 
    10141013            elif spaces: 
    1015                 if ch != u' ': 
     1014                if ch != ' ': 
    10161015                    if start+1 == end and self.column > self.best_width: 
    10171016                        self.write_indent() 
     
    10241023                    start = end 
    10251024            else: 
    1026                 if ch is None or ch in u' \n\x85\u2028\u2029': 
     1025                if ch is None or ch in ' \n\x85\u2028\u2029': 
    10271026                    data = text[start:end] 
    10281027                    if self.encoding: 
     
    10331032                    start = end 
    10341033            if ch is not None: 
    1035                 breaks = (ch in u'\n\x85\u2028\u2029') 
    1036                 spaces = (ch == u' ') 
     1034                breaks = (ch in '\n\x85\u2028\u2029') 
     1035                spaces = (ch == ' ') 
    10371036            end += 1 
    10381037 
    10391038    def write_literal(self, text): 
    10401039        hints = self.determine_block_hints(text) 
    1041         self.write_indicator(u'|'+hints, True) 
    1042         if hints[-1:] == u'+': 
     1040        self.write_indicator('|'+hints, True) 
     1041        if hints[-1:] == '+': 
    10431042            self.open_ended = True 
    10441043        self.write_line_break() 
     
    10501049                ch = text[end] 
    10511050            if breaks: 
    1052                 if ch is None or ch not in u'\n\x85\u2028\u2029': 
     1051                if ch is None or ch not in '\n\x85\u2028\u2029': 
    10531052                    for br in text[start:end]: 
    1054                         if br == u'\n': 
     1053                        if br == '\n': 
    10551054                            self.write_line_break() 
    10561055                        else: 
     
    10601059                    start = end 
    10611060            else: 
    1062                 if ch is None or ch in u'\n\x85\u2028\u2029': 
     1061                if ch is None or ch in '\n\x85\u2028\u2029': 
    10631062                    data = text[start:end] 
    10641063                    if self.encoding: 
     
    10691068                    start = end 
    10701069            if ch is not None: 
    1071                 breaks = (ch in u'\n\x85\u2028\u2029') 
     1070                breaks = (ch in '\n\x85\u2028\u2029') 
    10721071            end += 1 
    10731072 
     
    10781077            return 
    10791078        if not self.whitespace: 
    1080             data = u' ' 
     1079            data = ' ' 
    10811080            self.column += len(data) 
    10821081            if self.encoding: 
     
    10931092                ch = text[end] 
    10941093            if spaces: 
    1095                 if ch != u' ': 
     1094                if ch != ' ': 
    10961095                    if start+1 == end and self.column > self.best_width and split: 
    10971096                        self.write_indent() 
     
    11061105                    start = end 
    11071106            elif breaks: 
    1108                 if ch not in u'\n\x85\u2028\u2029': 
    1109                     if text[start] == u'\n': 
     1107                if ch not in '\n\x85\u2028\u2029': 
     1108                    if text[start] == '\n': 
    11101109                        self.write_line_break() 
    11111110                    for br in text[start:end]: 
    1112                         if br == u'\n': 
     1111                        if br == '\n': 
    11131112                            self.write_line_break() 
    11141113                        else: 
     
    11191118                    start = end 
    11201119            else: 
    1121                 if ch is None or ch in u' \n\x85\u2028\u2029': 
     1120                if ch is None or ch in ' \n\x85\u2028\u2029': 
    11221121                    data = text[start:end] 
    11231122                    self.column += len(data) 
     
    11271126                    start = end 
    11281127            if ch is not None: 
    1129                 spaces = (ch == u' ') 
    1130                 breaks = (ch in u'\n\x85\u2028\u2029') 
     1128                spaces = (ch == ' ') 
     1129                breaks = (ch in '\n\x85\u2028\u2029') 
    11311130            end += 1 
    11321131 
Note: See TracChangeset for help on using the changeset viewer.