Ticket #74: python3000.patch

File python3000.patch, 175.1 KB (added by idadesub@…, 5 years ago)

update the original patch to python 3.0b3.

  • lib/yaml/__init__.py 

    diff --git lib/yaml/__init__.py lib/yaml/__init__.py
index e131795..2a568a3 100644
     
     1import io 
    12 
    2 from error import * 
     3from yaml.error import * 
    34 
    4 from tokens import * 
    5 from events import * 
    6 from nodes import * 
     5from yaml.tokens import * 
     6from yaml.events import * 
     7from yaml.nodes import * 
    78 
    8 from loader import * 
    9 from dumper import * 
     9from yaml.loader import * 
     10from yaml.dumper import * 
    1011 
    1112try: 
    12     from cyaml import * 
     13    from yaml.cyaml import * 
    1314except ImportError: 
    1415    pass 
    1516 
    … … def emit(events, stream=None, Dumper=Dumper, 
    8889    """ 
    8990    getvalue = None 
    9091    if stream is None: 
    91         try: 
    92             from cStringIO import StringIO 
    93         except ImportError: 
    94             from StringIO import StringIO 
    95         stream = StringIO() 
     92        stream = io.StringIO() 
    9693        getvalue = stream.getvalue 
    9794    dumper = Dumper(stream, canonical=canonical, indent=indent, width=width, 
    9895            allow_unicode=allow_unicode, line_break=line_break) 
    … … def serialize_all(nodes, stream=None, Dumper=Dumper, 
    112109    """ 
    113110    getvalue = None 
    114111    if stream is None: 
    115         try: 
    116             from cStringIO import StringIO 
    117         except ImportError: 
    118             from StringIO import StringIO 
    119         stream = StringIO() 
     112        stream = io.StringIO() 
    120113        getvalue = stream.getvalue 
    121114    dumper = Dumper(stream, canonical=canonical, indent=indent, width=width, 
    122115            allow_unicode=allow_unicode, line_break=line_break, 
    … … def dump_all(documents, stream=None, Dumper=Dumper, 
    148141    """ 
    149142    getvalue = None 
    150143    if stream is None: 
    151         try: 
    152             from cStringIO import StringIO 
    153         except ImportError: 
    154             from StringIO import StringIO 
    155         stream = StringIO() 
     144        stream = io.StringIO() 
    156145        getvalue = stream.getvalue 
    157146    dumper = Dumper(stream, default_style=default_style, 
    158147            default_flow_style=default_flow_style, 
    … … class YAMLObjectMetaclass(type): 
    256245            cls.yaml_loader.add_constructor(cls.yaml_tag, cls.from_yaml) 
    257246            cls.yaml_dumper.add_representer(cls, cls.to_yaml) 
    258247 
    259 class YAMLObject(object): 
     248class YAMLObject(metaclass=YAMLObjectMetaclass): 
    260249    """ 
    261250    An object that can dump itself to a YAML stream 
    262251    and load itself from a YAML stream. 
    263252    """ 
    264253 
    265     __metaclass__ = YAMLObjectMetaclass 
    266254    __slots__ = ()  # no direct instantiation, so allow immutable subclasses 
    267255 
    268256    yaml_loader = Loader 

  • lib/yaml/composer.py 

    diff --git lib/yaml/composer.py lib/yaml/composer.py
index 06e5ac7..f468cc5 100644
     
    11 
    22__all__ = ['Composer', 'ComposerError'] 
    33 
    4 from error import MarkedYAMLError 
    5 from events import * 
    6 from nodes import * 
     4from yaml.error import MarkedYAMLError 
     5from yaml.events import * 
     6from yaml.nodes import * 
    77 
    88class ComposerError(MarkedYAMLError): 
    99    pass 
    1010 
    11 class Composer(object): 
     11class Composer: 
    1212 
    1313    def __init__(self): 
    1414        self.anchors = {} 
    … … class Composer(object): 
    8888    def compose_scalar_node(self, anchor): 
    8989        event = self.get_event() 
    9090        tag = event.tag 
    91         if tag is None or tag == u'!': 
     91        if tag is None or tag == '!': 
    9292            tag = self.resolve(ScalarNode, event.value, event.implicit) 
    9393        node = ScalarNode(tag, event.value, 
    9494                event.start_mark, event.end_mark, style=event.style) 
    … … class Composer(object): 
    9999    def compose_sequence_node(self, anchor): 
    100100        start_event = self.get_event() 
    101101        tag = start_event.tag 
    102         if tag is None or tag == u'!': 
     102        if tag is None or tag == '!': 
    103103            tag = self.resolve(SequenceNode, None, start_event.implicit) 
    104104        node = SequenceNode(tag, [], 
    105105                start_event.start_mark, None, 
    … … class Composer(object): 
    117117    def compose_mapping_node(self, anchor): 
    118118        start_event = self.get_event() 
    119119        tag = start_event.tag 
    120         if tag is None or tag == u'!': 
     120        if tag is None or tag == '!': 
    121121            tag = self.resolve(MappingNode, None, start_event.implicit) 
    122122        node = MappingNode(tag, [], 
    123123                start_event.start_mark, None, 

  • lib/yaml/constructor.py 

    diff --git lib/yaml/constructor.py lib/yaml/constructor.py
index 34cc226..cb51483 100644
     
    22__all__ = ['BaseConstructor', 'SafeConstructor', 'Constructor', 
    33    'ConstructorError'] 
    44 
    5 from error import * 
    6 from nodes import * 
     5from yaml.error import * 
     6from yaml.nodes import * 
    77 
    88import datetime 
    99 
    10 try: 
    11     set 
    12 except NameError: 
    13     from sets import Set as set 
    14  
    15 import binascii, re, sys, types 
     10import binascii, re, sys, types, base64 
    1611 
    1712class ConstructorError(MarkedYAMLError): 
    1813    pass 
    1914 
    20 class BaseConstructor(object): 
     15class BaseConstructor: 
    2116 
    2217    yaml_constructors = {} 
    2318    yaml_multi_constructors = {} 
    … … class BaseConstructor(object): 
    9691            data = constructor(self, tag_suffix, node) 
    9792        if isinstance(data, types.GeneratorType): 
    9893            generator = data 
    99             data = generator.next() 
     94            data = next(generator) 
    10095            if self.deep_construct: 
    10196                for dummy in generator: 
    10297                    pass 
    … … class BaseConstructor(object): 
    133128            key = self.construct_object(key_node, deep=deep) 
    134129            try: 
    135130                hash(key) 
    136             except TypeError, exc: 
     131            except TypeError as exc: 
    137132                raise ConstructorError("while constructing a mapping", node.start_mark, 
    138133                        "found unacceptable key (%s)" % exc, key_node.start_mark) 
    139134            value = self.construct_object(value_node, deep=deep) 
    … … class SafeConstructor(BaseConstructor): 
    169164    def construct_scalar(self, node): 
    170165        if isinstance(node, MappingNode): 
    171166            for key_node, value_node in node.value: 
    172                 if key_node.tag == u'tag:yaml.org,2002:value': 
     167                if key_node.tag == 'tag:yaml.org,2002:value': 
    173168                    return self.construct_scalar(value_node) 
    174169        return BaseConstructor.construct_scalar(self, node) 
    175170 
    … … class SafeConstructor(BaseConstructor): 
    178173        index = 0 
    179174        while index < len(node.value): 
    180175            key_node, value_node = node.value[index] 
    181             if key_node.tag == u'tag:yaml.org,2002:merge': 
     176            if key_node.tag == 'tag:yaml.org,2002:merge': 
    182177                del node.value[index] 
    183178                if isinstance(value_node, MappingNode): 
    184179                    self.flatten_mapping(value_node) 
    … … class SafeConstructor(BaseConstructor): 
    200195                    raise ConstructorError("while constructing a mapping", node.start_mark, 
    201196                            "expected a mapping or list of mappings for merging, but found %s" 
    202197                            % value_node.id, value_node.start_mark) 
    203             elif key_node.tag == u'tag:yaml.org,2002:value': 
    204                 key_node.tag = u'tag:yaml.org,2002:str' 
     198            elif key_node.tag == 'tag:yaml.org,2002:value': 
     199                key_node.tag = 'tag:yaml.org,2002:str' 
    205200                index += 1 
    206201            else: 
    207202                index += 1 
    … … class SafeConstructor(BaseConstructor): 
    218213        return None 
    219214 
    220215    bool_values = { 
    221         u'yes':     True, 
    222         u'no':      False, 
    223         u'true':    True, 
    224         u'false':   False, 
    225         u'on':      True, 
    226         u'off':     False, 
     216        'yes':     True, 
     217        'no':      False, 
     218        'true':    True, 
     219        'false':   False, 
     220        'on':      True, 
     221        'off':     False, 
    227222    } 
    228223 
    229224    def construct_yaml_bool(self, node): 
    … … class SafeConstructor(BaseConstructor): 
    290285    def construct_yaml_binary(self, node): 
    291286        value = self.construct_scalar(node) 
    292287        try: 
    293             return str(value).decode('base64') 
    294         except (binascii.Error, UnicodeEncodeError), exc: 
     288            return base64.decodestring(value.encode('utf-8')) 
     289        except (binascii.Error, UnicodeEncodeError) as exc: 
    295290            raise ConstructorError(None, None, 
    296291                    "failed to decode base64 data: %s" % exc, node.start_mark)  
    297292 
    298293    timestamp_regexp = re.compile( 
    299             ur'''^(?P<year>[0-9][0-9][0-9][0-9]) 
     294            r'''^(?P<year>[0-9][0-9][0-9][0-9]) 
    300295                -(?P<month>[0-9][0-9]?) 
    301296                -(?P<day>[0-9][0-9]?) 
    302297                (?:(?:[Tt]|[ \t]+) 
    … … class SafeConstructor(BaseConstructor): 
    387382        data.update(value) 
    388383 
    389384    def construct_yaml_str(self, node): 
    390         value = self.construct_scalar(node) 
    391         try: 
    392             return value.encode('ascii') 
    393         except UnicodeEncodeError: 
    394             return value 
     385        return self.construct_scalar(node) 
    395386 
    396387    def construct_yaml_seq(self, node): 
    397388        data = [] 
    … … class SafeConstructor(BaseConstructor): 
    416407 
    417408    def construct_undefined(self, node): 
    418409        raise ConstructorError(None, None, 
    419                 "could not determine a constructor for the tag %r" % node.tag.encode('utf-8'), 
     410                "could not determine a constructor for the tag %r" % node.tag, 
    420411                node.start_mark) 
    421412 
    422413SafeConstructor.add_constructor( 
    423         u'tag:yaml.org,2002:null', 
     414        'tag:yaml.org,2002:null', 
    424415        SafeConstructor.construct_yaml_null) 
    425416 
    426417SafeConstructor.add_constructor( 
    427         u'tag:yaml.org,2002:bool', 
     418        'tag:yaml.org,2002:bool', 
    428419        SafeConstructor.construct_yaml_bool) 
    429420 
    430421SafeConstructor.add_constructor( 
    431         u'tag:yaml.org,2002:int', 
     422        'tag:yaml.org,2002:int', 
    432423        SafeConstructor.construct_yaml_int) 
    433424 
    434425SafeConstructor.add_constructor( 
    435         u'tag:yaml.org,2002:float', 
     426        'tag:yaml.org,2002:float', 
    436427        SafeConstructor.construct_yaml_float) 
    437428 
    438429SafeConstructor.add_constructor( 
    439         u'tag:yaml.org,2002:binary', 
     430        'tag:yaml.org,2002:binary', 
    440431        SafeConstructor.construct_yaml_binary) 
    441432 
    442433SafeConstructor.add_constructor( 
    443         u'tag:yaml.org,2002:timestamp', 
     434        'tag:yaml.org,2002:timestamp', 
    444435        SafeConstructor.construct_yaml_timestamp) 
    445436 
    446437SafeConstructor.add_constructor( 
    447         u'tag:yaml.org,2002:omap', 
     438        'tag:yaml.org,2002:omap', 
    448439        SafeConstructor.construct_yaml_omap) 
    449440 
    450441SafeConstructor.add_constructor( 
    451         u'tag:yaml.org,2002:pairs', 
     442        'tag:yaml.org,2002:pairs', 
    452443        SafeConstructor.construct_yaml_pairs) 
    453444 
    454445SafeConstructor.add_constructor( 
    455         u'tag:yaml.org,2002:set', 
     446        'tag:yaml.org,2002:set', 
    456447        SafeConstructor.construct_yaml_set) 
    457448 
    458449SafeConstructor.add_constructor( 
    459         u'tag:yaml.org,2002:str', 
     450        'tag:yaml.org,2002:str', 
    460451        SafeConstructor.construct_yaml_str) 
    461452 
    462453SafeConstructor.add_constructor( 
    463         u'tag:yaml.org,2002:seq', 
     454        'tag:yaml.org,2002:seq', 
    464455        SafeConstructor.construct_yaml_seq) 
    465456 
    466457SafeConstructor.add_constructor( 
    467         u'tag:yaml.org,2002:map', 
     458        'tag:yaml.org,2002:map', 
    468459        SafeConstructor.construct_yaml_map) 
    469460 
    470461SafeConstructor.add_constructor(None, 
    … … SafeConstructor.add_constructor(None, 
    473464class Constructor(SafeConstructor): 
    474465 
    475466    def construct_python_str(self, node): 
    476         return self.construct_scalar(node).encode('utf-8') 
     467        return self.construct_scalar(node) 
    477468 
    478469    def construct_python_unicode(self, node): 
    479470        return self.construct_scalar(node) 
    480471 
     472    def construct_python_bytes(self, node): 
     473        return self.construct_scalar(node).encode('utf-8') 
     474 
    481475    def construct_python_long(self, node): 
    482         return long(self.construct_yaml_int(node)) 
     476        return self.construct_yaml_int(node) 
    483477 
    484478    def construct_python_complex(self, node): 
    485479       return complex(self.construct_scalar(node)) 
    … … class Constructor(SafeConstructor): 
    493487                    "expected non-empty name appended to the tag", mark) 
    494488        try: 
    495489            __import__(name) 
    496         except ImportError, exc: 
     490        except ImportError as exc: 
    497491            raise ConstructorError("while constructing a Python module", mark, 
    498                     "cannot find module %r (%s)" % (name.encode('utf-8'), exc), mark) 
     492                    "cannot find module %r (%s)" % (name, exc), mark) 
    499493        return sys.modules[name] 
    500494 
    501495    def find_python_name(self, name, mark): 
    502496        if not name: 
    503497            raise ConstructorError("while constructing a Python object", mark, 
    504498                    "expected non-empty name appended to the tag", mark) 
    505         if u'.' in name: 
    506             # Python 2.4 only 
    507             #module_name, object_name = name.rsplit('.', 1) 
    508             items = name.split('.') 
    509             object_name = items.pop() 
    510             module_name = '.'.join(items) 
     499        if '.' in name: 
     500            module_name, object_name = name.rsplit('.', 1) 
    511501        else: 
    512             module_name = '__builtin__' 
     502            module_name = 'builtins' 
    513503            object_name = name 
    514504        try: 
    515505            __import__(module_name) 
    516         except ImportError, exc: 
     506        except ImportError as exc: 
    517507            raise ConstructorError("while constructing a Python object", mark, 
    518                     "cannot find module %r (%s)" % (module_name.encode('utf-8'), exc), mark) 
     508                    "cannot find module %r (%s)" % (module_name, exc), mark) 
    519509        module = sys.modules[module_name] 
    520510        if not hasattr(module, object_name): 
    521511            raise ConstructorError("while constructing a Python object", mark, 
    522                     "cannot find %r in the module %r" % (object_name.encode('utf-8'), 
     512                    "cannot find %r in the module %r" % (object_name, 
    523513                        module.__name__), mark) 
    524514        return getattr(module, object_name) 
    525515 
    … … class Constructor(SafeConstructor): 
    527517        value = self.construct_scalar(node) 
    528518        if value: 
    529519            raise ConstructorError("while constructing a Python name", node.start_mark, 
    530                     "expected the empty value, but found %r" % value.encode('utf-8'), 
     520                    "expected the empty value, but found %r" % value, 
    531521                    node.start_mark) 
    532522        return self.find_python_name(suffix, node.start_mark) 
    533523 
    … … class Constructor(SafeConstructor): 
    535525        value = self.construct_scalar(node) 
    536526        if value: 
    537527            raise ConstructorError("while constructing a Python module", node.start_mark, 
    538                     "expected the empty value, but found %r" % value.encode('utf-8'), 
     528                    "expected the empty value, but found %r" % value, 
    539529                    node.start_mark) 
    540530        return self.find_python_module(suffix, node.start_mark) 
    541531 
    542     class classobj: pass 
    543  
    544532    def make_python_instance(self, suffix, node, 
    545533            args=None, kwds=None, newobj=False): 
    546534        if not args: 
    … … class Constructor(SafeConstructor): 
    548536        if not kwds: 
    549537            kwds = {} 
    550538        cls = self.find_python_name(suffix, node.start_mark) 
    551         if newobj and isinstance(cls, type(self.classobj))  \ 
    552                 and not args and not kwds: 
    553             instance = self.classobj() 
    554             instance.__class__ = cls 
    555             return instance 
    556         elif newobj and isinstance(cls, type): 
     539        if newobj and isinstance(cls, type): 
    557540            return cls.__new__(cls, *args, **kwds) 
    558541        else: 
    559542            return cls(*args, **kwds) 
    … … class Constructor(SafeConstructor): 
    620603        return self.construct_python_object_apply(suffix, node, newobj=True) 
    621604 
    622605Constructor.add_constructor( 
    623     u'tag:yaml.org,2002:python/none', 
     606    'tag:yaml.org,2002:python/none', 
    624607    Constructor.construct_yaml_null) 
    625608 
    626609Constructor.add_constructor( 
    627     u'tag:yaml.org,2002:python/bool', 
     610    'tag:yaml.org,2002:python/bool', 
    628611    Constructor.construct_yaml_bool) 
    629612 
    630613Constructor.add_constructor( 
    631     u'tag:yaml.org,2002:python/str', 
     614    'tag:yaml.org,2002:python/str', 
    632615    Constructor.construct_python_str) 
    633616 
    634617Constructor.add_constructor( 
    635     u'tag:yaml.org,2002:python/unicode', 
     618    'tag:yaml.org,2002:python/unicode', 
    636619    Constructor.construct_python_unicode) 
    637620 
    638621Constructor.add_constructor( 
    639     u'tag:yaml.org,2002:python/int', 
     622    'tag:yaml.org,2002:python/bytes', 
     623    Constructor.construct_python_bytes) 
     624 
     625Constructor.add_constructor( 
     626    'tag:yaml.org,2002:python/int', 
    640627    Constructor.construct_yaml_int) 
    641628 
    642629Constructor.add_constructor( 
    643     u'tag:yaml.org,2002:python/long', 
     630    'tag:yaml.org,2002:python/long', 
    644631    Constructor.construct_python_long) 
    645632 
    646633Constructor.add_constructor( 
    647     u'tag:yaml.org,2002:python/float', 
     634    'tag:yaml.org,2002:python/float', 
    648635    Constructor.construct_yaml_float) 
    649636 
    650637Constructor.add_constructor( 
    651     u'tag:yaml.org,2002:python/complex', 
     638    'tag:yaml.org,2002:python/complex', 
    652639    Constructor.construct_python_complex) 
    653640 
    654641Constructor.add_constructor( 
    655     u'tag:yaml.org,2002:python/list', 
     642    'tag:yaml.org,2002:python/list', 
    656643    Constructor.construct_yaml_seq) 
    657644 
    658645Constructor.add_constructor( 
    659     u'tag:yaml.org,2002:python/tuple', 
     646    'tag:yaml.org,2002:python/tuple', 
    660647    Constructor.construct_python_tuple) 
    661648 
    662649Constructor.add_constructor( 
    663     u'tag:yaml.org,2002:python/dict', 
     650    'tag:yaml.org,2002:python/dict', 
    664651    Constructor.construct_yaml_map) 
    665652 
    666653Constructor.add_multi_constructor( 
    667     u'tag:yaml.org,2002:python/name:', 
     654    'tag:yaml.org,2002:python/name:', 
    668655    Constructor.construct_python_name) 
    669656 
    670657Constructor.add_multi_constructor( 
    671     u'tag:yaml.org,2002:python/module:', 
     658    'tag:yaml.org,2002:python/module:', 
    672659    Constructor.construct_python_module) 
    673660 
    674661Constructor.add_multi_constructor( 
    675     u'tag:yaml.org,2002:python/object:', 
     662    'tag:yaml.org,2002:python/object:', 
    676663    Constructor.construct_python_object) 
    677664 
    678665Constructor.add_multi_constructor( 
    679     u'tag:yaml.org,2002:python/object/apply:', 
     666    'tag:yaml.org,2002:python/object/apply:', 
    680667    Constructor.construct_python_object_apply) 
    681668 
    682669Constructor.add_multi_constructor( 
    683     u'tag:yaml.org,2002:python/object/new:', 
     670    'tag:yaml.org,2002:python/object/new:', 
    684671    Constructor.construct_python_object_new) 
    685672 

  • lib/yaml/dumper.py 

    diff --git lib/yaml/dumper.py lib/yaml/dumper.py
index 355c1e2..e06364c 100644
     
    11 
    22__all__ = ['BaseDumper', 'SafeDumper', 'Dumper'] 
    33 
    4 from emitter import * 
    5 from serializer import * 
    6 from representer import * 
    7 from resolver import * 
     4from yaml.emitter import * 
     5from yaml.serializer import * 
     6from yaml.representer import * 
     7from yaml.resolver import * 
    88 
    99class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver): 
    1010 

  • lib/yaml/emitter.py 

    diff --git lib/yaml/emitter.py lib/yaml/emitter.py
index d9d1bf8..17789e9 100644
     
    88 
    99__all__ = ['Emitter', 'EmitterError'] 
    1010 
    11 from error import YAMLError 
    12 from events import * 
     11from yaml.error import YAMLError 
     12from yaml.events import * 
    1313 
    1414import re 
    1515 
    1616class EmitterError(YAMLError): 
    1717    pass 
    1818 
    19 class ScalarAnalysis(object): 
     19class ScalarAnalysis: 
    2020    def __init__(self, scalar, empty, multiline, 
    2121            allow_flow_plain, allow_block_plain, 
    2222            allow_single_quoted, allow_double_quoted, 
    … … class ScalarAnalysis(object): 
    3030        self.allow_double_quoted = allow_double_quoted 
    3131        self.allow_block = allow_block 
    3232 
    33 class Emitter(object): 
     33class Emitter: 
    3434 
    3535    DEFAULT_TAG_PREFIXES = { 
    36         u'!' : u'!', 
    37         u'tag:yaml.org,2002:' : u'!!', 
     36        '!' : '!', 
     37        'tag:yaml.org,2002:' : '!!', 
    3838    } 
    3939 
    4040    def __init__(self, stream, canonical=None, indent=None, width=None, 
    … … class Emitter(object): 
    8787        self.best_width = 80 
    8888        if width and width > self.best_indent*2: 
    8989            self.best_width = width 
    90         self.best_line_break = u'\n' 
    91         if line_break in [u'\r', u'\n', u'\r\n']: 
     90        self.best_line_break = '\n' 
     91        if line_break in ['\r', '\n', '\r\n']: 
    9292            self.best_line_break = line_break 
    9393 
    9494        # Tag prefixes. 
    … … class Emitter(object): 
    176176                self.write_version_directive(version_text) 
    177177            self.tag_prefixes = self.DEFAULT_TAG_PREFIXES.copy() 
    178178            if self.event.tags: 
    179                 handles = self.event.tags.keys() 
    180                 handles.sort() 
     179                handles = sorted(self.event.tags.keys()) 
    181180                for handle in handles: 
    182181                    prefix = self.event.tags[handle] 
    183182                    self.tag_prefixes[prefix] = handle 
    … … class Emitter(object): 
    189188                    and not self.check_empty_document()) 
    190189            if not implicit: 
    191190                self.write_indent() 
    192                 self.write_indicator(u'---', True) 
     191                self.write_indicator('---', True) 
    193192                if self.canonical: 
    194193                    self.write_indent() 
    195194            self.state = self.expect_document_root 
    … … class Emitter(object): 
    204203        if isinstance(self.event, DocumentEndEvent): 
    205204            self.write_indent() 
    206205            if self.event.explicit: 
    207                 self.write_indicator(u'...', True) 
     206                self.write_indicator('...', True) 
    208207                self.write_indent() 
    209208            self.flush_stream() 
    210209            self.state = self.expect_document_start 
    … … class Emitter(object): 
    227226        if isinstance(self.event, AliasEvent): 
    228227            self.expect_alias() 
    229228        elif isinstance(self.event, (ScalarEvent, CollectionStartEvent)): 
    230             self.process_anchor(u'&') 
     229            self.process_anchor('&') 
    231230            self.process_tag() 
    232231            if isinstance(self.event, ScalarEvent): 
    233232                self.expect_scalar() 
    … … class Emitter(object): 
    249248    def expect_alias(self): 
    250249        if self.event.anchor is None: 
    251250            raise EmitterError("anchor is not specified for alias") 
    252         self.process_anchor(u'*') 
     251        self.process_anchor('*') 
    253252        self.state = self.states.pop() 
    254253 
    255254    def expect_scalar(self): 
    … … class Emitter(object): 
    261260    # Flow sequence handlers. 
    262261 
    263262    def expect_flow_sequence(self): 
    264         self.write_indicator(u'[', True, whitespace=True) 
     263        self.write_indicator('[', True, whitespace=True) 
    265264        self.flow_level += 1 
    266265        self.increase_indent(flow=True) 
    267266        self.state = self.expect_first_flow_sequence_item 
    … … class Emitter(object): 
    270269        if isinstance(self.event, SequenceEndEvent): 
    271270            self.indent = self.indents.pop() 
    272271            self.flow_level -= 1 
    273             self.write_indicator(u']', False) 
     272            self.write_indicator(']', False) 
    274273            self.state = self.states.pop() 
    275274        else: 
    276275            if self.canonical or self.column > self.best_width: 
    … … class Emitter(object): 
    283282            self.indent = self.indents.pop() 
    284283            self.flow_level -= 1 
    285284            if self.canonical: 
    286                 self.write_indicator(u',', False) 
     285                self.write_indicator(',', False) 
    287286                self.write_indent() 
    288             self.write_indicator(u']', False) 
     287            self.write_indicator(']', False) 
    289288            self.state = self.states.pop() 
    290289        else: 
    291             self.write_indicator(u',', False) 
     290            self.write_indicator(',', False) 
    292291            if self.canonical or self.column > self.best_width: 
    293292                self.write_indent() 
    294293            self.states.append(self.expect_flow_sequence_item) 
    … … class Emitter(object): 
    297296    # Flow mapping handlers. 
    298297 
    299298    def expect_flow_mapping(self): 
    300         self.write_indicator(u'{', True, whitespace=True) 
     299        self.write_indicator('{', True, whitespace=True) 
    301300        self.flow_level += 1 
    302301        self.increase_indent(flow=True) 
    303302        self.state = self.expect_first_flow_mapping_key 
    … … class Emitter(object): 
    306305        if isinstance(self.event, MappingEndEvent): 
    307306            self.indent = self.indents.pop() 
    308307            self.flow_level -= 1 
    309             self.write_indicator(u'}', False) 
     308            self.write_indicator('}', False) 
    310309            self.state = self.states.pop() 
    311310        else: 
    312311            if self.canonical or self.column > self.best_width: 
    … … class Emitter(object): 
    315314                self.states.append(self.expect_flow_mapping_simple_value) 
    316315                self.expect_node(mapping=True, simple_key=True) 
    317316            else: 
    318                 self.write_indicator(u'?', True) 
     317                self.write_indicator('?', True) 
    319318                self.states.append(self.expect_flow_mapping_value) 
    320319                self.expect_node(mapping=True) 
    321320 
    … … class Emitter(object): 
    324323            self.indent = self.indents.pop() 
    325324            self.flow_level -= 1 
    326325            if self.canonical: 
    327                 self.write_indicator(u',', False) 
     326                self.write_indicator(',', False) 
    328327                self.write_indent() 
    329             self.write_indicator(u'}', False) 
     328            self.write_indicator('}', False) 
    330329            self.state = self.states.pop() 
    331330        else: 
    332             self.write_indicator(u',', False) 
     331            self.write_indicator(',', False) 
    333332            if self.canonical or self.column > self.best_width: 
    334333                self.write_indent() 
    335334            if not self.canonical and self.check_simple_key(): 
    336335                self.states.append(self.expect_flow_mapping_simple_value) 
    337336                self.expect_node(mapping=True, simple_key=True) 
    338337            else: 
    339                 self.write_indicator(u'?', True) 
     338                self.write_indicator('?', True) 
    340339                self.states.append(self.expect_flow_mapping_value) 
    341340                self.expect_node(mapping=True) 
    342341 
    343342    def expect_flow_mapping_simple_value(self): 
    344         self.write_indicator(u':', False) 
     343        self.write_indicator(':', False) 
    345344        self.states.append(self.expect_flow_mapping_key) 
    346345        self.expect_node(mapping=True) 
    347346 
    348347    def expect_flow_mapping_value(self): 
    349348        if self.canonical or self.column > self.best_width: 
    350349            self.write_indent() 
    351         self.write_indicator(u':', True) 
     350        self.write_indicator(':', True) 
    352351        self.states.append(self.expect_flow_mapping_key) 
    353352        self.expect_node(mapping=True) 
    354353 
    … … class Emitter(object): 
    368367            self.state = self.states.pop() 
    369368        else: 
    370369            self.write_indent() 
    371             self.write_indicator(u'-', True, indention=True) 
     370            self.write_indicator('-', True, indention=True) 
    372371            self.states.append(self.expect_block_sequence_item) 
    373372            self.expect_node(sequence=True) 
    374373 
    … … class Emitter(object): 
    391390                self.states.append(self.expect_block_mapping_simple_value) 
    392391                self.expect_node(mapping=True, simple_key=True) 
    393392            else: 
    394                 self.write_indicator(u'?', True, indention=True) 
     393                self.write_indicator('?', True, indention=True) 
    395394                self.states.append(self.expect_block_mapping_value) 
    396395                self.expect_node(mapping=True) 
    397396 
    398397    def expect_block_mapping_simple_value(self): 
    399         self.write_indicator(u':', False) 
     398        self.write_indicator(':', False) 
    400399        self.states.append(self.expect_block_mapping_key) 
    401400        self.expect_node(mapping=True) 
    402401 
    403402    def expect_block_mapping_value(self): 
    404403        self.write_indent() 
    405         self.write_indicator(u':', True, indention=True) 
     404        self.write_indicator(':', True, indention=True) 
    406405        self.states.append(self.expect_block_mapping_key) 
    407406        self.expect_node(mapping=True) 
    408407 
    … … class Emitter(object): 
    421420            return False 
    422421        event = self.events[0] 
    423422        return (isinstance(event, ScalarEvent) and event.anchor is None 
    424                 and event.tag is None and event.implicit and event.value == u'') 
     423                and event.tag is None and event.implicit and event.value == '') 
    425424 
    426425    def check_simple_key(self): 
    427426        length = 0 
    … … class Emitter(object): 
    466465                self.prepared_tag = None 
    467466                return 
    468467            if self.event.implicit[0] and tag is None: 
    469                 tag = u'!' 
     468                tag = '!' 
    470469                self.prepared_tag = None 
    471470        else: 
    472471            if (not self.canonical or tag is None) and self.event.implicit: 
    … … class Emitter(object): 
    529528        major, minor = version 
    530529        if major != 1: 
    531530            raise EmitterError("unsupported YAML version: %d.%d" % (major, minor)) 
    532         return u'%d.%d' % (major, minor) 
     531        return '%d.%d' % (major, minor) 
    533532 
    534533    def prepare_tag_handle(self, handle): 
    535534        if not handle: 
    536535            raise EmitterError("tag handle must not be empty") 
    537         if handle[0] != u'!' or handle[-1] != u'!': 
     536        if handle[0] != '!' or handle[-1] != '!': 
    538537            raise EmitterError("tag handle must start and end with '!': %r" 
    539538                    % (handle.encode('utf-8'))) 
    540539        for ch in handle[1:-1]: 
    541             if not (u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'    \ 
    542                     or ch in u'-_'): 
     540            if not ('0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'    \ 
     541                    or ch in '-_'): 
    543542                raise EmitterError("invalid character %r in the tag handle: %r" 
    544543                        % (ch.encode('utf-8'), handle.encode('utf-8'))) 
    545544        return handle 
    … … class Emitter(object): 
    549548            raise EmitterError("tag prefix must not be empty") 
    550549        chunks = [] 
    551550        start = end = 0 
    552         if prefix[0] == u'!': 
     551        if prefix[0] == '!': 
    553552            end = 1 
    554553        while end < len(prefix): 
    555554            ch = prefix[end] 
    556             if u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    557                     or ch in u'-;/?!:@&=+$,_.~*\'()[]': 
     555            if '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'  \ 
     556                    or ch in '-;/?!:@&=+$,_.~*\'()[]': 
    558557                end += 1 
    559558            else: 
    560559                if start < end: 
    … … class Emitter(object): 
    562561                start = end = end+1 
    563562                data = ch.encode('utf-8') 
    564563                for ch in data: 
    565                     chunks.append(u'%%%02X' % ord(ch)) 
     564                    chunks.append('%%%02X' % ord(ch)) 
    566565        if start < end: 
    567566            chunks.append(prefix[start:end]) 
    568         return u''.join(chunks) 
     567        return ''.join(chunks) 
    569568 
    570569    def prepare_tag(self, tag): 
    571570        if not tag: 
    572571            raise EmitterError("tag must not be empty") 
    573         if tag == u'!': 
     572        if tag == '!': 
    574573            return tag 
    575574        handle = None 
    576575        suffix = tag 
    577576        for prefix in self.tag_prefixes: 
    578577            if tag.startswith(prefix)   \ 
    579                     and (prefix == u'!' or len(prefix) < len(tag)): 
     578                    and (prefix == '!' or len(prefix) < len(tag)): 
    580579                handle = self.tag_prefixes[prefix] 
    581580                suffix = tag[len(prefix):] 
    582581        chunks = [] 
    583582        start = end = 0 
    584583        while end < len(suffix): 
    585584            ch = suffix[end] 
    586             if u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    587                     or ch in u'-;/?:@&=+$,_.~*\'()[]'   \ 
    588                     or (ch == u'!' and handle != u'!'): 
     585            if '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'  \ 
     586                    or ch in '-;/?:@&=+$,_.~*\'()[]'   \ 
     587                    or (ch == '!' and handle != '!'): 
    589588                end += 1 
    590589            else: 
    591590                if start < end: 
    … … class Emitter(object): 
    593592                start = end = end+1 
    594593                data = ch.encode('utf-8') 
    595594                for ch in data: 
    596                     chunks.append(u'%%%02X' % ord(ch)) 
     595                    chunks.append('%%%02X' % ord(ch)) 
    597596        if start < end: 
    598597            chunks.append(suffix[start:end]) 
    599         suffix_text = u''.join(chunks) 
     598        suffix_text = ''.join(chunks) 
    600599        if handle: 
    601             return u'%s%s' % (handle, suffix_text) 
     600            return '%s%s' % (handle, suffix_text) 
    602601        else: 
    603             return u'!<%s>' % suffix_text 
     602            return '!<%s>' % suffix_text 
    604603 
    605604    def prepare_anchor(self, anchor): 
    606605        if not anchor: 
    607606            raise EmitterError("anchor must not be empty") 
    608607        for ch in anchor: 
    609             if not (u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'    \ 
    610                     or ch in u'-_'): 
     608            if not ('0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'    \ 
     609                    or ch in '-_'): 
    611610                raise EmitterError("invalid character %r in the anchor: %r" 
    612611                        % (ch.encode('utf-8'), anchor.encode('utf-8'))) 
    613612        return anchor 
    … … class Emitter(object): 
    638637        mixed_breaks_spaces = False    # anything else 
    639638 
    640639        # Check document indicators. 
    641         if scalar.startswith(u'---') or scalar.startswith(u'...'): 
     640        if scalar.startswith('---') or scalar.startswith('...'): 
    642641            block_indicators = True 
    643642            flow_indicators = True 
    644643 
    … … class Emitter(object): 
    647646 
    648647        # Last character or followed by a whitespace. 
    649648        followed_by_space = (len(scalar) == 1 or 
    650                 scalar[1] in u'\0 \t\r\n\x85\u2028\u2029') 
     649                scalar[1] in '\0 \t\r\n\x85\u2028\u2029') 
    651650 
    652651        # The current series of whitespaces contain plain spaces. 
    653652        spaces = False 
    … … class Emitter(object): 
    671670 
    672671            if index == 0: 
    673672                # Leading indicators are special characters. 
    674                 if ch in u'#,[]{}&*!|>\'\"%@`':  
     673                if ch in '#,[]{}&*!|>\'\"%@`':  
    675674                    flow_indicators = True 
    676675                    block_indicators = True 
    677                 if ch in u'?:': 
     676                if ch in '?:': 
    678677                    flow_indicators = True 
    679678                    if followed_by_space: 
    680679                        block_indicators = True 
    681                 if ch == u'-' and followed_by_space: 
     680                if ch == '-' and followed_by_space: 
    682681                    flow_indicators = True 
    683682                    block_indicators = True 
    684683            else: 
    685684                # Some indicators cannot appear within a scalar as well. 
    686                 if ch in u',?[]{}': 
     685                if ch in ',?[]{}': 
    687686                    flow_indicators = True 
    688                 if ch == u':': 
     687                if ch == ':': 
    689688                    flow_indicators = True 
    690689                    if followed_by_space: 
    691690                        block_indicators = True 
    692                 if ch == u'#' and preceeded_by_space: 
     691                if ch == '#' and preceeded_by_space: 
    693692                    flow_indicators = True 
    694693                    block_indicators = True 
    695694 
    696695            # Check for line breaks, special, and unicode characters. 
    697696 
    698             if ch in u'\n\x85\u2028\u2029': 
     697            if ch in '\n\x85\u2028\u2029': 
    699698                line_breaks = True 
    700             if not (ch == u'\n' or u'\x20' <= ch <= u'\x7E'): 
    701                 if (ch == u'\x85' or u'\xA0' <= ch <= u'\uD7FF' 
    702                         or u'\uE000' <= ch <= u'\uFFFD') and ch != u'\uFEFF': 
     699            if not (ch == '\n' or '\x20' <= ch <= '\x7E'): 
     700                if (ch == '\x85' or '\xA0' <= ch <= '\uD7FF' 
     701                        or '\uE000' <= ch <= '\uFFFD') and ch != '\uFEFF': 
    703702                    unicode_characters = True 
    704703                    if not self.allow_unicode: 
    705704                        special_characters = True 
    … … class Emitter(object): 
    709708            # Spaces, line breaks, and how they are mixed. State machine. 
    710709 
    711710            # Start or continue series of whitespaces. 
    712             if ch in u' \n\x85\u2028\u2029': 
     711            if ch in ' \n\x85\u2028\u2029': 
    713712                if spaces and breaks: 
    714                     if ch != u' ':      # break+ (space+ break+)    => mixed 
     713                    if ch != ' ':      # break+ (space+ break+)    => mixed 
    715714                        mixed = True 
    716715                elif spaces: 
    717                     if ch != u' ':      # (space+ break+)   => mixed 
     716                    if ch != ' ':      # (space+ break+)   => mixed 
    718717                        breaks = True 
    719718                        mixed = True 
    720719                elif breaks: 
    721                     if ch == u' ':      # break+ space+ 
     720                    if ch == ' ':      # break+ space+ 
    722721                        spaces = True 
    723722                else: 
    724723                    leading = (index == 0) 
    725                     if ch == u' ':      # space+ 
     724                    if ch == ' ':      # space+ 
    726725                        spaces = True 
    727726                    else:               # break+ 
    728727                        breaks = True 
    … … class Emitter(object): 
    763762 
    764763            # Prepare for the next character. 
    765764            index += 1 
    766             preceeded_by_space = (ch in u'\0 \t\r\n\x85\u2028\u2029') 
     765            preceeded_by_space = (ch in '\0 \t\r\n\x85\u2028\u2029') 
    767766            followed_by_space = (index+1 >= len(scalar) or 
    768                     scalar[index+1] in u'\0 \t\r\n\x85\u2028\u2029') 
     767                    scalar[index+1] in '\0 \t\r\n\x85\u2028\u2029') 
    769768 
    770769        # Let's decide what styles are allowed. 
    771770        allow_flow_plain = True 
    … … class Emitter(object): 
    824823    def write_stream_start(self): 
    825824        # Write BOM if needed. 
    826825        if self.encoding and self.encoding.startswith('utf-16'): 
    827             self.stream.write(u'\xFF\xFE'.encode(self.encoding)) 
     826            self.stream.write('\xFF\xFE'.encode(self.encoding)) 
    828827 
    829828    def write_stream_end(self): 
    830829        self.flush_stream() 
    … … class Emitter(object): 
    834833        if self.whitespace or not need_whitespace: 
    835834            data = indicator 
    836835        else: 
    837             data = u' '+indicator 
     836            data = ' '+indicator 
    838837        self.whitespace = whitespace 
    839838        self.indention = self.indention and indention 
    840839        self.column += len(data) 
    841         if self.encoding: 
    842             data = data.encode(self.encoding) 
    843840        self.stream.write(data) 
    844841 
    845842    def write_indent(self): 
    … … class Emitter(object): 
    849846            self.write_line_break() 
    850847        if self.column < indent: 
    851848            self.whitespace = True 
    852             data = u' '*(indent-self.column) 
     849            data = ' '*(indent-self.column) 
    853850            self.column = indent 
    854             if self.encoding: 
    855                 data = data.encode(self.encoding) 
    856851            self.stream.write(data) 
    857852 
    858853    def write_line_break(self, data=None): 
    … … class Emitter(object): 
    862857        self.indention = True 
    863858        self.line += 1 
    864859        self.column = 0 
    865         if self.encoding: 
    866             data = data.encode(self.encoding) 
    867860        self.stream.write(data) 
    868861 
    869862    def write_version_directive(self, version_text): 
    870         data = u'%%YAML %s' % version_text 
    871         if self.encoding: 
    872             data = data.encode(self.encoding) 
     863        data = '%%YAML %s' % version_text 
    873864        self.stream.write(data) 
    874865        self.write_line_break() 
    875866 
    876867    def write_tag_directive(self, handle_text, prefix_text): 
    877         data = u'%%TAG %s %s' % (handle_text, prefix_text) 
    878         if self.encoding: 
    879             data = data.encode(self.encoding) 
     868        data = '%%TAG %s %s' % (handle_text, prefix_text) 
    880869        self.stream.write(data) 
    881870        self.write_line_break() 
    882871 
    883872    # Scalar streams. 
    884873 
    885874    def write_single_quoted(self, text, split=True): 
    886         self.write_indicator(u'\'', True) 
     875        self.write_indicator('\'', True) 
    887876        spaces = False 
    888877        breaks = False 
    889878        start = end = 0 
    … … class Emitter(object): 
    892881            if end < len(text): 
    893882                ch = text[end] 
    894883            if spaces: 
    895                 if ch is None or ch != u' ': 
     884                if ch is None or ch != ' ': 
    896885                    if start+1 == end and self.column > self.best_width and split   \ 
    897886                            and start != 0 and end != len(text): 
    898887                        self.write_indent() 
    899888                    else: 
    900889                        data = text[start:end] 
    901890                        self.column += len(data) 
    902                         if self.encoding: 
    903                             data = data.encode(self.encoding) 
    904891                        self.stream.write(data) 
    905892                    start = end 
    906893            elif breaks: 
    907                 if ch is None or ch not in u'\n\x85\u2028\u2029': 
    908                     if text[start] == u'\n': 
     894                if ch is None or ch not in '\n\x85\u2028\u2029': 
     895                    if text[start] == '\n': 
    909896                        self.write_line_break() 
    910897                    for br in text[start:end]: 
    911                         if br == u'\n': 
     898                        if br == '\n': 
    912899                            self.write_line_break() 
    913900                        else: 
    914901                            self.write_line_break(br) 
    915902                    self.write_indent() 
    916903                    start = end 
    917904            else: 
    918                 if ch is None or ch in u' \n\x85\u2028\u2029' or ch == u'\'': 
     905                if ch is None or ch in ' \n\x85\u2028\u2029' or ch == '\'': 
    919906                    if start < end: 
    920907                        data = text[start:end] 
    921908                        self.column += len(data) 
    922                         if self.encoding: 
    923                             data = data.encode(self.encoding) 
    924909                        self.stream.write(data) 
    925910                        start = end 
    926             if ch == u'\'': 
    927                 data = u'\'\'' 
     911            if ch == '\'': 
     912                data = '\'\'' 
    928913                self.column += 2 
    929                 if self.encoding: 
    930                     data = data.encode(self.encoding) 
    931914                self.stream.write(data) 
    932915                start = end + 1 
    933916            if ch is not None: 
    934                 spaces = (ch == u' ') 
    935                 breaks = (ch in u'\n\x85\u2028\u2029') 
     917                spaces = (ch == ' ') 
     918                breaks = (ch in '\n\x85\u2028\u2029') 
    936919            end += 1 
    937         self.write_indicator(u'\'', False) 
     920        self.write_indicator('\'', False) 
    938921 
    939922    ESCAPE_REPLACEMENTS = { 
    940         u'\0':      u'0', 
    941         u'\x07':    u'a', 
    942         u'\x08':    u'b', 
    943         u'\x09':    u't', 
    944         u'\x0A':    u'n', 
    945         u'\x0B':    u'v', 
    946         u'\x0C':    u'f', 
    947         u'\x0D':    u'r', 
    948         u'\x1B':    u'e', 
    949         u'\"':      u'\"', 
    950         u'\\':      u'\\', 
    951         u'\x85':    u'N', 
    952         u'\xA0':    u'_', 
    953         u'\u2028':  u'L', 
    954         u'\u2029':  u'P', 
     923        '\0':      '0', 
     924        '\x07':    'a', 
     925        '\x08':    'b', 
     926        '\x09':    't', 
     927        '\x0A':    'n', 
     928        '\x0B':    'v', 
     929        '\x0C':    'f', 
     930        '\x0D':    'r', 
     931        '\x1B':    'e', 
     932        '\"':      '\"', 
     933        '\\':      '\\', 
     934        '\x85':    'N', 
     935        '\xA0':    '_', 
     936        '\u2028':  'L', 
     937        '\u2029':  'P', 
    955938    } 
    956939 
    957940    def write_double_quoted(self, text, split=True): 
    958         self.write_indicator(u'"', True) 
     941        self.write_indicator('"', True) 
    959942        start = end = 0 
    960943        while end <= len(text): 
    961944            ch = None 
    962945            if end < len(text): 
    963946                ch = text[end] 
    964             if ch is None or ch in u'"\\\x85\u2028\u2029\uFEFF' \ 
    965                     or not (u'\x20' <= ch <= u'\x7E' 
     947            if ch is None or ch in '"\\\x85\u2028\u2029\uFEFF' \ 
     948                    or not ('\x20' <= ch <= '\x7E' 
    966949                        or (self.allow_unicode 
    967                             and (u'\xA0' <= ch <= u'\uD7FF' 
    968                                 or u'\uE000' <= ch <= u'\uFFFD'))): 
     950                            and ('\xA0' <= ch <= '\uD7FF' 
     951                                or '\uE000' <= ch <= '\uFFFD'))): 
    969952                if start < end: 
    970953                    data = text[start:end] 
    971954                    self.column += len(data) 
    972                     if self.encoding: 
    973                         data = data.encode(self.encoding) 
    974955                    self.stream.write(data) 
    975956                    start = end 
    976957                if ch is not None: 
    977958                    if ch in self.ESCAPE_REPLACEMENTS: 
    978                         data = u'\\'+self.ESCAPE_REPLACEMENTS[ch] 
    979                     elif ch <= u'\xFF': 
    980                         data = u'\\x%02X' % ord(ch) 
    981                     elif ch <= u'\uFFFF': 
    982                         data = u'\\u%04X' % ord(ch) 
     959                        data = '\\'+self.ESCAPE_REPLACEMENTS[ch] 
     960                    elif ch <= '\xFF': 
     961                        data = '\\x%02X' % ord(ch) 
     962                    elif ch <= '\uFFFF': 
     963                        data = '\\u%04X' % ord(ch) 
    983964                    else: 
    984                         data = u'\\U%08X' % ord(ch) 
     965                        data = '\\U%08X' % ord(ch) 
    985966                    self.column += len(data) 
    986                     if self.encoding: 
    987                         data = data.encode(self.encoding) 
    988967                    self.stream.write(data) 
    989968                    start = end+1 
    990             if 0 < end < len(text)-1 and (ch == u' ' or start >= end)   \ 
     969            if 0 < end < len(text)-1 and (ch == ' ' or start >= end)   \ 
    991970                    and self.column+(end-start) > self.best_width and split: 
    992                 data = text[start:end]+u'\\' 
     971                data = text[start:end]+'\\' 
    993972                if start < end: 
    994973                    start = end 
    995974                self.column += len(data) 
    996                 if self.encoding: 
    997                     data = data.encode(self.encoding) 
    998975                self.stream.write(data) 
    999976                self.write_indent() 
    1000977                self.whitespace = False 
    1001978                self.indention = False 
    1002                 if text[start] == u' ': 
    1003                     data = u'\\' 
     979                if text[start] == ' ': 
     980                    data = '\\' 
    1004981                    self.column += len(data) 
    1005                     if self.encoding: 
    1006                         data = data.encode(self.encoding) 
    1007982                    self.stream.write(data) 
    1008983            end += 1 
    1009         self.write_indicator(u'"', False) 
     984        self.write_indicator('"', False) 
    1010985 
    1011986    def determine_chomp(self, text): 
    1012987        tail = text[-2:] 
    1013988        while len(tail) < 2: 
    1014             tail = u' '+tail 
    1015         if tail[-1] in u'\n\x85\u2028\u2029': 
    1016             if tail[-2] in u'\n\x85\u2028\u2029': 
    1017                 return u'+' 
     989            tail = ' '+tail 
     990        if tail[-1] in '\n\x85\u2028\u2029': 
     991            if tail[-2] in '\n\x85\u2028\u2029': 
     992                return '+' 
    1018993            else: 
    1019                 return u'' 
     994                return '' 
    1020995        else: 
    1021             return u'-' 
     996            return '-' 
    1022997 
    1023998    def write_folded(self, text): 
    1024999        chomp = self.determine_chomp(text) 
    1025         self.write_indicator(u'>'+chomp, True) 
     1000        self.write_indicator('>'+chomp, True) 
    10261001        self.write_indent() 
    10271002        leading_space = False 
    10281003        spaces = False 
    … … class Emitter(object): 
    10331008            if end < len(text): 
    10341009                ch = text[end] 
    10351010            if breaks: 
    1036                 if ch is None or ch not in u'\n\x85\u2028\u2029': 
    1037                     if not leading_space and ch is not None and ch != u' '  \ 
    1038                             and text[start] == u'\n': 
     1011                if ch is None or ch not in '\n\x85\u2028\u2029': 
     1012                    if not leading_space and ch is not None and ch != ' '  \ 
     1013                            and text[start] == '\n': 
    10391014                        self.write_line_break() 
    1040                     leading_space = (ch == u' ') 
     1015                    leading_space = (ch == ' ') 
    10411016                    for br in text[start:end]: 
    1042                         if br == u'\n': 
     1017                        if br == '\n': 
    10431018                            self.write_line_break() 
    10441019                        else: 
    10451020                            self.write_line_break(br) 
    … … class Emitter(object): 
    10471022                        self.write_indent() 
    10481023                    start = end 
    10491024            elif spaces: 
    1050                 if ch != u' ': 
     1025                if ch != ' ': 
    10511026                    if start+1 == end and self.column > self.best_width: 
    10521027                        self.write_indent() 
    10531028                    else: 
    10541029                        data = text[start:end] 
    10551030                        self.column += len(data) 
    1056                         if self.encoding: 
    1057                             data = data.encode(self.encoding) 
    10581031                        self.stream.write(data) 
    10591032                    start = end 
    10601033            else: 
    1061                 if ch is None or ch in u' \n\x85\u2028\u2029': 
     1034                if ch is None or ch in ' \n\x85\u2028\u2029': 
    10621035                    data = text[start:end] 
    1063                     if self.encoding: 
    1064                         data = data.encode(self.encoding) 
    10651036                    self.stream.write(data) 
    10661037                    if ch is None: 
    10671038                        self.write_line_break() 
    10681039                    start = end 
    10691040            if ch is not None: 
    1070                 breaks = (ch in u'\n\x85\u2028\u2029') 
    1071                 spaces = (ch == u' ') 
     1041                breaks = (ch in '\n\x85\u2028\u2029') 
     1042                spaces = (ch == ' ') 
    10721043            end += 1 
    10731044 
    10741045    def write_literal(self, text): 
    10751046        chomp = self.determine_chomp(text) 
    1076         self.write_indicator(u'|'+chomp, True) 
     1047        self.write_indicator('|'+chomp, True) 
    10771048        self.write_indent() 
    10781049        breaks = False 
    10791050        start = end = 0 
    … … class Emitter(object): 
    10821053            if end < len(text): 
    10831054                ch = text[end] 
    10841055            if breaks: 
    1085                 if ch is None or ch not in u'\n\x85\u2028\u2029': 
     1056                if ch is None or ch not in '\n\x85\u2028\u2029': 
    10861057                    for br in text[start:end]: 
    1087                         if br == u'\n': 
     1058                        if br == '\n': 
    10881059                            self.write_line_break() 
    10891060                        else: 
    10901061                            self.write_line_break(br) 
    … … class Emitter(object): 
    10921063                        self.write_indent() 
    10931064                    start = end 
    10941065            else: 
    1095                 if ch is None or ch in u'\n\x85\u2028\u2029': 
     1066                if ch is None or ch in '\n\x85\u2028\u2029': 
    10961067                    data = text[start:end] 
    1097                     if self.encoding: 
    1098                         data = data.encode(self.encoding) 
    10991068                    self.stream.write(data) 
    11001069                    if ch is None: 
    11011070                        self.write_line_break() 
    11021071                    start = end 
    11031072            if ch is not None: 
    1104                 breaks = (ch in u'\n\x85\u2028\u2029') 
     1073                breaks = (ch in '\n\x85\u2028\u2029') 
    11051074            end += 1 
    11061075 
    11071076    def write_plain(self, text, split=True): 
    11081077        if not text: 
    11091078            return 
    11101079        if not self.whitespace: 
    1111             data = u' ' 
     1080            data = ' ' 
    11121081            self.column += len(data) 
    1113             if self.encoding: 
    1114                 data = data.encode(self.encoding) 
    11151082            self.stream.write(data) 
    11161083        self.writespace = False 
    11171084        self.indention = False 
    … … class Emitter(object): 
    11231090            if end < len(text): 
    11241091                ch = text[end] 
    11251092            if spaces: 
    1126                 if ch != u' ': 
     1093                if ch != ' ': 
    11271094                    if start+1 == end and self.column > self.best_width and split: 
    11281095                        self.write_indent() 
    11291096                        self.writespace = False 
    … … class Emitter(object): 
    11311098                    else: 
    11321099                        data = text[start:end] 
    11331100                        self.column += len(data) 
    1134                         if self.encoding: 
    1135                             data = data.encode(self.encoding) 
    11361101                        self.stream.write(data) 
    11371102                    start = end 
    11381103            elif breaks: 
    1139                 if ch not in u'\n\x85\u2028\u2029': 
    1140                     if text[start] == u'\n': 
     1104                if ch not in '\n\x85\u2028\u2029': 
     1105                    if text[start] == '\n': 
    11411106                        self.write_line_break() 
    11421107                    for br in text[start:end]: 
    1143                         if br == u'\n': 
     1108                        if br == '\n': 
    11441109                            self.write_line_break() 
    11451110                        else: 
    11461111                            self.write_line_break(br) 
    … … class Emitter(object): 
    11491114                    self.indention = False 
    11501115                    start = end 
    11511116            else: 
    1152                 if ch is None or ch in u' \n\x85\u2028\u2029': 
     1117                if ch is None or ch in ' \n\x85\u2028\u2029': 
    11531118                    data = text[start:end] 
    11541119                    self.column += len(data) 
    1155                     if self.encoding: 
    1156                         data = data.encode(self.encoding) 
    11571120                    self.stream.write(data) 
    11581121                    start = end 
    11591122            if ch is not None: 
    1160                 spaces = (ch == u' ') 
    1161                 breaks = (ch in u'\n\x85\u2028\u2029') 
     1123                spaces = (ch == ' ') 
     1124                breaks = (ch in '\n\x85\u2028\u2029') 
    11621125            end += 1 
    11631126 

  • lib/yaml/error.py 

    diff --git lib/yaml/error.py lib/yaml/error.py
index 577686d..b796b4d 100644
     
    11 
    22__all__ = ['Mark', 'YAMLError', 'MarkedYAMLError'] 
    33 
    4 class Mark(object): 
     4class Mark: 
    55 
    66    def __init__(self, name, index, line, column, buffer, pointer): 
    77        self.name = name 
    … … class Mark(object): 
    1616            return None 
    1717        head = '' 
    1818        start = self.pointer 
    19         while start > 0 and self.buffer[start-1] not in u'\0\r\n\x85\u2028\u2029': 
     19        while start > 0 and self.buffer[start-1] not in '\0\r\n\x85\u2028\u2029': 
    2020            start -= 1 
    2121            if self.pointer-start > max_length/2-1: 
    2222                head = ' ... ' 
    … … class Mark(object): 
    2424                break 
    2525        tail = '' 
    2626        end = self.pointer 
    27         while end < len(self.buffer) and self.buffer[end] not in u'\0\r\n\x85\u2028\u2029': 
     27        while end < len(self.buffer) and self.buffer[end] not in '\0\r\n\x85\u2028\u2029': 
    2828            end += 1 
    2929            if end-self.pointer > max_length/2-1: 
    3030                tail = ' ... ' 
    3131                end -= 5 
    3232                break 
    33         snippet = self.buffer[start:end].encode('utf-8') 
     33        snippet = self.buffer[start:end] 
    3434        return ' '*indent + head + snippet + tail + '\n'  \ 
    3535                + ' '*(indent+self.pointer-start+len(head)) + '^' 
    3636 

  • lib/yaml/events.py 

    diff --git lib/yaml/events.py lib/yaml/events.py
index f79ad38..3f244fa 100644
     
    11 
    22# Abstract classes. 
    33 
    4 class Event(object): 
     4class Event: 
    55    def __init__(self, start_mark=None, end_mark=None): 
    66        self.start_mark = start_mark 
    77        self.end_mark = end_mark 

  • lib/yaml/loader.py 

    diff --git lib/yaml/loader.py lib/yaml/loader.py
index 293ff46..efde149 100644
     
    11 
    22__all__ = ['BaseLoader', 'SafeLoader', 'Loader'] 
    33 
    4 from reader import * 
    5 from scanner import * 
    6 from parser import * 
    7 from composer import * 
    8 from constructor import * 
    9 from resolver import * 
     4from yaml.reader import * 
     5from yaml.scanner import * 
     6from yaml.parser import * 
     7from yaml.composer import * 
     8from yaml.constructor import * 
     9from yaml.resolver import * 
    1010 
    1111class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver): 
    1212 

  • lib/yaml/nodes.py 

    diff --git lib/yaml/nodes.py lib/yaml/nodes.py
index c4f070c..59cb70d 100644
     
    11 
    2 class Node(object): 
     2class Node: 
    33    def __init__(self, tag, value, start_mark, end_mark): 
    44        self.tag = tag 
    55        self.value = value 
    … … class Node(object): 
    2222        value = repr(value) 
    2323        return '%s(tag=%r, value=%s)' % (self.__class__.__name__, self.tag, value) 
    2424 
     25    def __lt__(self, other): 
     26        if isinstance(other, Node): 
     27            return self.value < other.value 
     28        return super.__lt__(self, other) 
     29 
     30    def __hash__(self): 
     31        return id(self) 
     32 
    2533class ScalarNode(Node): 
    2634    id = 'scalar' 
    2735    def __init__(self, tag, value, 

  • lib/yaml/parser.py 

    diff --git lib/yaml/parser.py lib/yaml/parser.py
index a46bb9e..51c6dc8 100644
     
    6161 
    6262__all__ = ['Parser', 'ParserError'] 
    6363 
    64 from error import MarkedYAMLError 
    65 from tokens import * 
    66 from events import * 
    67 from scanner import * 
     64from yaml.error import MarkedYAMLError 
     65from yaml.tokens import * 
     66from yaml.events import * 
     67from yaml.scanner import * 
    6868 
    6969class ParserError(MarkedYAMLError): 
    7070    pass 
    7171 
    72 class Parser(object): 
     72class Parser: 
    7373    # Since writing a recursive-descendant parser is a straightforward task, we 
    7474    # do not give many comments here. 
    7575    # Note that we use Python generators. If you rewrite the parser in another 
    7676    # language, you may replace all 'yield'-s with event handler calls. 
    7777 
    7878    DEFAULT_TAGS = { 
    79         u'!':   u'!', 
    80         u'!!':  u'tag:yaml.org,2002:', 
     79        '!':   '!', 
     80        '!!':  'tag:yaml.org,2002:', 
    8181    } 
    8282 
    8383    def __init__(self): 
    … … class Parser(object): 
    216216        self.tag_handles = {} 
    217217        while self.check_token(DirectiveToken): 
    218218            token = self.get_token() 
    219             if token.name == u'YAML': 
     219            if token.name == 'YAML': 
    220220                if self.yaml_version is not None: 
    221221                    raise ParserError(None, None, 
    222222                            "found duplicate YAML directive", token.start_mark) 
    … … class Parser(object): 
    226226                            "found incompatible YAML document (version 1.* is required)", 
    227227                            token.start_mark) 
    228228                self.yaml_version = token.value 
    229             elif token.name == u'TAG': 
     229            elif token.name == 'TAG': 
    230230                handle, prefix = token.value 
    231231                if handle in self.tag_handles: 
    232232                    raise ParserError(None, None, 
    … … class Parser(object): 
    305305                    tag = self.tag_handles[handle]+suffix 
    306306                else: 
    307307                    tag = suffix 
    308             #if tag == u'!': 
     308            #if tag == '!': 
    309309            #    raise ParserError("while parsing a node", start_mark, 
    310310            #            "found non-specific tag '!'", tag_mark, 
    311311            #            "Please check 'http://pyyaml.org/wiki/YAMLNonSpecificTag' and share your opinion.") 
    312312            if start_mark is None: 
    313313                start_mark = end_mark = self.peek_token().start_mark 
    314314            event = None 
    315             implicit = (tag is None or tag == u'!') 
     315            implicit = (tag is None or tag == '!') 
    316316            if indentless_sequence and self.check_token(BlockEntryToken): 
    317317                end_mark = self.peek_token().end_mark 
    318318                event = SequenceStartEvent(anchor, tag, implicit, 
    … … class Parser(object): 
    322322                if self.check_token(ScalarToken): 
    323323                    token = self.get_token() 
    324324                    end_mark = token.end_mark 
    325                     if (token.plain and tag is None) or tag == u'!': 
     325                    if (token.plain and tag is None) or tag == '!': 
    326326                        implicit = (True, False) 
    327327                    elif tag is None: 
    328328                        implicit = (False, True) 
    … … class Parser(object): 
    354354                elif anchor is not None or tag is not None: 
    355355                    # Empty scalars are allowed even if a tag or an anchor is 
    356356                    # specified. 
    357                     event = ScalarEvent(anchor, tag, (implicit, False), u'', 
     357                    event = ScalarEvent(anchor, tag, (implicit, False), '', 
    358358                            start_mark, end_mark) 
    359359                    self.state = self.states.pop() 
    360360                else: 
    … … class Parser(object): 
    582582        return self.process_empty_scalar(self.peek_token().start_mark) 
    583583 
    584584    def process_empty_scalar(self, mark): 
    585         return ScalarEvent(None, None, (True, False), u'', mark, mark) 
     585        return ScalarEvent(None, None, (True, False), '', mark, mark) 
    586586 

  • lib/yaml/reader.py 

    diff --git lib/yaml/reader.py lib/yaml/reader.py
index 1d4667c..1998ce2 100644
     
    1717 
    1818__all__ = ['Reader', 'ReaderError'] 
    1919 
    20 from error import YAMLError, Mark 
    21  
    22 import codecs, re 
    23  
    24 # Unfortunately, codec functions in Python 2.3 does not support the `finish` 
    25 # arguments, so we have to write our own wrappers. 
    26  
    27 try: 
    28     codecs.utf_8_decode('', 'strict', False) 
    29     from codecs import utf_8_decode, utf_16_le_decode, utf_16_be_decode 
    30  
    31 except TypeError: 
    32  
    33     def utf_16_le_decode(data, errors, finish=False): 
    34         if not finish and len(data) % 2 == 1: 
    35             data = data[:-1] 
    36         return codecs.utf_16_le_decode(data, errors) 
    37  
    38     def utf_16_be_decode(data, errors, finish=False): 
    39         if not finish and len(data) % 2 == 1: 
    40             data = data[:-1] 
    41         return codecs.utf_16_be_decode(data, errors) 
    42  
    43     def utf_8_decode(data, errors, finish=False): 
    44         if not finish: 
    45             # We are trying to remove a possible incomplete multibyte character 
    46             # from the suffix of the data. 
    47             # The first byte of a multi-byte sequence is in the range 0xc0 to 0xfd. 
    48             # All further bytes are in the range 0x80 to 0xbf. 
    49             # UTF-8 encoded UCS characters may be up to six bytes long. 
    50             count = 0 
    51             while count < 5 and count < len(data)   \ 
    52                     and '\x80' <= data[-count-1] <= '\xBF': 
    53                 count -= 1 
    54             if count < 5 and count < len(data)  \ 
    55                     and '\xC0' <= data[-count-1] <= '\xFD': 
    56                 data = data[:-count-1] 
    57         return codecs.utf_8_decode(data, errors) 
     20from yaml.error import YAMLError, Mark 
     21 
     22import codecs, re, io 
    5823 
    5924class ReaderError(YAMLError): 
    6025 
    … … class ReaderError(YAMLError): 
    6631        self.reason = reason 
    6732 
    6833    def __str__(self): 
    69         if isinstance(self.character, str): 
    70             return "'%s' codec can't decode byte #x%02x: %s\n"  \ 
     34        if isinstance(self.character, bytes): 
     35            return "'%s' codec can't decode #x%02x: %s\n"  \ 
    7136                    "  in \"%s\", position %d"    \ 
    7237                    % (self.encoding, ord(self.character), self.reason, 
    7338                            self.name, self.position) 
    7439        else: 
    75             return "unacceptable character #x%04x: %s\n"    \ 
     40            return "unacceptable character %r: %s\n"    \ 
    7641                    "  in \"%s\", position %d"    \ 
    77                     % (ord(self.character), self.reason, 
     42                    % (self.character, self.reason, 
    7843                            self.name, self.position) 
    7944 
    80 class Reader(object): 
     45class Reader: 
    8146    # Reader: 
    8247    # - determines the data encoding and converts it to unicode, 
    8348    # - checks if characters are in allowed range, 
    … … class Reader(object): 
    9661        self.stream = None 
    9762        self.stream_pointer = 0 
    9863        self.eof = True 
    99         self.buffer = u'' 
     64        self.buffer = '' 
    10065        self.pointer = 0 
    10166        self.raw_buffer = None 
    10267        self.raw_decode = None 
    … … class Reader(object): 
    10469        self.index = 0 
    10570        self.line = 0 
    10671        self.column = 0 
    107         if isinstance(stream, unicode): 
     72        if isinstance(stream, str): 
    10873            self.name = "<unicode string>" 
    10974            self.check_printable(stream) 
    110             self.buffer = stream+u'\0' 
    111         elif isinstance(stream, str): 
     75            self.buffer = stream+'\0' 
     76        elif isinstance(stream, bytes): 
    11277            self.name = "<string>" 
    11378            self.raw_buffer = stream 
    11479            self.determine_encoding() 
    … … class Reader(object): 
    11681            self.stream = stream 
    11782            self.name = getattr(stream, 'name', "<file>") 
    11883            self.eof = False 
    119             self.raw_buffer = '' 
     84            self.raw_buffer = None 
    12085            self.determine_encoding() 
    12186 
    12287    def peek(self, index=0): 
    … … class Reader(object): 
    138103            ch = self.buffer[self.pointer] 
    139104            self.pointer += 1 
    140105            self.index += 1 
    141             if ch in u'\n\x85\u2028\u2029'  \ 
    142                     or (ch == u'\r' and self.buffer[self.pointer] != u'\n'): 
     106            if ch in '\n\x85\u2028\u2029'  \ 
     107                    or (ch == '\r' and self.buffer[self.pointer] != '\n'): 
    143108                self.line += 1 
    144109                self.column = 0 
    145             elif ch != u'\uFEFF': 
     110            elif ch != '\uFEFF': 
    146111                self.column += 1 
    147112            length -= 1 
    148113 
    … … class Reader(object): 
    155120                    None, None) 
    156121 
    157122    def determine_encoding(self): 
    158         while not self.eof and len(self.raw_buffer) < 2: 
     123        while not self.eof and (self.raw_buffer is None or len(self.raw_buffer) < 2): 
    159124            self.update_raw() 
    160         if not isinstance(self.raw_buffer, unicode): 
     125        if not isinstance(self.raw_buffer, str): 
    161126            if self.raw_buffer.startswith(codecs.BOM_UTF16_LE): 
    162                 self.raw_decode = utf_16_le_decode 
     127                self.raw_decode = codecs.utf_16_le_decode 
    163128                self.encoding = 'utf-16-le' 
    164129            elif self.raw_buffer.startswith(codecs.BOM_UTF16_BE): 
    165                 self.raw_decode = utf_16_be_decode 
     130                self.raw_decode = codecs.utf_16_be_decode 
    166131                self.encoding = 'utf-16-be' 
    167132            else: 
    168                 self.raw_decode = utf_8_decode 
     133                self.raw_decode = codecs.utf_8_decode 
    169134                self.encoding = 'utf-8' 
    170135        self.update(1) 
    171136 
    172     NON_PRINTABLE = re.compile(u'[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD]') 
     137    NON_PRINTABLE = re.compile('[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD]') 
    173138    def check_printable(self, data): 
    174139        match = self.NON_PRINTABLE.search(data) 
    175140        if match: 
    … … class Reader(object): 
    190155                try: 
    191156                    data, converted = self.raw_decode(self.raw_buffer, 
    192157                            'strict', self.eof) 
    193                 except UnicodeDecodeError, exc: 
     158                except UnicodeDecodeError as exc: 
    194159                    character = exc.object[exc.start] 
    195160                    if self.stream is not None: 
    196161                        position = self.stream_pointer-len(self.raw_buffer)+exc.start 
    197162                    else: 
    198163                        position = exc.start 
    199164                    raise ReaderError(self.name, position, character, 
    200                             exc.encoding, exc.reason) 
     165                            exc.encoding, exc.reason) from exc 
    201166            else: 
    202167                data = self.raw_buffer 
    203168                converted = len(data) 
    … … class Reader(object): 
    205170            self.buffer += data 
    206171            self.raw_buffer = self.raw_buffer[converted:] 
    207172            if self.eof: 
    208                 self.buffer += u'\0' 
     173                self.buffer += '\0' 
    209174                self.raw_buffer = None 
    210175                break 
    211176 
    212177    def update_raw(self, size=1024): 
    213178        data = self.stream.read(size) 
    214179        if data: 
    215             self.raw_buffer += data 
    216             self.stream_pointer += len(data) 
     180            if self.raw_buffer is None: 
     181                self.raw_buffer = data 
     182            else: 
     183                self.raw_buffer += data 
     184                self.stream_pointer += len(data) 
    217185        else: 
     186            if self.raw_buffer is None: 
     187                self.raw_buffer = b'' 
    218188            self.eof = True 
    219189 
    220190#try: 

  • lib/yaml/representer.py 

    diff --git lib/yaml/representer.py lib/yaml/representer.py
index 1f4fe59..5c9a76f 100644
     
    22__all__ = ['BaseRepresenter', 'SafeRepresenter', 'Representer', 
    33    'RepresenterError'] 
    44 
    5 from error import * 
    6 from nodes import * 
     5from yaml.error import * 
     6from yaml.nodes import * 
    77 
    8 import datetime 
     8import datetime, base64 
    99 
    10 try: 
    11     set 
    12 except NameError: 
    13     from sets import Set as set 
    14  
    15 import sys, copy_reg, types 
     10import sys, copyreg, types 
    1611 
    1712class RepresenterError(YAMLError): 
    1813    pass 
    1914 
    20 class BaseRepresenter(object): 
     15class BaseRepresenter: 
    2116 
    2217    yaml_representers = {} 
    2318    yaml_multi_representers = {} 
    … … class BaseRepresenter(object): 
    5651            #self.represented_objects[alias_key] = None 
    5752            self.object_keeper.append(data) 
    5853        data_types = type(data).__mro__ 
    59         if type(data) is types.InstanceType: 
    60             data_types = self.get_classobj_bases(data.__class__)+list(data_types) 
    6154        if data_types[0] in self.yaml_representers: 
    6255            node = self.yaml_representers[data_types[0]](self, data) 
    6356        else: 
    … … class BaseRepresenter(object): 
    7164                elif None in self.yaml_representers: 
    7265                    node = self.yaml_representers[None](self, data) 
    7366                else: 
    74                     node = ScalarNode(None, unicode(data)) 
     67                    node = ScalarNode(None, str(data)) 
    7568        #if alias_key is not None: 
    7669        #    self.represented_objects[alias_key] = node 
    7770        return node 
    … … class BaseRepresenter(object): 
    121114            self.represented_objects[self.alias_key] = node 
    122115        best_style = True 
    123116        if hasattr(mapping, 'items'): 
    124             mapping = mapping.items() 
    125             mapping.sort() 
     117            mapping = list(mapping.items()) 
    126118        for item_key, item_value in mapping: 
    127119            node_key = self.represent_data(item_key) 
    128120            node_value = self.represent_data(item_value) 
    … … class BaseRepresenter(object): 
    131123            if not (isinstance(node_value, ScalarNode) and not node_value.style): 
    132124                best_style = False 
    133125            value.append((node_key, node_value)) 
     126        value.sort() 
    134127        if flow_style is None: 
    135128            if self.default_flow_style is not None: 
    136129                node.flow_style = self.default_flow_style 
    … … class SafeRepresenter(BaseRepresenter): 
    146139    def ignore_aliases(self, data): 
    147140        if data in [None, ()]: 
    148141            return True 
    149         if isinstance(data, (str, unicode, bool, int, float)): 
     142        if isinstance(data, (str, bytes, bool, int, float)): 
    150143            return True 
    151144 
    152145    def represent_none(self, data): 
    153         return self.represent_scalar(u'tag:yaml.org,2002:null', 
    154                 u'null') 
     146        return self.represent_scalar('tag:yaml.org,2002:null', 
     147                'null') 
    155148 
    156     def represent_str(self, data): 
     149    def represent_bytes(self, data): 
    157150        tag = None 
    158151        style = None 
    159152        try: 
    160             data = unicode(data, 'ascii') 
    161             tag = u'tag:yaml.org,2002:str' 
     153            data = data.decode('ascii') 
     154            tag = 'tag:yaml.org,2002:python/bytes' 
    162155        except UnicodeDecodeError: 
    163156            try: 
    164                 data = unicode(data, 'utf-8') 
    165                 tag = u'tag:yaml.org,2002:str' 
     157                data = data.decode('utf-8') 
     158                tag = 'tag:yaml.org,2002:python/bytes' 
    166159            except UnicodeDecodeError: 
    167                 data = data.encode('base64') 
    168                 tag = u'tag:yaml.org,2002:binary' 
     160                data = base64.b64encode(data).decode('ascii') 
     161                tag = 'tag:yaml.org,2002:binary' 
    169162                style = '|' 
    170163        return self.represent_scalar(tag, data, style=style) 
    171164 
    172     def represent_unicode(self, data): 
    173         return self.represent_scalar(u'tag:yaml.org,2002:str', data) 
     165    def represent_str(self, data): 
     166        return self.represent_scalar('tag:yaml.org,2002:str', data) 
    174167 
    175168    def represent_bool(self, data): 
    176169        if data: 
    177             value = u'true' 
     170            value = 'true' 
    178171        else: 
    179             value = u'false' 
    180         return self.represent_scalar(u'tag:yaml.org,2002:bool', value) 
     172            value = 'false' 
     173        return self.represent_scalar('tag:yaml.org,2002:bool', value) 
    181174 
    182175    def represent_int(self, data): 
    183         return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(data)) 
    184  
    185     def represent_long(self, data): 
    186         return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(data)) 
     176        return self.represent_scalar('tag:yaml.org,2002:int', str(data)) 
    187177 
    188178    inf_value = 1e300 
    189179    while repr(inf_value) != repr(inf_value*inf_value): 
    … … class SafeRepresenter(BaseRepresenter): 
    191181 
    192182    def represent_float(self, data): 
    193183        if data != data or (data == 0.0 and data == 1.0): 
    194             value = u'.nan' 
     184            value = '.nan' 
    195185        elif data == self.inf_value: 
    196             value = u'.inf' 
     186            value = '.inf' 
    197187        elif data == -self.inf_value: 
    198             value = u'-.inf' 
     188            value = '-.inf' 
    199189        else: 
    200             value = unicode(repr(data)).lower() 
     190            value = str(repr(data)).lower() 
    201191            # Note that in some cases `repr(data)` represents a float number 
    202192            # without the decimal parts.  For instance: 
    203193            #   >>> repr(1e17) 
    … … class SafeRepresenter(BaseRepresenter): 
    205195            # Unfortunately, this is not a valid float representation according 
    206196            # to the definition of the `!!float` tag.  We fix this by adding 
    207197            # '.0' before the 'e' symbol. 
    208             if u'.' not in value and u'e' in value: 
    209                 value = value.replace(u'e', u'.0e', 1) 
    210         return self.represent_scalar(u'tag:yaml.org,2002:float', value) 
     198            if '.' not in value and 'e' in value: 
     199                value = value.replace('e', '.0e', 1) 
     200        return self.represent_scalar('tag:yaml.org,2002:float', value) 
    211201 
    212202    def represent_list(self, data): 
    213203        #pairs = (len(data) > 0 and isinstance(data, list)) 
    … … class SafeRepresenter(BaseRepresenter): 
    217207        #            pairs = False 
    218208        #            break 
    219209        #if not pairs: 
    220             return self.represent_sequence(u'tag:yaml.org,2002:seq', data) 
     210            return self.represent_sequence('tag:yaml.org,2002:seq', data) 
    221211        #value = [] 
    222212        #for item_key, item_value in data: 
    223         #    value.append(self.represent_mapping(u'tag:yaml.org,2002:map', 
     213        #    value.append(self.represent_mapping('tag:yaml.org,2002:map', 
    224214        #        [(item_key, item_value)])) 
    225         #return SequenceNode(u'tag:yaml.org,2002:pairs', value) 
     215        #return SequenceNode('tag:yaml.org,2002:pairs', value) 
    226216 
    227217    def represent_dict(self, data): 
    228         return self.represent_mapping(u'tag:yaml.org,2002:map', data) 
     218        return self.represent_mapping('tag:yaml.org,2002:map', data) 
    229219 
    230220    def represent_set(self, data): 
    231221        value = {} 
    232222        for key in data: 
    233223            value[key] = None 
    234         return self.represent_mapping(u'tag:yaml.org,2002:set', value) 
     224        return self.represent_mapping('tag:yaml.org,2002:set', value) 
    235225 
    236226    def represent_date(self, data): 
    237         value = unicode(data.isoformat()) 
    238         return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value) 
     227        value = str(data.isoformat()) 
     228        return self.represent_scalar('tag:yaml.org,2002:timestamp', value) 
    239229 
    240230    def represent_datetime(self, data): 
    241         value = unicode(data.isoformat(' ')) 
    242         return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value) 
     231        value = str(data.isoformat(' ')) 
     232        return self.represent_scalar('tag:yaml.org,2002:timestamp', value) 
    243233 
    244234    def represent_yaml_object(self, tag, data, cls, flow_style=None): 
    245235        if hasattr(data, '__getstate__'): 
    … … SafeRepresenter.add_representer(type(None), 
    257247SafeRepresenter.add_representer(str, 
    258248        SafeRepresenter.represent_str) 
    259249 
    260 SafeRepresenter.add_representer(unicode, 
    261         SafeRepresenter.represent_unicode) 
    262  
    263250SafeRepresenter.add_representer(bool, 
    264251        SafeRepresenter.represent_bool) 
    265252 
    266253SafeRepresenter.add_representer(int, 
    267254        SafeRepresenter.represent_int) 
    268255 
    269 SafeRepresenter.add_representer(long, 
    270         SafeRepresenter.represent_long) 
    271  
    272256SafeRepresenter.add_representer(float, 
    273257        SafeRepresenter.represent_float) 
    274258 
    … … SafeRepresenter.add_representer(None, 
    294278 
    295279class Representer(SafeRepresenter): 
    296280 
    297     def represent_str(self, data): 
     281    def represent_bytes(self, data): 
    298282        tag = None 
    299283        style = None 
    300284        try: 
    301             data = unicode(data, 'ascii') 
    302             tag = u'tag:yaml.org,2002:str' 
     285            data = data.decode('ascii') 
     286            tag = 'tag:yaml.org,2002:python/bytes' 
    303287        except UnicodeDecodeError: 
    304288            try: 
    305                 data = unicode(data, 'utf-8') 
    306                 tag = u'tag:yaml.org,2002:python/str' 
     289                data = data.decode('utf-8') 
     290                tag = 'tag:yaml.org,2002:python/bytes' 
    307291            except UnicodeDecodeError: 
    308                 data = data.encode('base64') 
    309                 tag = u'tag:yaml.org,2002:binary' 
     292                data = base64.b64encode(data).decode('ascii') 
     293                tag = 'tag:yaml.org,2002:binary' 
    310294                style = '|' 
    311295        return self.represent_scalar(tag, data, style=style) 
    312296 
    313     def represent_unicode(self, data): 
    314         tag = None 
    315         try: 
    316             data.encode('ascii') 
    317             tag = u'tag:yaml.org,2002:python/unicode' 
    318         except UnicodeEncodeError: 
    319             tag = u'tag:yaml.org,2002:str' 
     297    def represent_str(self, data): 
     298        tag = 'tag:yaml.org,2002:str' 
    320299        return self.represent_scalar(tag, data) 
    321300 
    322     def represent_long(self, data): 
    323         tag = u'tag:yaml.org,2002:int' 
    324         if int(data) is not data: 
    325             tag = u'tag:yaml.org,2002:python/long' 
    326         return self.represent_scalar(tag, unicode(data)) 
    327  
    328301    def represent_complex(self, data): 
    329302        if data.imag == 0.0: 
    330             data = u'%r' % data.real 
     303            data = '%r' % data.real 
    331304        elif data.real == 0.0: 
    332             data = u'%rj' % data.imag 
     305            data = '%rj' % data.imag 
    333306        elif data.imag > 0: 
    334             data = u'%r+%rj' % (data.real, data.imag) 
     307            data = '%r+%rj' % (data.real, data.imag) 
    335308        else: 
    336             data = u'%r%rj' % (data.real, data.imag) 
    337         return self.represent_scalar(u'tag:yaml.org,2002:python/complex', data) 
     309            data = '%r%rj' % (data.real, data.imag) 
     310        return self.represent_scalar('tag:yaml.org,2002:python/complex', data) 
    338311 
    339312    def represent_tuple(self, data): 
    340         return self.represent_sequence(u'tag:yaml.org,2002:python/tuple', data) 
     313        return self.represent_sequence('tag:yaml.org,2002:python/tuple', data) 
    341314 
    342315    def represent_name(self, data): 
    343         name = u'%s.%s' % (data.__module__, data.__name__) 
    344         return self.represent_scalar(u'tag:yaml.org,2002:python/name:'+name, u'') 
     316        name = '%s.%s' % (data.__module__, data.__name__) 
     317        return self.represent_scalar('tag:yaml.org,2002:python/name:'+name, '') 
    345318 
    346319    def represent_module(self, data): 
    347320        return self.represent_scalar( 
    348                 u'tag:yaml.org,2002:python/module:'+data.__name__, u'') 
    349  
    350     def represent_instance(self, data): 
    351         # For instances of classic classes, we use __getinitargs__ and 
    352         # __getstate__ to serialize the data. 
    353  
    354         # If data.__getinitargs__ exists, the object must be reconstructed by 
    355         # calling cls(**args), where args is a tuple returned by 
    356         # __getinitargs__. Otherwise, the cls.__init__ method should never be 
    357         # called and the class instance is created by instantiating a trivial 
    358         # class and assigning to the instance's __class__ variable. 
    359  
    360         # If data.__getstate__ exists, it returns the state of the object. 
    361         # Otherwise, the state of the object is data.__dict__. 
    362  
    363         # We produce either a !!python/object or !!python/object/new node. 
    364         # If data.__getinitargs__ does not exist and state is a dictionary, we 
    365         # produce a !!python/object node . Otherwise we produce a 
    366         # !!python/object/new node. 
    367  
    368         cls = data.__class__ 
    369         class_name = u'%s.%s' % (cls.__module__, cls.__name__) 
    370         args = None 
    371         state = None 
    372         if hasattr(data, '__getinitargs__'): 
    373             args = list(data.__getinitargs__()) 
    374         if hasattr(data, '__getstate__'): 
    375             state = data.__getstate__() 
    376         else: 
    377             state = data.__dict__ 
    378         if args is None and isinstance(state, dict): 
    379             return self.represent_mapping( 
    380                     u'tag:yaml.org,2002:python/object:'+class_name, state) 
    381         if isinstance(state, dict) and not state: 
    382             return self.represent_sequence( 
    383                     u'tag:yaml.org,2002:python/object/new:'+class_name, args) 
    384         value = {} 
    385         if args: 
    386             value['args'] = args 
    387         value['state'] = state 
    388         return self.represent_mapping( 
    389                 u'tag:yaml.org,2002:python/object/new:'+class_name, value) 
     321                'tag:yaml.org,2002:python/module:'+data.__name__, '') 
    390322 
    391323    def represent_object(self, data): 
    392324        # We use __reduce__ API to save the data. data.__reduce__ returns 
    … … class Representer(SafeRepresenter): 
    406338        # !!python/object/apply node. 
    407339 
    408340        cls = type(data) 
    409         if cls in copy_reg.dispatch_table: 
    410             reduce = copy_reg.dispatch_table[cls](data) 
     341        if cls in copyreg.dispatch_table: 
     342            reduce = copyreg.dispatch_table[cls](data) 
    411343        elif hasattr(data, '__reduce_ex__'): 
    412344            reduce = data.__reduce_ex__(2) 
    413345        elif hasattr(data, '__reduce__'): 
    … … class Representer(SafeRepresenter): 
    426358        if function.__name__ == '__newobj__': 
    427359            function = args[0] 
    428360            args = args[1:] 
    429             tag = u'tag:yaml.org,2002:python/object/new:' 
     361            tag = 'tag:yaml.org,2002:python/object/new:' 
    430362            newobj = True 
    431363        else: 
    432             tag = u'tag:yaml.org,2002:python/object/apply:' 
     364            tag = 'tag:yaml.org,2002:python/object/apply:' 
    433365            newobj = False 
    434         function_name = u'%s.%s' % (function.__module__, function.__name__) 
     366        function_name = '%s.%s' % (function.__module__, function.__name__) 
    435367        if not args and not listitems and not dictitems \ 
    436368                and isinstance(state, dict) and newobj: 
    437369            return self.represent_mapping( 
    438                     u'tag:yaml.org,2002:python/object:'+function_name, state) 
     370                    'tag:yaml.org,2002:python/object:'+function_name, state) 
    439371        if not listitems and not dictitems  \ 
    440372                and isinstance(state, dict) and not state: 
    441373            return self.represent_sequence(tag+function_name, args) 
    … … class Representer(SafeRepresenter): 
    453385Representer.add_representer(str, 
    454386        Representer.represent_str) 
    455387 
    456 Representer.add_representer(unicode, 
    457         Representer.represent_unicode) 
    458  
    459 Representer.add_representer(long, 
    460         Representer.represent_long) 
     388Representer.add_representer(bytes, 
     389        Representer.represent_bytes) 
    461390 
    462391Representer.add_representer(complex, 
    463392        Representer.represent_complex) 
    … … Representer.add_representer(tuple, 
    468397Representer.add_representer(type, 
    469398        Representer.represent_name) 
    470399 
    471 Representer.add_representer(types.ClassType, 
    472         Representer.represent_name) 
    473  
    474400Representer.add_representer(types.FunctionType, 
    475401        Representer.represent_name) 
    476402 
    … … Representer.add_representer(types.BuiltinFunctionType, 
    480406Representer.add_representer(types.ModuleType, 
    481407        Representer.represent_module) 
    482408 
    483 Representer.add_multi_representer(types.InstanceType, 
    484         Representer.represent_instance) 
    485  
    486409Representer.add_multi_representer(object, 
    487410        Representer.represent_object) 
    488411 

  • lib/yaml/resolver.py 

    diff --git lib/yaml/resolver.py lib/yaml/resolver.py
index 60c43e3..08f121f 100644
     
    11 
    22__all__ = ['BaseResolver', 'Resolver'] 
    33 
    4 from error import * 
    5 from nodes import * 
     4from yaml.error import * 
     5from yaml.nodes import * 
    66 
    77import re 
    88 
    99class ResolverError(YAMLError): 
    1010    pass 
    1111 
    12 class BaseResolver(object): 
     12class BaseResolver: 
    1313 
    14     DEFAULT_SCALAR_TAG = u'tag:yaml.org,2002:str' 
    15     DEFAULT_SEQUENCE_TAG = u'tag:yaml.org,2002:seq' 
    16     DEFAULT_MAPPING_TAG = u'tag:yaml.org,2002:map' 
     14    DEFAULT_SCALAR_TAG = 'tag:yaml.org,2002:str' 
     15    DEFAULT_SEQUENCE_TAG = 'tag:yaml.org,2002:seq' 
     16    DEFAULT_MAPPING_TAG = 'tag:yaml.org,2002:map' 
    1717 
    1818    yaml_implicit_resolvers = {} 
    1919    yaml_path_resolvers = {} 
    … … class BaseResolver(object): 
    6666            elif node_check is dict: 
    6767                node_check = MappingNode 
    6868            elif node_check not in [ScalarNode, SequenceNode, MappingNode]  \ 
    69                     and not isinstance(node_check, basestring)  \ 
     69                    and not isinstance(node_check, str)  \ 
    7070                    and node_check is not None: 
    7171                raise ResolverError("Invalid node checker: %s" % node_check) 
    72             if not isinstance(index_check, (basestring, int))   \ 
     72            if not isinstance(index_check, (str, int))   \ 
    7373                    and index_check is not None: 
    7474                raise ResolverError("Invalid index checker: %s" % index_check) 
    7575            new_path.append((node_check, index_check)) 
    … … class BaseResolver(object): 
    117117    def check_resolver_prefix(self, depth, path, kind, 
    118118            current_node, current_index): 
    119119        node_check, index_check = path[depth-1] 
    120         if isinstance(node_check, basestring): 
     120        if isinstance(node_check, str): 
    121121            if current_node.tag != node_check: 
    122122                return 
    123123        elif node_check is not None: 
    … … class BaseResolver(object): 
    128128        if (index_check is False or index_check is None)    \ 
    129129                and current_index is None: 
    130130            return 
    131         if isinstance(index_check, basestring): 
     131        if isinstance(index_check, str): 
    132132            if not (isinstance(current_index, ScalarNode) 
    133133                    and index_check == current_index.value): 
    134134                return 
    … … class BaseResolver(object): 
    139139 
    140140    def resolve(self, kind, value, implicit): 
    141141        if kind is ScalarNode and implicit[0]: 
    142             if value == u'': 
    143                 resolvers = self.yaml_implicit_resolvers.get(u'', []) 
     142            if value == '': 
     143                resolvers = self.yaml_implicit_resolvers.get('', []) 
    144144            else: 
    145145                resolvers = self.yaml_implicit_resolvers.get(value[0], []) 
    146146            resolvers += self.yaml_implicit_resolvers.get(None, []) 
    … … class Resolver(BaseResolver): 
    165165    pass 
    166166 
    167167Resolver.add_implicit_resolver( 
    168         u'tag:yaml.org,2002:bool', 
    169         re.compile(ur'''^(?:yes|Yes|YES|no|No|NO 
     168        'tag:yaml.org,2002:bool', 
     169        re.compile(r'''^(?:yes|Yes|YES|no|No|NO 
    170170                    |true|True|TRUE|false|False|FALSE 
    171171                    |on|On|ON|off|Off|OFF)$''', re.X), 
    172         list(u'yYnNtTfFoO')) 
     172        list('yYnNtTfFoO')) 
    173173 
    174174Resolver.add_implicit_resolver( 
    175         u'tag:yaml.org,2002:float', 
    176         re.compile(ur'''^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)? 
     175        'tag:yaml.org,2002:float', 
     176        re.compile(r'''^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)? 
    177177                    |\.[0-9_]+(?:[eE][-+][0-9]+)? 
    178178                    |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]* 
    179179                    |[-+]?\.(?:inf|Inf|INF) 
    180180                    |\.(?:nan|NaN|NAN))$''', re.X), 
    181         list(u'-+0123456789.')) 
     181        list('-+0123456789.')) 
    182182 
    183183Resolver.add_implicit_resolver( 
    184         u'tag:yaml.org,2002:int', 
    185         re.compile(ur'''^(?:[-+]?0b[0-1_]+ 
     184        'tag:yaml.org,2002:int', 
     185        re.compile(r'''^(?:[-+]?0b[0-1_]+ 
    186186                    |[-+]?0[0-7_]+ 
    187187                    |[-+]?(?:0|[1-9][0-9_]*) 
    188188                    |[-+]?0x[0-9a-fA-F_]+ 
    189189                    |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$''', re.X), 
    190         list(u'-+0123456789')) 
     190        list('-+0123456789')) 
    191191 
    192192Resolver.add_implicit_resolver( 
    193         u'tag:yaml.org,2002:merge', 
    194         re.compile(ur'^(?:<<)$'), 
     193        'tag:yaml.org,2002:merge', 
     194        re.compile(r'^(?:<<)$'), 
    195195        ['<']) 
    196196 
    197197Resolver.add_implicit_resolver( 
    198         u'tag:yaml.org,2002:null', 
    199         re.compile(ur'''^(?: ~ 
     198        'tag:yaml.org,2002:null', 
     199        re.compile(r'''^(?: ~ 
    200200                    |null|Null|NULL 
    201201                    | )$''', re.X), 
    202         [u'~', u'n', u'N', u'']) 
     202        ['~', 'n', 'N', '']) 
    203203 
    204204Resolver.add_implicit_resolver( 
    205         u'tag:yaml.org,2002:timestamp', 
    206         re.compile(ur'''^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] 
     205        'tag:yaml.org,2002:timestamp', 
     206        re.compile(r'''^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] 
    207207                    |[0-9][0-9][0-9][0-9] -[0-9][0-9]? -[0-9][0-9]? 
    208208                     (?:[Tt]|[ \t]+)[0-9][0-9]? 
    209209                     :[0-9][0-9] :[0-9][0-9] (?:\.[0-9]*)? 
    210210                     (?:[ \t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$''', re.X), 
    211         list(u'0123456789')) 
     211        list('0123456789')) 
    212212 
    213213Resolver.add_implicit_resolver( 
    214         u'tag:yaml.org,2002:value', 
    215         re.compile(ur'^(?:=)$'), 
     214        'tag:yaml.org,2002:value', 
     215        re.compile(r'^(?:=)$'), 
    216216        ['=']) 
    217217 
    218218# The following resolver is only for documentation purposes. It cannot work 
    219219# because plain scalars cannot start with '!', '&', or '*'. 
    220220Resolver.add_implicit_resolver( 
    221         u'tag:yaml.org,2002:yaml', 
    222         re.compile(ur'^(?:!|&|\*)$'), 
    223         list(u'!&*')) 
     221        'tag:yaml.org,2002:yaml', 
     222        re.compile(r'^(?:!|&|\*)$'), 
     223        list('!&*')) 
    224224 

  • lib/yaml/scanner.py 

    diff --git lib/yaml/scanner.py lib/yaml/scanner.py
index a3ecdd0..2014e46 100644
     
    2626 
    2727__all__ = ['Scanner', 'ScannerError'] 
    2828 
    29 from error import MarkedYAMLError 
    30 from tokens import * 
     29from yaml.error import MarkedYAMLError 
     30from yaml.tokens import * 
    3131 
    3232class ScannerError(MarkedYAMLError): 
    3333    pass 
    3434 
    35 class SimpleKey(object): 
     35class SimpleKey: 
    3636    # See below simple keys treatment. 
    3737 
    3838    def __init__(self, token_number, required, index, line, column, mark): 
    … … class SimpleKey(object): 
    4343        self.column = column 
    4444        self.mark = mark 
    4545 
    46 class Scanner(object): 
     46class Scanner: 
    4747 
    4848    def __init__(self): 
    4949        """Initialize the scanner.""" 
    … … class Scanner(object): 
    166166        ch = self.peek() 
    167167 
    168168        # Is it the end of stream? 
    169         if ch == u'\0': 
     169        if ch == '\0': 
    170170            return self.fetch_stream_end() 
    171171 
    172172        # Is it a directive? 
    173         if ch == u'%' and self.check_directive(): 
     173        if ch == '%' and self.check_directive(): 
    174174            return self.fetch_directive() 
    175175 
    176176        # Is it the document start? 
    177         if ch == u'-' and self.check_document_start(): 
     177        if ch == '-' and self.check_document_start(): 
    178178            return self.fetch_document_start() 
    179179 
    180180        # Is it the document end? 
    181         if ch == u'.' and self.check_document_end(): 
     181        if ch == '.' and self.check_document_end(): 
    182182            return self.fetch_document_end() 
    183183 
    184184        # TODO: support for BOM within a stream. 
    185         #if ch == u'\uFEFF': 
     185        #if ch == '\uFEFF': 
    186186        #    return self.fetch_bom()    <-- issue BOMToken 
    187187 
    188188        # Note: the order of the following checks is NOT significant. 
    189189 
    190190        # Is it the flow sequence start indicator? 
    191         if ch == u'[': 
     191        if ch == '[': 
    192192            return self.fetch_flow_sequence_start() 
    193193 
    194194        # Is it the flow mapping start indicator? 
    195         if ch == u'{': 
     195        if ch == '{': 
    196196            return self.fetch_flow_mapping_start() 
    197197 
    198198        # Is it the flow sequence end indicator? 
    199         if ch == u']': 
     199        if ch == ']': 
    200200            return self.fetch_flow_sequence_end() 
    201201 
    202202        # Is it the flow mapping end indicator? 
    203         if ch == u'}': 
     203        if ch == '}': 
    204204            return self.fetch_flow_mapping_end() 
    205205 
    206206        # Is it the flow entry indicator? 
    207         if ch == u',': 
     207        if ch == ',': 
    208208            return self.fetch_flow_entry() 
    209209 
    210210        # Is it the block entry indicator? 
    211         if ch == u'-' and self.check_block_entry(): 
     211        if ch == '-' and self.check_block_entry(): 
    212212            return self.fetch_block_entry() 
    213213 
    214214        # Is it the key indicator? 
    215         if ch == u'?' and self.check_key(): 
     215        if ch == '?' and self.check_key(): 
    216216            return self.fetch_key() 
    217217 
    218218        # Is it the value indicator? 
    219         if ch == u':' and self.check_value(): 
     219        if ch == ':' and self.check_value(): 
    220220            return self.fetch_value() 
    221221 
    222222        # Is it an alias? 
    223         if ch == u'*': 
     223        if ch == '*': 
    224224            return self.fetch_alias() 
    225225 
    226226        # Is it an anchor? 
    227         if ch == u'&': 
     227        if ch == '&': 
    228228            return self.fetch_anchor() 
    229229 
    230230        # Is it a tag? 
    231         if ch == u'!': 
     231        if ch == '!': 
    232232            return self.fetch_tag() 
    233233 
    234234        # Is it a literal scalar? 
    235         if ch == u'|' and not self.flow_level: 
     235        if ch == '|' and not self.flow_level: 
    236236            return self.fetch_literal() 
    237237 
    238238        # Is it a folded scalar? 
    239         if ch == u'>' and not self.flow_level: 
     239        if ch == '>' and not self.flow_level: 
    240240            return self.fetch_folded() 
    241241 
    242242        # Is it a single quoted scalar? 
    243         if ch == u'\'': 
     243        if ch == '\'': 
    244244            return self.fetch_single() 
    245245 
    246246        # Is it a double quoted scalar? 
    247         if ch == u'\"': 
     247        if ch == '\"': 
    248248            return self.fetch_double() 
    249249 
    250250        # It must be a plain scalar then. 
    … … class Scanner(object): 
    280280        # - should be no longer than 1024 characters. 
    281281        # Disabling this procedure will allow simple keys of any length and 
    282282        # height (may cause problems if indentation is broken though). 
    283         for level in self.possible_simple_keys.keys(): 
     283        for level in list(self.possible_simple_keys.keys()): 
    284284            key = self.possible_simple_keys[level] 
    285285            if key.line != self.line  \ 
    286286                    or self.index-key.index > 1024: 
    … … class Scanner(object): 
    691691 
    692692        # DOCUMENT-START:   ^ '---' (' '|'\n') 
    693693        if self.column == 0: 
    694             if self.prefix(3) == u'---'  \ 
    695                     and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     694            if self.prefix(3) == '---'  \ 
     695                    and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': 
    696696                return True 
    697697 
    698698    def check_document_end(self): 
    699699 
    700700        # DOCUMENT-END:     ^ '...' (' '|'\n') 
    701701        if self.column == 0: 
    702             if self.prefix(3) == u'...'  \ 
    703                     and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     702            if self.prefix(3) == '...'  \ 
     703                    and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': 
    704704                return True 
    705705 
    706706    def check_block_entry(self): 
    707707 
    708708        # BLOCK-ENTRY:      '-' (' '|'\n') 
    709         return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
     709        return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029' 
    710710 
    711711    def check_key(self): 
    712712 
    … … class Scanner(object): 
    716716 
    717717        # KEY(block context):   '?' (' '|'\n') 
    718718        else: 
    719             return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
     719            return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029' 
    720720 
    721721    def check_value(self): 
    722722 
    … … class Scanner(object): 
    726726 
    727727        # VALUE(block context): ':' (' '|'\n') 
    728728        else: 
    729             return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
     729            return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029' 
    730730 
    731731    def check_plain(self): 
    732732 
    … … class Scanner(object): 
    743743        # '-' character) because we want the flow context to be space 
    744744        # independent. 
    745745        ch = self.peek() 
    746         return ch not in u'\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`'  \ 
    747                 or (self.peek(1) not in u'\0 \t\r\n\x85\u2028\u2029' 
    748                         and (ch == u'-' or (not self.flow_level and ch in u'?:'))) 
     746        return ch not in '\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`'  \ 
     747                or (self.peek(1) not in '\0 \t\r\n\x85\u2028\u2029' 
     748                        and (ch == '-' or (not self.flow_level and ch in '?:'))) 
    749749 
    750750    # Scanners. 
    751751 
    … … class Scanner(object): 
    769769        # `unwind_indent` before issuing BLOCK-END. 
    770770        # Scanners for block, flow, and plain scalars need to be modified. 
    771771 
    772         if self.index == 0 and self.peek() == u'\uFEFF': 
     772        if self.index == 0 and self.peek() == '\uFEFF': 
    773773            self.forward() 
    774774        found = False 
    775775        while not found: 
    776             while self.peek() == u' ': 
     776            while self.peek() == ' ': 
    777777                self.forward() 
    778             if self.peek() == u'#': 
    779                 while self.peek() not in u'\0\r\n\x85\u2028\u2029': 
     778            if self.peek() == '#': 
     779                while self.peek() not in '\0\r\n\x85\u2028\u2029': 
    780780                    self.forward() 
    781781            if self.scan_line_break(): 
    782782                if not self.flow_level: 
    … … class Scanner(object): 
    790790        self.forward() 
    791791        name = self.scan_directive_name(start_mark) 
    792792        value = None 
    793         if name == u'YAML': 
     793        if name == 'YAML': 
    794794            value = self.scan_yaml_directive_value(start_mark) 
    795795            end_mark = self.get_mark() 
    796         elif name == u'TAG': 
     796        elif name == 'TAG': 
    797797            value = self.scan_tag_directive_value(start_mark) 
    798798            end_mark = self.get_mark() 
    799799        else: 
    800800            end_mark = self.get_mark() 
    801             while self.peek() not in u'\0\r\n\x85\u2028\u2029': 
     801            while self.peek() not in '\0\r\n\x85\u2028\u2029': 
    802802                self.forward() 
    803803        self.scan_directive_ignored_line(start_mark) 
    804804        return DirectiveToken(name, value, start_mark, end_mark) 
    … … class Scanner(object): 
    807807        # See the specification for details. 
    808808        length = 0 
    809809        ch = self.peek(length) 
    810         while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    811                 or ch in u'-_': 
     810        while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'  \ 
     811                or ch in '-_': 
    812812            length += 1 
    813813            ch = self.peek(length) 
    814814        if not length: 
    … … class Scanner(object): 
    818818        value = self.prefix(length) 
    819819        self.forward(length) 
    820820        ch = self.peek() 
    821         if ch not in u'\0 \r\n\x85\u2028\u2029': 
     821        if ch not in '\0 \r\n\x85\u2028\u2029': 
    822822            raise ScannerError("while scanning a directive", start_mark, 
    823823                    "expected alphabetic or numeric character, but found %r" 
    824824                    % ch.encode('utf-8'), self.get_mark()) 
    … … class Scanner(object): 
    826826 
    827827    def scan_yaml_directive_value(self, start_mark): 
    828828        # See the specification for details. 
    829         while self.peek() == u' ': 
     829        while self.peek() == ' ': 
    830830            self.forward() 
    831831        major = self.scan_yaml_directive_number(start_mark) 
    832832        if self.peek() != '.': 
    … … class Scanner(object): 
    836836                    self.get_mark()) 
    837837        self.forward() 
    838838        minor = self.scan_yaml_directive_number(start_mark) 
    839         if self.peek() not in u'\0 \r\n\x85\u2028\u2029': 
     839        if self.peek() not in '\0 \r\n\x85\u2028\u2029': 
    840840            raise ScannerError("while scanning a directive", start_mark, 
    841841                    "expected a digit or ' ', but found %r" 
    842842                    % self.peek().encode('utf-8'), 
    … … class Scanner(object): 
    846846    def scan_yaml_directive_number(self, start_mark): 
    847847        # See the specification for details. 
    848848        ch = self.peek() 
    849         if not (u'0' <= ch <= '9'): 
     849        if not ('0' <= ch <= '9'): 
    850850            raise ScannerError("while scanning a directive", start_mark, 
    851851                    "expected a digit, but found %r" % ch.encode('utf-8'), 
    852852                    self.get_mark()) 
    853853        length = 0 
    854         while u'0' <= self.peek(length) <= u'9': 
     854        while '0' <= self.peek(length) <= '9': 
    855855            length += 1 
    856856        value = int(self.prefix(length)) 
    857857        self.forward(length) 
    … … class Scanner(object): 
    859859 
    860860    def scan_tag_directive_value(self, start_mark): 
    861861        # See the specification for details. 
    862         while self.peek() == u' ': 
     862        while self.peek() == ' ': 
    863863            self.forward() 
    864864        handle = self.scan_tag_directive_handle(start_mark) 
    865         while self.peek() == u' ': 
     865        while self.peek() == ' ': 
    866866            self.forward() 
    867867        prefix = self.scan_tag_directive_prefix(start_mark) 
    868868        return (handle, prefix) 
    … … class Scanner(object): 
    871871        # See the specification for details. 
    872872        value = self.scan_tag_handle('directive', start_mark) 
    873873        ch = self.peek() 
    874         if ch != u' ': 
     874        if ch != ' ': 
    875875            raise ScannerError("while scanning a directive", start_mark, 
    876876                    "expected ' ', but found %r" % ch.encode('utf-8'), 
    877877                    self.get_mark()) 
    … … class Scanner(object): 
    881881        # See the specification for details. 
    882882        value = self.scan_tag_uri('directive', start_mark) 
    883883        ch = self.peek() 
    884         if ch not in u'\0 \r\n\x85\u2028\u2029': 
     884        if ch not in '\0 \r\n\x85\u2028\u2029': 
    885885            raise ScannerError("while scanning a directive", start_mark, 
    886886                    "expected ' ', but found %r" % ch.encode('utf-8'), 
    887887                    self.get_mark()) 
    … … class Scanner(object): 
    889889 
    890890    def scan_directive_ignored_line(self, start_mark): 
    891891        # See the specification for details. 
    892         while self.peek() == u' ': 
     892        while self.peek() == ' ': 
    893893            self.forward() 
    894         if self.peek() == u'#': 
    895             while self.peek() not in u'\0\r\n\x85\u2028\u2029': 
     894        if self.peek() == '#': 
     895            while self.peek() not in '\0\r\n\x85\u2028\u2029': 
    896896                self.forward() 
    897897        ch = self.peek() 
    898         if ch not in u'\0\r\n\x85\u2028\u2029': 
     898        if ch not in '\0\r\n\x85\u2028\u2029': 
    899899            raise ScannerError("while scanning a directive", start_mark, 
    900900                    "expected a comment or a line break, but found %r" 
    901901                        % ch.encode('utf-8'), self.get_mark()) 
    … … class Scanner(object): 
    919919        self.forward() 
    920920        length = 0 
    921921        ch = self.peek(length) 
    922         while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    923                 or ch in u'-_': 
     922        while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'  \ 
     923                or ch in '-_': 
    924924            length += 1 
    925925            ch = self.peek(length) 
    926926        if not length: 
    … … class Scanner(object): 
    930930        value = self.prefix(length) 
    931931        self.forward(length) 
    932932        ch = self.peek() 
    933         if ch not in u'\0 \t\r\n\x85\u2028\u2029?:,]}%@`': 
     933        if ch not in '\0 \t\r\n\x85\u2028\u2029?:,]}%@`': 
    934934            raise ScannerError("while scanning an %s" % name, start_mark, 
    935935                    "expected alphabetic or numeric character, but found %r" 
    936936                    % ch.encode('utf-8'), self.get_mark()) 
    … … class Scanner(object): 
    941941        # See the specification for details. 
    942942        start_mark = self.get_mark() 
    943943        ch = self.peek(1) 
    944         if ch == u'<': 
     944        if ch == '<': 
    945945            handle = None 
    946946            self.forward(2) 
    947947            suffix = self.scan_tag_uri('tag', start_mark) 
    948             if self.peek() != u'>': 
     948            if self.peek() != '>': 
    949949                raise ScannerError("while parsing a tag", start_mark, 
    950950                        "expected '>', but found %r" % self.peek().encode('utf-8'), 
    951951                        self.get_mark()) 
    952952            self.forward() 
    953         elif ch in u'\0 \t\r\n\x85\u2028\u2029': 
     953        elif ch in '\0 \t\r\n\x85\u2028\u2029': 
    954954            handle = None 
    955             suffix = u'!' 
     955            suffix = '!' 
    956956            self.forward() 
    957957        else: 
    958958            length = 1 
    959959            use_handle = False 
    960             while ch not in u'\0 \r\n\x85\u2028\u2029': 
    961                 if ch == u'!': 
     960            while ch not in '\0 \r\n\x85\u2028\u2029': 
     961                if ch == '!': 
    962962                    use_handle = True 
    963963                    break 
    964964                length += 1 
    965965                ch = self.peek(length) 
    966             handle = u'!' 
     966            handle = '!' 
    967967            if use_handle: 
    968968                handle = self.scan_tag_handle('tag', start_mark) 
    969969            else: 
    970                 handle = u'!' 
     970                handle = '!' 
    971971                self.forward() 
    972972            suffix = self.scan_tag_uri('tag', start_mark) 
    973973        ch = self.peek() 
    974         if ch not in u'\0 \r\n\x85\u2028\u2029': 
     974        if ch not in '\0 \r\n\x85\u2028\u2029': 
    975975            raise ScannerError("while scanning a tag", start_mark, 
    976976                    "expected ' ', but found %r" % ch.encode('utf-8'), 
    977977                    self.get_mark()) 
    … … class Scanner(object): 
    10051005        else: 
    10061006            indent = min_indent+increment-1 
    10071007            breaks, end_mark = self.scan_block_scalar_breaks(indent) 
    1008         line_break = u'' 
     1008        line_break = '' 
    10091009 
    10101010        # Scan the inner part of the block scalar. 
    1011         while self.column == indent and self.peek() != u'\0': 
     1011        while self.column == indent and self.peek() != '\0': 
    10121012            chunks.extend(breaks) 
    1013             leading_non_space = self.peek() not in u' \t' 
     1013            leading_non_space = self.peek() not in ' \t' 
    10141014            length = 0 
    1015             while self.peek(length) not in u'\0\r\n\x85\u2028\u2029': 
     1015            while self.peek(length) not in '\0\r\n\x85\u2028\u2029': 
    10161016                length += 1 
    10171017            chunks.append(self.prefix(length)) 
    10181018            self.forward(length) 
    10191019            line_break = self.scan_line_break() 
    10201020            breaks, end_mark = self.scan_block_scalar_breaks(indent) 
    1021             if self.column == indent and self.peek() != u'\0': 
     1021            if self.column == indent and self.peek() != '\0': 
    10221022 
    10231023                # Unfortunately, folding rules are ambiguous. 
    10241024                # 
    10251025                # This is the folding according to the specification: 
    10261026                 
    1027                 if folded and line_break == u'\n'   \ 
    1028                         and leading_non_space and self.peek() not in u' \t': 
     1027                if folded and line_break == '\n'   \ 
     1028                        and leading_non_space and self.peek() not in ' \t': 
    10291029                    if not breaks: 
    1030                         chunks.append(u' ') 
     1030                        chunks.append(' ') 
    10311031                else: 
    10321032                    chunks.append(line_break) 
    10331033                 
    10341034                # This is Clark Evans's interpretation (also in the spec 
    10351035                # examples): 
    10361036                # 
    1037                 #if folded and line_break == u'\n': 
     1037                #if folded and line_break == '\n': 
    10381038                #    if not breaks: 
    10391039                #        if self.peek() not in ' \t': 
    1040                 #            chunks.append(u' ') 
     1040                #            chunks.append(' ') 
    10411041                #        else: 
    10421042                #            chunks.append(line_break) 
    10431043                #else: 
    … … class Scanner(object): 
    10521052            chunks.extend(breaks) 
    10531053 
    10541054        # We are done. 
    1055         return ScalarToken(u''.join(chunks), False, start_mark, end_mark, 
     1055        return ScalarToken(''.join(chunks), False, start_mark, end_mark, 
    10561056                style) 
    10571057 
    10581058    def scan_block_scalar_indicators(self, start_mark): 
    … … class Scanner(object): 
    10601060        chomping = None 
    10611061        increment = None 
    10621062        ch = self.peek() 
    1063         if ch in u'+-': 
     1063        if ch in '+-': 
    10641064            if ch == '+': 
    10651065                chomping = True 
    10661066            else: 
    10671067                chomping = False 
    10681068            self.forward() 
    10691069            ch = self.peek() 
    1070             if ch in u'0123456789': 
     1070            if ch in '0123456789': 
    10711071                increment = int(ch) 
    10721072                if increment == 0: 
    10731073                    raise ScannerError("while scanning a block scalar", start_mark, 
    10741074                            "expected indentation indicator in the range 1-9, but found 0", 
    10751075                            self.get_mark()) 
    10761076                self.forward() 
    1077         elif ch in u'0123456789': 
     1077        elif ch in '0123456789': 
    10781078            increment = int(ch) 
    10791079            if increment == 0: 
    10801080                raise ScannerError("while scanning a block scalar", start_mark, 
    … … class Scanner(object): 
    10821082                        self.get_mark()) 
    10831083            self.forward() 
    10841084            ch = self.peek() 
    1085             if ch in u'+-': 
     1085            if ch in '+-': 
    10861086                if ch == '+': 
    10871087                    chomping = True 
    10881088                else: 
    10891089                    chomping = False 
    10901090                self.forward() 
    10911091        ch = self.peek() 
    1092         if ch not in u'\0 \r\n\x85\u2028\u2029': 
     1092        if ch not in '\0 \r\n\x85\u2028\u2029': 
    10931093            raise ScannerError("while scanning a block scalar", start_mark, 
    10941094                    "expected chomping or indentation indicators, but found %r" 
    10951095                        % ch.encode('utf-8'), self.get_mark()) 
    … … class Scanner(object): 
    10971097 
    10981098    def scan_block_scalar_ignored_line(self, start_mark): 
    10991099        # See the specification for details. 
    1100         while self.peek() == u' ': 
     1100        while self.peek() == ' ': 
    11011101            self.forward() 
    1102         if self.peek() == u'#': 
    1103             while self.peek() not in u'\0\r\n\x85\u2028\u2029': 
     1102        if self.peek() == '#': 
     1103            while self.peek() not in '\0\r\n\x85\u2028\u2029': 
    11041104                self.forward() 
    11051105        ch = self.peek() 
    1106         if ch not in u'\0\r\n\x85\u2028\u2029': 
     1106        if ch not in '\0\r\n\x85\u2028\u2029': 
    11071107            raise ScannerError("while scanning a block scalar", start_mark, 
    11081108                    "expected a comment or a line break, but found %r" 
    11091109                        % ch.encode('utf-8'), self.get_mark()) 
    … … class Scanner(object): 
    11141114        chunks = [] 
    11151115        max_indent = 0 
    11161116        end_mark = self.get_mark() 
    1117         while self.peek() in u' \r\n\x85\u2028\u2029': 
    1118             if self.peek() != u' ': 
     1117        while self.peek() in ' \r\n\x85\u2028\u2029': 
     1118            if self.peek() != ' ': 
    11191119                chunks.append(self.scan_line_break()) 
    11201120                end_mark = self.get_mark() 
    11211121            else: 
    … … class Scanner(object): 
    11281128        # See the specification for details. 
    11291129        chunks = [] 
    11301130        end_mark = self.get_mark() 
    1131         while self.column < indent and self.peek() == u' ': 
     1131        while self.column < indent and self.peek() == ' ': 
    11321132            self.forward() 
    1133         while self.peek() in u'\r\n\x85\u2028\u2029': 
     1133        while self.peek() in '\r\n\x85\u2028\u2029': 
    11341134            chunks.append(self.scan_line_break()) 
    11351135            end_mark = self.get_mark() 
    1136             while self.column < indent and self.peek() == u' ': 
     1136            while self.column < indent and self.peek() == ' ': 
    11371137                self.forward() 
    11381138        return chunks, end_mark 
    11391139 
    … … class Scanner(object): 
    11581158            chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark)) 
    11591159        self.forward() 
    11601160        end_mark = self.get_mark() 
    1161         return ScalarToken(u''.join(chunks), False, start_mark, end_mark, 
     1161        return ScalarToken(''.join(chunks), False, start_mark, end_mark, 
    11621162                style) 
    11631163 
    11641164    ESCAPE_REPLACEMENTS = { 
    1165         u'0':   u'\0', 
    1166         u'a':   u'\x07', 
    1167         u'b':   u'\x08', 
    1168         u't':   u'\x09', 
    1169         u'\t':  u'\x09', 
    1170         u'n':   u'\x0A', 
    1171         u'v':   u'\x0B', 
    1172         u'f':   u'\x0C', 
    1173         u'r':   u'\x0D', 
    1174         u'e':   u'\x1B', 
    1175         u' ':   u'\x20', 
    1176         u'\"':  u'\"', 
    1177         u'\\':  u'\\', 
    1178         u'N':   u'\x85', 
    1179         u'_':   u'\xA0', 
    1180         u'L':   u'\u2028', 
    1181         u'P':   u'\u2029', 
     1165        '0':   '\0', 
     1166        'a':   '\x07', 
     1167        'b':   '\x08', 
     1168        't':   '\x09', 
     1169        '\t':  '\x09', 
     1170        'n':   '\x0A', 
     1171        'v':   '\x0B', 
     1172        'f':   '\x0C', 
     1173        'r':   '\x0D', 
     1174        'e':   '\x1B', 
     1175        ' ':   '\x20', 
     1176        '\"':  '\"', 
     1177        '\\':  '\\', 
     1178        'N':   '\x85', 
     1179        '_':   '\xA0', 
     1180        'L':   '\u2028', 
     1181        'P':   '\u2029', 
    11821182    } 
    11831183 
    11841184    ESCAPE_CODES = { 
    1185         u'x':   2, 
    1186         u'u':   4, 
    1187         u'U':   8, 
     1185        'x':   2, 
     1186        'u':   4, 
     1187        'U':   8, 
    11881188    } 
    11891189 
    11901190    def scan_flow_scalar_non_spaces(self, double, start_mark): 
    … … class Scanner(object): 
    11921192        chunks = [] 
    11931193        while True: 
    11941194            length = 0 
    1195             while self.peek(length) not in u'\'\"\\\0 \t\r\n\x85\u2028\u2029': 
     1195            while self.peek(length) not in '\'\"\\\0 \t\r\n\x85\u2028\u2029': 
    11961196                length += 1 
    11971197            if length: 
    11981198                chunks.append(self.prefix(length)) 
    11991199                self.forward(length) 
    12001200            ch = self.peek() 
    1201             if not double and ch == u'\'' and self.peek(1) == u'\'': 
    1202                 chunks.append(u'\'') 
     1201            if not double and ch == '\'' and self.peek(1) == '\'': 
     1202                chunks.append('\'') 
    12031203                self.forward(2) 
    1204             elif (double and ch == u'\'') or (not double and ch in u'\"\\'): 
     1204            elif (double and ch == '\'') or (not double and ch in '\"\\'): 
    12051205                chunks.append(ch) 
    12061206                self.forward() 
    1207             elif double and ch == u'\\': 
     1207            elif double and ch == '\\': 
    12081208                self.forward() 
    12091209                ch = self.peek() 
    12101210                if ch in self.ESCAPE_REPLACEMENTS: 
    … … class Scanner(object): 
    12141214                    length = self.ESCAPE_CODES[ch] 
    12151215                    self.forward() 
    12161216                    for k in range(length): 
    1217                         if self.peek(k) not in u'0123456789ABCDEFabcdef': 
     1217                        if self.peek(k) not in '0123456789ABCDEFabcdef': 
    12181218                            raise ScannerError("while scanning a double-quoted scalar", start_mark, 
    12191219                                    "expected escape sequence of %d hexdecimal numbers, but found %r" % 
    12201220                                        (length, self.peek(k).encode('utf-8')), self.get_mark()) 
    12211221                    code = int(self.prefix(length), 16) 
    1222                     chunks.append(unichr(code)) 
     1222                    chunks.append(chr(code)) 
    12231223                    self.forward(length) 
    1224                 elif ch in u'\r\n\x85\u2028\u2029': 
     1224                elif ch in '\r\n\x85\u2028\u2029': 
    12251225                    self.scan_line_break() 
    12261226                    chunks.extend(self.scan_flow_scalar_breaks(double, start_mark)) 
    12271227                else: 
    … … class Scanner(object): 
    12341234        # See the specification for details. 
    12351235        chunks = [] 
    12361236        length = 0 
    1237         while self.peek(length) in u' \t': 
     1237        while self.peek(length) in ' \t': 
    12381238            length += 1 
    12391239        whitespaces = self.prefix(length) 
    12401240        self.forward(length) 
    12411241        ch = self.peek() 
    1242         if ch == u'\0': 
     1242        if ch == '\0': 
    12431243            raise ScannerError("while scanning a quoted scalar", start_mark, 
    12441244                    "found unexpected end of stream", self.get_mark()) 
    1245         elif ch in u'\r\n\x85\u2028\u2029': 
     1245        elif ch in '\r\n\x85\u2028\u2029': 
    12461246            line_break = self.scan_line_break() 
    12471247            breaks = self.scan_flow_scalar_breaks(double, start_mark) 
    1248             if line_break != u'\n': 
     1248            if line_break != '\n': 
    12491249                chunks.append(line_break) 
    12501250            elif not breaks: 
    1251                 chunks.append(u' ') 
     1251                chunks.append(' ') 
    12521252            chunks.extend(breaks) 
    12531253        else: 
    12541254            chunks.append(whitespaces) 
    … … class Scanner(object): 
    12611261            # Instead of checking indentation, we check for document 
    12621262            # separators. 
    12631263            prefix = self.prefix(3) 
    1264             if (prefix == u'---' or prefix == u'...')   \ 
    1265                     and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     1264            if (prefix == '---' or prefix == '...')   \ 
     1265                    and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': 
    12661266                raise ScannerError("while scanning a quoted scalar", start_mark, 
    12671267                        "found unexpected document separator", self.get_mark()) 
    1268             while self.peek() in u' \t': 
     1268            while self.peek() in ' \t': 
    12691269                self.forward() 
    1270             if self.peek() in u'\r\n\x85\u2028\u2029': 
     1270            if self.peek() in '\r\n\x85\u2028\u2029': 
    12711271                chunks.append(self.scan_line_break()) 
    12721272            else: 
    12731273                return chunks 
    … … class Scanner(object): 
    12891289        spaces = [] 
    12901290        while True: 
    12911291            length = 0 
    1292             if self.peek() == u'#': 
     1292            if self.peek() == '#': 
    12931293                break 
    12941294            while True: 
    12951295                ch = self.peek(length) 
    1296                 if ch in u'\0 \t\r\n\x85\u2028\u2029'   \ 
    1297                         or (not self.flow_level and ch == u':' and 
    1298                                 self.peek(length+1) in u'\0 \t\r\n\x85\u2028\u2029') \ 
    1299                         or (self.flow_level and ch in u',:?[]{}'): 
     1296                if ch in '\0 \t\r\n\x85\u2028\u2029'   \ 
     1297                        or (not self.flow_level and ch == ':' and 
     1298                                self.peek(length+1) in '\0 \t\r\n\x85\u2028\u2029') \ 
     1299                        or (self.flow_level and ch in ',:?[]{}'): 
    13001300                    break 
    13011301                length += 1 
    13021302            # It's not clear what we should do with ':' in the flow context. 
    1303             if (self.flow_level and ch == u':' 
    1304                     and self.peek(length+1) not in u'\0 \t\r\n\x85\u2028\u2029,[]{}'): 
     1303            if (self.flow_level and ch == ':' 
     1304                    and self.peek(length+1) not in '\0 \t\r\n\x85\u2028\u2029,[]{}'): 
    13051305                self.forward(length) 
    13061306                raise ScannerError("while scanning a plain scalar", start_mark, 
    13071307                    "found unexpected ':'", self.get_mark(), 
    … … class Scanner(object): 
    13141314            self.forward(length) 
    13151315            end_mark = self.get_mark() 
    13161316            spaces = self.scan_plain_spaces(indent, start_mark) 
    1317             if not spaces or self.peek() == u'#' \ 
     1317            if not spaces or self.peek() == '#' \ 
    13181318                    or (not self.flow_level and self.column < indent): 
    13191319                break 
    1320         return ScalarToken(u''.join(chunks), True, start_mark, end_mark) 
     1320        return ScalarToken(''.join(chunks), True, start_mark, end_mark) 
    13211321 
    13221322    def scan_plain_spaces(self, indent, start_mark): 
    13231323        # See the specification for details. 
    … … class Scanner(object): 
    13251325        # We just forbid them completely. Do not use tabs in YAML! 
    13261326        chunks = [] 
    13271327        length = 0 
    1328         while self.peek(length) in u' ': 
     1328        while self.peek(length) in ' ': 
    13291329            length += 1 
    13301330        whitespaces = self.prefix(length) 
    13311331        self.forward(length) 
    13321332        ch = self.peek() 
    1333         if ch in u'\r\n\x85\u2028\u2029': 
     1333        if ch in '\r\n\x85\u2028\u2029': 
    13341334            line_break = self.scan_line_break() 
    13351335            self.allow_simple_key = True 
    13361336            prefix = self.prefix(3) 
    1337             if (prefix == u'---' or prefix == u'...')   \ 
    1338                     and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     1337            if (prefix == '---' or prefix == '...')   \ 
     1338                    and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': 
    13391339                return 
    13401340            breaks = [] 
    1341             while self.peek() in u' \r\n\x85\u2028\u2029': 
     1341            while self.peek() in ' \r\n\x85\u2028\u2029': 
    13421342                if self.peek() == ' ': 
    13431343                    self.forward() 
    13441344                else: 
    13451345                    breaks.append(self.scan_line_break()) 
    13461346                    prefix = self.prefix(3) 
    1347                     if (prefix == u'---' or prefix == u'...')   \ 
    1348                             and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     1347                    if (prefix == '---' or prefix == '...')   \ 
     1348                            and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': 
    13491349                        return 
    1350             if line_break != u'\n': 
     1350            if line_break != '\n': 
    13511351                chunks.append(line_break) 
    13521352            elif not breaks: 
    1353                 chunks.append(u' ') 
     1353                chunks.append(' ') 
    13541354            chunks.extend(breaks) 
    13551355        elif whitespaces: 
    13561356            chunks.append(whitespaces) 
    … … class Scanner(object): 
    13611361        # For some strange reasons, the specification does not allow '_' in 
    13621362        # tag handles. I have allowed it anyway. 
    13631363        ch = self.peek() 
    1364         if ch != u'!': 
     1364        if ch != '!': 
    13651365            raise ScannerError("while scanning a %s" % name, start_mark, 
    13661366                    "expected '!', but found %r" % ch.encode('utf-8'), 
    13671367                    self.get_mark()) 
    13681368        length = 1 
    13691369        ch = self.peek(length) 
    1370         if ch != u' ': 
    1371             while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    1372                     or ch in u'-_': 
     1370        if ch != ' ': 
     1371            while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'  \ 
     1372                    or ch in '-_': 
    13731373                length += 1 
    13741374                ch = self.peek(length) 
    1375             if ch != u'!': 
     1375            if ch != '!': 
    13761376                self.forward(length) 
    13771377                raise ScannerError("while scanning a %s" % name, start_mark, 
    13781378                        "expected '!', but found %r" % ch.encode('utf-8'), 
    … … class Scanner(object): 
    13881388        chunks = [] 
    13891389        length = 0 
    13901390        ch = self.peek(length) 
    1391         while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    1392                 or ch in u'-;/?:@&=+$,_.!~*\'()[]%': 
    1393             if ch == u'%': 
     1391        while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'  \ 
     1392                or ch in '-;/?:@&=+$,_.!~*\'()[]%': 
     1393            if ch == '%': 
    13941394                chunks.append(self.prefix(length)) 
    13951395                self.forward(length) 
    13961396                length = 0 
    … … class Scanner(object): 
    14061406            raise ScannerError("while parsing a %s" % name, start_mark, 
    14071407                    "expected URI, but found %r" % ch.encode('utf-8'), 
    14081408                    self.get_mark()) 
    1409         return u''.join(chunks) 
     1409        return ''.join(chunks) 
    14101410 
    14111411    def scan_uri_escapes(self, name, start_mark): 
    14121412        # See the specification for details. 
    14131413        bytes = [] 
    14141414        mark = self.get_mark() 
    1415         while self.peek() == u'%': 
     1415        while self.peek() == '%': 
    14161416            self.forward() 
    14171417            for k in range(2): 
    1418                 if self.peek(k) not in u'0123456789ABCDEFabcdef': 
     1418                if self.peek(k) not in '0123456789ABCDEFabcdef': 
    14191419                    raise ScannerError("while scanning a %s" % name, start_mark, 
    14201420                            "expected URI escape sequence of 2 hexdecimal numbers, but found %r" % 
    14211421                                (self.peek(k).encode('utf-8')), self.get_mark()) 
    14221422            bytes.append(chr(int(self.prefix(2), 16))) 
    14231423            self.forward(2) 
    14241424        try: 
    1425             value = unicode(''.join(bytes), 'utf-8') 
    1426         except UnicodeDecodeError, exc: 
     1425            value = str(''.join(bytes)) 
     1426        except UnicodeDecodeError as exc: 
    14271427            raise ScannerError("while scanning a %s" % name, start_mark, str(exc), mark) 
    14281428        return value 
    14291429 
    … … class Scanner(object): 
    14371437        #   '\u2029     :   '\u2029' 
    14381438        #   default     :   '' 
    14391439        ch = self.peek() 
    1440         if ch in u'\r\n\x85': 
    1441             if self.prefix(2) == u'\r\n': 
     1440        if ch in '\r\n\x85': 
     1441            if self.prefix(2) == '\r\n': 
    14421442                self.forward(2) 
    14431443            else: 
    14441444                self.forward() 
    1445             return u'\n' 
    1446         elif ch in u'\u2028\u2029': 
     1445            return '\n' 
     1446        elif ch in '\u2028\u2029': 
    14471447            self.forward() 
    14481448            return ch 
    1449         return u'' 
     1449        return '' 
    14501450 
    14511451#try: 
    14521452#    import psyco 

  • lib/yaml/serializer.py 

    diff --git lib/yaml/serializer.py lib/yaml/serializer.py
index 2101f95..d193c41 100644
     
    11 
    22__all__ = ['Serializer', 'SerializerError'] 
    33 
    4 from error import YAMLError 
    5 from events import * 
    6 from nodes import * 
     4from yaml.error import YAMLError 
     5from yaml.events import * 
     6from yaml.nodes import * 
    77 
    88class SerializerError(YAMLError): 
    99    pass 
    1010 
    11 class Serializer(object): 
     11class Serializer: 
    1212 
    13     ANCHOR_TEMPLATE = u'id%03d' 
     13    ANCHOR_TEMPLATE = 'id%03d' 
    1414 
    1515    def __init__(self, encoding=None, 
    1616            explicit_start=None, explicit_end=None, version=None, tags=None): 

  • lib/yaml/tokens.py 

    diff --git lib/yaml/tokens.py lib/yaml/tokens.py
index 4d0b48a..0cbd7e5 100644
     
    11 
    2 class Token(object): 
     2class Token: 
    33    def __init__(self, start_mark, end_mark): 
    44        self.start_mark = start_mark 
    55        self.end_mark = end_mark 
    66    def __repr__(self): 
    7         attributes = [key for key in self.__dict__ 
    8                 if not key.endswith('_mark')] 
    9         attributes.sort() 
    10         arguments = ', '.join(['%s=%r' % (key, getattr(self, key)) 
    11                 for key in attributes]) 
     7        attributes = sorted(key for key in self.__dict__ 
     8                if not key.endswith('_mark')) 
     9        arguments = ', '.join('%s=%r' % (key, getattr(self, key)) 
     10                for key in attributes) 
    1211        return '%s(%s)' % (self.__class__.__name__, arguments) 
    1312 
    1413#class BOMToken(Token): 

  • tests/data/construct-binary.code 

    diff --git tests/data/construct-binary.code tests/data/construct-binary.code
index 67ac0d5..30bfc3f 100644
     
    11{ 
    22    "canonical": 
    3         "GIF89a\x0c\x00\x0c\x00\x84\x00\x00\xff\xff\xf7\xf5\xf5\xee\xe9\xe9\xe5fff\x00\x00\x00\xe7\xe7\xe7^^^\xf3\xf3\xed\x8e\x8e\x8e\xe0\xe0\xe0\x9f\x9f\x9f\x93\x93\x93\xa7\xa7\xa7\x9e\x9e\x9eiiiccc\xa3\xa3\xa3\x84\x84\x84\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9!\xfe\x0eMade with GIMP\x00,\x00\x00\x00\x00\x0c\x00\x0c\x00\x00\x05,  \x8e\x810\x9e\xe3@\x14\xe8i\x10\xc4\xd1\x8a\x08\x1c\xcf\x80M$z\xef\xff0\x85p\xb8\xb01f\r\x1b\xce\x01\xc3\x01\x1e\x10' \x82\n\x01\x00;", 
     3        b"GIF89a\x0c\x00\x0c\x00\x84\x00\x00\xff\xff\xf7\xf5\xf5\xee\xe9\xe9\xe5fff\x00\x00\x00\xe7\xe7\xe7^^^\xf3\xf3\xed\x8e\x8e\x8e\xe0\xe0\xe0\x9f\x9f\x9f\x93\x93\x93\xa7\xa7\xa7\x9e\x9e\x9eiiiccc\xa3\xa3\xa3\x84\x84\x84\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9!\xfe\x0eMade with GIMP\x00,\x00\x00\x00\x00\x0c\x00\x0c\x00\x00\x05,  \x8e\x810\x9e\xe3@\x14\xe8i\x10\xc4\xd1\x8a\x08\x1c\xcf\x80M$z\xef\xff0\x85p\xb8\xb01f\r\x1b\xce\x01\xc3\x01\x1e\x10' \x82\n\x01\x00;", 
    44    "generic": 
    5         "GIF89a\x0c\x00\x0c\x00\x84\x00\x00\xff\xff\xf7\xf5\xf5\xee\xe9\xe9\xe5fff\x00\x00\x00\xe7\xe7\xe7^^^\xf3\xf3\xed\x8e\x8e\x8e\xe0\xe0\xe0\x9f\x9f\x9f\x93\x93\x93\xa7\xa7\xa7\x9e\x9e\x9eiiiccc\xa3\xa3\xa3\x84\x84\x84\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9!\xfe\x0eMade with GIMP\x00,\x00\x00\x00\x00\x0c\x00\x0c\x00\x00\x05,  \x8e\x810\x9e\xe3@\x14\xe8i\x10\xc4\xd1\x8a\x08\x1c\xcf\x80M$z\xef\xff0\x85p\xb8\xb01f\r\x1b\xce\x01\xc3\x01\x1e\x10' \x82\n\x01\x00;", 
     5        b"GIF89a\x0c\x00\x0c\x00\x84\x00\x00\xff\xff\xf7\xf5\xf5\xee\xe9\xe9\xe5fff\x00\x00\x00\xe7\xe7\xe7^^^\xf3\xf3\xed\x8e\x8e\x8e\xe0\xe0\xe0\x9f\x9f\x9f\x93\x93\x93\xa7\xa7\xa7\x9e\x9e\x9eiiiccc\xa3\xa3\xa3\x84\x84\x84\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9!\xfe\x0eMade with GIMP\x00,\x00\x00\x00\x00\x0c\x00\x0c\x00\x00\x05,  \x8e\x810\x9e\xe3@\x14\xe8i\x10\xc4\xd1\x8a\x08\x1c\xcf\x80M$z\xef\xff0\x85p\xb8\xb01f\r\x1b\xce\x01\xc3\x01\x1e\x10' \x82\n\x01\x00;", 
    66    "description": "The binary value above is a tiny arrow encoded as a gif image.", 
    77} 

  • new file tests/data/construct-python-bytes-ascii.code 

    diff --git tests/data/construct-python-bytes-ascii.code tests/data/construct-python-bytes-ascii.code
new file mode 100644
index 0000000..aa9a80b
    - +  
     1b"ascii string" 

  • new file tests/data/construct-python-bytes-ascii.data 

    diff --git tests/data/construct-python-bytes-ascii.data tests/data/construct-python-bytes-ascii.data
new file mode 100644
index 0000000..dc53f06
    - +  
     1--- !!python/bytes "ascii string" 

  • new file tests/data/construct-python-bytes-utf8.code 

    diff --git tests/data/construct-python-bytes-utf8.code tests/data/construct-python-bytes-utf8.code
new file mode 100644
index 0000000..6ca7d8f
    - +  
     1'\u042d\u0442\u043e \u0443\u043d\u0438\u043a\u043e\u0434\u043d\u0430\u044f \u0441\u0442\u0440\u043e\u043a\u0430'.encode('utf-8') 

  • new file tests/data/construct-python-bytes-utf8.data 

    diff --git tests/data/construct-python-bytes-utf8.data tests/data/construct-python-bytes-utf8.data
new file mode 100644
index 0000000..4e916c0
    - +  
     1--- !!python/bytes "ЭтП уМОкПЎМая стрПка" 

  • tests/data/construct-python-long-short.code 

    diff --git tests/data/construct-python-long-short.code tests/data/construct-python-long-short.code
index fafc3f1..190a180 100644
     
    1 123L 
     1123 

  • tests/data/construct-python-name-module.code 

    diff --git tests/data/construct-python-name-module.code tests/data/construct-python-name-module.code
index 335c7ca..4e6a519 100644
     
    1 [file, Loader, dump, abs, yaml.tokens] 
     1[list, Loader, dump, abs, yaml.tokens] 

  • tests/data/construct-python-name-module.data 

    diff --git tests/data/construct-python-name-module.data tests/data/construct-python-name-module.data
index c8f8036..7f1cc20 100644
     
    1 - !!python/name:file 
     1- !!python/name:list 
    22- !!python/name:yaml.Loader 
    33- !!python/name:yaml.dump 
    44- !!python/name:abs 

  • tests/data/construct-python-object.code 

    diff --git tests/data/construct-python-object.code tests/data/construct-python-object.code
index 7f1edf1..651a669 100644
     
    11[ 
    22AnObject(1, 'two', [3,3,3]), 
    3 AnInstance(1, 'two', [3,3,3]), 
    43 
    54AnObject(1, 'two', [3,3,3]), 
    6 AnInstance(1, 'two', [3,3,3]), 
    75 
    86AState(1, 'two', [3,3,3]), 
    97ACustomState(1, 'two', [3,3,3]), 
    108 
    11 InitArgs(1, 'two', [3,3,3]), 
    12 InitArgsWithState(1, 'two', [3,3,3]), 
    13  
    149NewArgs(1, 'two', [3,3,3]), 
    1510NewArgsWithState(1, 'two', [3,3,3]), 
    1611 

  • tests/data/construct-python-object.data 

    diff --git tests/data/construct-python-object.data tests/data/construct-python-object.data
index bce8b2e..2414f09 100644
     
    11- !!python/object:test_constructor.AnObject { foo: 1, bar: two, baz: [3,3,3] } 
    2 - !!python/object:test_constructor.AnInstance { foo: 1, bar: two, baz: [3,3,3] } 
    32 
    43- !!python/object/new:test_constructor.AnObject { args: [1, two], kwds: {baz: [3,3,3]} } 
    5 - !!python/object/apply:test_constructor.AnInstance { args: [1, two], kwds: {baz: [3,3,3]} } 
    64 
    75- !!python/object:test_constructor.AState { _foo: 1, _bar: two, _baz: [3,3,3] } 
    86- !!python/object/new:test_constructor.ACustomState { state: !!python/tuple [1, two, [3,3,3]] } 
    97 
    10 - !!python/object/new:test_constructor.InitArgs [1, two, [3,3,3]] 
    11 - !!python/object/new:test_constructor.InitArgsWithState { args: [1, two], state: [3,3,3] } 
    12  
    138- !!python/object/new:test_constructor.NewArgs [1, two, [3,3,3]] 
    149- !!python/object/new:test_constructor.NewArgsWithState { args: [1, two], state: [3,3,3] } 
    1510 

  • tests/data/construct-python-str-utf8.code 

    diff --git tests/data/construct-python-str-utf8.code tests/data/construct-python-str-utf8.code
index 47b28ab..9f66032 100644
     
    1 u'\u042d\u0442\u043e \u0443\u043d\u0438\u043a\u043e\u0434\u043d\u0430\u044f \u0441\u0442\u0440\u043e\u043a\u0430'.encode('utf-8') 
     1'\u042d\u0442\u043e \u0443\u043d\u0438\u043a\u043e\u0434\u043d\u0430\u044f \u0441\u0442\u0440\u043e\u043a\u0430' 

  • deleted file tests/data/construct-python-unicode-ascii.code 

    diff --git tests/data/construct-python-unicode-ascii.code tests/data/construct-python-unicode-ascii.code
deleted file mode 100644
index d4cd82c..0000000
    + -  
    1 u"ascii string" 

  • deleted file tests/data/construct-python-unicode-ascii.data 

    diff --git tests/data/construct-python-unicode-ascii.data tests/data/construct-python-unicode-ascii.data
deleted file mode 100644
index 3a0647b..0000000
    + -  
    1 --- !!python/unicode "ascii string" 

  • deleted file tests/data/construct-python-unicode-utf8.code 

    diff --git tests/data/construct-python-unicode-utf8.code tests/data/construct-python-unicode-utf8.code
deleted file mode 100644
index 2793ac7..0000000
    + -  
    1 u'\u042d\u0442\u043e \u0443\u043d\u0438\u043a\u043e\u0434\u043d\u0430\u044f \u0441\u0442\u0440\u043e\u043a\u0430' 

  • deleted file tests/data/construct-python-unicode-utf8.data 

    diff --git tests/data/construct-python-unicode-utf8.data tests/data/construct-python-unicode-utf8.data
deleted file mode 100644
index 5a980ea..0000000
    + -  
    1 --- !!python/unicode "ЭтП уМОкПЎМая стрПка" 

  • tests/data/construct-str-utf8.code 

    diff --git tests/data/construct-str-utf8.code tests/data/construct-str-utf8.code
index 2793ac7..9f66032 100644
     
    1 u'\u042d\u0442\u043e \u0443\u043d\u0438\u043a\u043e\u0434\u043d\u0430\u044f \u0441\u0442\u0440\u043e\u043a\u0430' 
     1'\u042d\u0442\u043e \u0443\u043d\u0438\u043a\u043e\u0434\u043d\u0430\u044f \u0441\u0442\u0440\u043e\u043a\u0430' 

  • tests/data/emitting-unacceptable-unicode-character-bug.code 

    diff --git tests/data/emitting-unacceptable-unicode-character-bug.code tests/data/emitting-unacceptable-unicode-character-bug.code
index 4b92854..2a5df00 100644
     
    1 u"\udd00" 
     1"\udd00" 

  • tests/data/recursive-set.recursive 

    diff --git tests/data/recursive-set.recursive tests/data/recursive-set.recursive
index 457c50d..d1a7ca3 100644
     
    1 try: 
    2     set 
    3 except NameError: 
    4     from sets import Set as set 
    51value = set() 
    62value.add(AnInstance(foo=value, bar=value)) 
    73value.add(AnInstance(foo=value, bar=value)) 

  • tests/data/serializer-is-already-opened.dumper-error 

    diff --git tests/data/serializer-is-already-opened.dumper-error tests/data/serializer-is-already-opened.dumper-error
index 0f66a46..c2be9bb 100644
     
    1 dumper = Dumper(StringIO.StringIO()) 
     1dumper = Dumper(io.StringIO()) 
    22dumper.open() 
    33dumper.open() 

  • tests/data/serializer-is-closed-1.dumper-error 

    diff --git tests/data/serializer-is-closed-1.dumper-error tests/data/serializer-is-closed-1.dumper-error
index 5d9ecfc..93dcd66 100644
     
    1 dumper = Dumper(StringIO.StringIO()) 
     1dumper = Dumper(io.StringIO()) 
    22dumper.open() 
    33dumper.close() 
    44dumper.open() 

  • tests/data/serializer-is-closed-2.dumper-error 

    diff --git tests/data/serializer-is-closed-2.dumper-error tests/data/serializer-is-closed-2.dumper-error
index 0762145..e15fb9d 100644
     
    1 dumper = Dumper(StringIO.StringIO()) 
     1dumper = Dumper(io.StringIO()) 
    22dumper.open() 
    33dumper.close() 
    44dumper.serialize(ScalarNode(tag='!foo', value='bar')) 

  • tests/data/serializer-is-not-opened-1.dumper-error 

    diff --git tests/data/serializer-is-not-opened-1.dumper-error tests/data/serializer-is-not-opened-1.dumper-error
index 1d21554..8f68baf 100644
     
    1 dumper = Dumper(StringIO.StringIO()) 
     1dumper = Dumper(io.StringIO()) 
    22dumper.close() 

  • tests/data/serializer-is-not-opened-2.dumper-error 

    diff --git tests/data/serializer-is-not-opened-2.dumper-error tests/data/serializer-is-not-opened-2.dumper-error
index d1d7f98..e818837 100644
     
    1 dumper = Dumper(StringIO.StringIO()) 
     1dumper = Dumper(io.StringIO()) 
    22dumper.serialize(ScalarNode(tag='!foo', value='bar')) 

  • tests/test_appliance.py 

    diff --git tests/test_appliance.py tests/test_appliance.py
index d5e5d3e..5f3c23f 100644
    class Error(Exception): 
    4343class CanonicalScanner: 
    4444 
    4545    def __init__(self, data): 
    46         self.data = unicode(data, 'utf-8')+u'\0' 
     46        self.data = str(data, 'utf-8')+'\0' 
    4747        self.index = 0 
    4848        self.scan() 
    4949 
    … … class CanonicalScanner: 
    7676        while True: 
    7777            self.find_token() 
    7878            ch = self.data[self.index] 
    79             if ch == u'\0': 
     79            if ch == '\0': 
    8080                self.tokens.append(StreamEndToken(None, None)) 
    8181                break 
    82             elif ch == u'%': 
     82            elif ch == '%': 
    8383                self.tokens.append(self.scan_directive()) 
    84             elif ch == u'-' and self.data[self.index:self.index+3] == u'---': 
     84            elif ch == '-' and self.data[self.index:self.index+3] == '---': 
    8585                self.index += 3 
    8686                self.tokens.append(DocumentStartToken(None, None)) 
    87             elif ch == u'[': 
     87            elif ch == '[': 
    8888                self.index += 1 
    8989                self.tokens.append(FlowSequenceStartToken(None, None)) 
    90             elif ch == u'{': 
     90            elif ch == '{': 
    9191                self.index += 1 
    9292                self.tokens.append(FlowMappingStartToken(None, None)) 
    93             elif ch == u']': 
     93            elif ch == ']': 
    9494                self.index += 1 
    9595                self.tokens.append(FlowSequenceEndToken(None, None)) 
    96             elif ch == u'}': 
     96            elif ch == '}': 
    9797                self.index += 1 
    9898                self.tokens.append(FlowMappingEndToken(None, None)) 
    99             elif ch == u'?': 
     99            elif ch == '?': 
    100100                self.index += 1 
    101101                self.tokens.append(KeyToken(None, None)) 
    102             elif ch == u':': 
     102            elif ch == ':': 
    103103                self.index += 1 
    104104                self.tokens.append(ValueToken(None, None)) 
    105             elif ch == u',': 
     105            elif ch == ',': 
    106106                self.index += 1 
    107107                self.tokens.append(FlowEntryToken(None, None)) 
    108             elif ch == u'*' or ch == u'&': 
     108            elif ch == '*' or ch == '&': 
    109109                self.tokens.append(self.scan_alias()) 
    110             elif ch == u'!': 
     110            elif ch == '!': 
    111111                self.tokens.append(self.scan_tag()) 
    112             elif ch == u'"': 
     112            elif ch == '"': 
    113113                self.tokens.append(self.scan_scalar()) 
    114114            else: 
    115115                raise Error("invalid token") 
    116116 
    117     DIRECTIVE = u'%YAML 1.1' 
     117    DIRECTIVE = '%YAML 1.1' 
    118118 
    119119    def scan_directive(self): 
    120120        if self.data[self.index:self.index+len(self.DIRECTIVE)] == self.DIRECTIVE and \ 
    121                 self.data[self.index+len(self.DIRECTIVE)] in u' \n\0': 
     121                self.data[self.index+len(self.DIRECTIVE)] in ' \n\0': 
    122122            self.index += len(self.DIRECTIVE) 
    123123            return DirectiveToken('YAML', (1, 1), None, None) 
    124124 
    125125    def scan_alias(self): 
    126         if self.data[self.index] == u'*': 
     126        if self.data[self.index] == '*': 
    127127            TokenClass = AliasToken 
    128128        else: 
    129129            TokenClass = AnchorToken 
    130130        self.index += 1 
    131131        start = self.index 
    132         while self.data[self.index] not in u', \n\0': 
     132        while self.data[self.index] not in ', \n\0': 
    133133            self.index += 1 
    134134        value = self.data[start:self.index] 
    135135        return TokenClass(value, None, None) 
    … … class CanonicalScanner: 
    137137    def scan_tag(self): 
    138138        self.index += 1 
    139139        start = self.index 
    140         while self.data[self.index] not in u' \n\0': 
     140        while self.data[self.index] not in ' \n\0': 
    141141            self.index += 1 
    142142        value = self.data[start:self.index] 
    143         if value[0] == u'!': 
     143        if value[0] == '!': 
    144144            value = 'tag:yaml.org,2002:'+value[1:] 
    145         elif value[0] == u'<' and value[-1] == u'>': 
     145        elif value[0] == '<' and value[-1] == '>': 
    146146            value = value[1:-1] 
    147147        else: 
    148             value = u'!'+value 
     148            value = '!'+value 
    149149        return TagToken(value, None, None) 
    150150 
    151151    QUOTE_CODES = { 
    … … class CanonicalScanner: 
    155155    } 
    156156 
    157157    QUOTE_REPLACES = { 
    158         u'\\': u'\\', 
    159         u'\"': u'\"', 
    160         u' ': u' ', 
    161         u'a': u'\x07', 
    162         u'b': u'\x08', 
    163         u'e': u'\x1B', 
    164         u'f': u'\x0C', 
    165         u'n': u'\x0A', 
    166         u'r': u'\x0D', 
    167         u't': u'\x09', 
    168         u'v': u'\x0B', 
    169         u'N': u'\u0085', 
    170         u'L': u'\u2028', 
    171         u'P': u'\u2029', 
    172         u'_': u'_', 
    173         u'0': u'\x00', 
     158        '\\': '\\', 
     159        '\"': '\"', 
     160        ' ': ' ', 
     161        'a': '\x07', 
     162        'b': '\x08', 
     163        'e': '\x1B', 
     164        'f': '\x0C', 
     165        'n': '\x0A', 
     166        'r': '\x0D', 
     167        't': '\x09', 
     168        'v': '\x0B', 
     169        'N': '\u0085', 
     170        'L': '\u2028', 
     171        'P': '\u2029', 
     172        '_': '_', 
     173        '0': '\x00', 
    174174 
    175175    } 
    176176 
    … … class CanonicalScanner: 
    179179        chunks = [] 
    180180        start = self.index 
    181181        ignore_spaces = False 
    182         while self.data[self.index] != u'"': 
    183             if self.data[self.index] == u'\\': 
     182        while self.data[self.index] != '"': 
     183            if self.data[self.index] == '\\': 
    184184                ignore_spaces = False 
    185185                chunks.append(self.data[start:self.index]) 
    186186                self.index += 1 
    187187                ch = self.data[self.index] 
    188188                self.index += 1 
    189                 if ch == u'\n': 
     189                if ch == '\n': 
    190190                    ignore_spaces = True 
    191191                elif ch in self.QUOTE_CODES: 
    192192                    length = self.QUOTE_CODES[ch] 
    193193                    code = int(self.data[self.index:self.index+length], 16) 
    194                     chunks.append(unichr(code)) 
     194                    chunks.append(chr(code)) 
    195195                    self.index += length 
    196196                else: 
    197197                    chunks.append(self.QUOTE_REPLACES[ch]) 
    198198                start = self.index 
    199             elif self.data[self.index] == u'\n': 
     199            elif self.data[self.index] == '\n': 
    200200                chunks.append(self.data[start:self.index]) 
    201                 chunks.append(u' ') 
     201                chunks.append(' ') 
    202202                self.index += 1 
    203203                start = self.index 
    204204                ignore_spaces = True 
    205             elif ignore_spaces and self.data[self.index] == u' ': 
     205            elif ignore_spaces and self.data[self.index] == ' ': 
    206206                self.index += 1 
    207207                start = self.index 
    208208            else: 
    … … class CanonicalScanner: 
    210210                self.index += 1 
    211211        chunks.append(self.data[start:self.index]) 
    212212        self.index += 1 
    213         return ScalarToken(u''.join(chunks), False, None, None) 
     213        return ScalarToken(''.join(chunks), False, None, None) 
    214214 
    215215    def find_token(self): 
    216216        found = False 
    217217        while not found: 
    218             while self.data[self.index] in u' \t': 
     218            while self.data[self.index] in ' \t': 
    219219                self.index += 1 
    220             if self.data[self.index] == u'#': 
    221                 while self.data[self.index] != u'\n': 
     220            if self.data[self.index] == '#': 
     221                while self.data[self.index] != '\n': 
    222222                    self.index += 1 
    223             if self.data[self.index] == u'\n': 
     223            if self.data[self.index] == '\n': 
    224224                self.index += 1 
    225225            else: 
    226226                found = True 

  • tests/test_canonical.py 

    diff --git tests/test_canonical.py tests/test_canonical.py
index 4416902..73804bc 100644
    import test_appliance 
    44class TestCanonicalAppliance(test_appliance.TestAppliance): 
    55 
    66    def _testCanonicalScanner(self, test_name, canonical_filename): 
    7         data = file(canonical_filename, 'rb').read() 
     7        data = open(canonical_filename, 'rb').read() 
    88        tokens = list(test_appliance.canonical_scan(data)) 
    99        #for token in tokens: 
    10         #    print token 
     10        #    print(token) 
    1111 
    1212    def _testCanonicalParser(self, test_name, canonical_filename): 
    13         data = file(canonical_filename, 'rb').read() 
     13        data = open(canonical_filename, 'rb').read() 
    1414        event = list(test_appliance.canonical_parse(data)) 
    1515        #for event in events: 
    16         #    print event 
     16        #    print(event) 
    1717 
    1818TestCanonicalAppliance.add_tests('testCanonicalScanner', '.canonical') 
    1919TestCanonicalAppliance.add_tests('testCanonicalParser', '.canonical') 

  • tests/test_constructor.py 

    diff --git tests/test_constructor.py tests/test_constructor.py
index 04f54ef..3d72e5f 100644
     
    22import test_appliance 
    33 
    44import datetime 
    5 try: 
    6     set 
    7 except NameError: 
    8     from sets import Set as set 
    95 
    106from yaml import * 
    117 
    … … class YAMLObject2(YAMLObject): 
    111107        else: 
    112108            return False 
    113109 
    114 class AnObject(object): 
     110class AnObject: 
    115111 
    116112    def __new__(cls, foo=None, bar=None, baz=None): 
    117113        self = object.__new__(cls) 
    … … class AnObject(object): 
    128124        return type(self) is type(other) and    \ 
    129125                (self.foo, self.bar, self.baz) == (other.foo, other.bar, other.baz) 
    130126 
    131 class AnInstance: 
     127    def __repr__(self): 
     128        return '%s(foo=%r, bar=%r, baz=%r)' %    \ 
     129                (self.__class__.__name__, self.foo, self.bar, self.baz) 
    132130 
    133     def __init__(self, foo=None, bar=None, baz=None): 
    134         self.foo = foo 
    135         self.bar = bar 
    136         self.baz = baz 
    137  
    138     def __cmp__(self, other): 
    139         return cmp((type(self), self.foo, self.bar, self.baz), 
    140                 (type(other), other.foo, other.bar, other.baz)) 
    141  
    142     def __eq__(self, other): 
    143         return type(self) is type(other) and    \ 
    144                 (self.foo, self.bar, self.baz) == (other.foo, other.bar, other.baz) 
    145  
    146 class AState(AnInstance): 
     131class AState(AnObject): 
    147132 
    148133    def __getstate__(self): 
    149134        return { 
    … … class AState(AnInstance): 
    157142        self.bar = state['_bar'] 
    158143        self.baz = state['_baz'] 
    159144 
    160 class ACustomState(AnInstance): 
     145class ACustomState(AnObject): 
    161146 
    162147    def __getstate__(self): 
    163148        return (self.foo, self.bar, self.baz) 
    … … class ACustomState(AnInstance): 
    165150    def __setstate__(self, state): 
    166151        self.foo, self.bar, self.baz = state 
    167152 
    168 class InitArgs(AnInstance): 
    169  
    170     def __getinitargs__(self): 
    171         return (self.foo, self.bar, self.baz) 
    172  
    173     def __getstate__(self): 
    174         return {} 
    175  
    176 class InitArgsWithState(AnInstance): 
    177  
    178     def __getinitargs__(self): 
    179         return (self.foo, self.bar) 
    180  
    181     def __getstate__(self): 
    182         return self.baz 
    183  
    184     def __setstate__(self, state): 
    185         self.baz = state 
    186  
    187153class NewArgs(AnObject): 
    188154 
    189155    def __getnewargs__(self): 
    … … class FixedOffset(datetime.tzinfo): 
    255221 
    256222 
    257223def execute(code): 
    258     exec code 
     224    exec(code) 
    259225    return value 
    260226 
    261227class TestConstructorTypes(test_appliance.TestAppliance): 
    … … class TestConstructorTypes(test_appliance.TestAppliance): 
    264230        data1 = None 
    265231        data2 = None 
    266232        try: 
    267             data1 = list(load_all(file(data_filename, 'rb'), Loader=MyLoader)) 
     233            data1 = list(load_all(open(data_filename, 'rb'), Loader=MyLoader)) 
    268234            if len(data1) == 1: 
    269235                data1 = data1[0] 
    270             data2 = eval(file(code_filename, 'rb').read()) 
     236            data2 = eval(open(code_filename, 'rb').read()) 
    271237            self.failUnlessEqual(type(data1), type(data2)) 
    272238            try: 
    273239                self.failUnlessEqual(data1, data2) 
    … … class TestConstructorTypes(test_appliance.TestAppliance): 
    300266                else: 
    301267                    raise 
    302268        except: 
    303             print 
    304             print "DATA:" 
    305             print file(data_filename, 'rb').read() 
    306             print "CODE:" 
    307             print file(code_filename, 'rb').read() 
    308             print "NATIVES1:", data1 
    309             print "NATIVES2:", data2 
     269            print() 
     270            print("DATA:") 
     271            print(open(data_filename, 'rb').read()) 
     272            print("CODE:") 
     273            print(open(code_filename, 'rb').read()) 
     274            print("NATIVES1:", repr(data1)) 
     275            print("NATIVES2:", repr(data2)) 
    310276            raise 
    311277 
    312278TestConstructorTypes.add_tests('testTypes', '.data', '.code') 

  • tests/test_emitter.py 

    diff --git tests/test_emitter.py tests/test_emitter.py
index d45cd8f..bf93dba 100644
     
    11 
    2 import test_appliance, sys, StringIO 
     2import test_appliance, sys, io 
    33 
    44from yaml import * 
    55import yaml 
    … … class TestEmitter(test_appliance.TestAppliance): 
    1616        self._testEmitter(test_name, canonical_filename, True) 
    1717 
    1818    def _testEmitter(self, test_name, filename, canonical=None): 
    19         events = list(parse(file(filename, 'rb'))) 
     19        events = list(parse(open(filename, 'rb'))) 
    2020        #self._dump(filename, events, canonical) 
    21         stream = StringIO.StringIO() 
     21        stream = io.StringIO() 
    2222        emit(events, stream, canonical=canonical) 
    2323        data = stream.getvalue() 
    2424        new_events = list(parse(data)) 
    … … class TestEmitter(test_appliance.TestAppliance): 
    3535                self.failUnlessEqual(event.value, new_event.value) 
    3636 
    3737    def _dump(self, filename, events, canonical): 
    38         print "="*30 
    39         print "ORIGINAL DOCUMENT:" 
    40         print file(filename, 'rb').read() 
    41         print '-'*30 
    42         print "EMITTED DOCUMENT:" 
     38        print("="*30) 
     39        print("ORIGINAL DOCUMENT:") 
     40        print(open(filename, 'rb').read()) 
     41        print('-'*30) 
     42        print("EMITTED DOCUMENT:") 
    4343        emit(events, sys.stdout, canonical=canonical) 
    4444         
    4545TestEmitter.add_tests('testEmitterOnData', '.canonical', '.data') 
    … … EventsLoader.add_constructor(None, EventsLoader.construct_event) 
    7171class TestEmitterEvents(test_appliance.TestAppliance): 
    7272 
    7373    def _testEmitterEvents(self, test_name, events_filename): 
    74         events = list(load(file(events_filename, 'rb'), Loader=EventsLoader)) 
     74        events = list(load(open(events_filename, 'rb'), Loader=EventsLoader)) 
    7575        #self._dump(events_filename, events) 
    76         stream = StringIO.StringIO() 
     76        stream = io.StringIO() 
    7777        emit(events, stream) 
    7878        data = stream.getvalue() 
    7979        new_events = list(parse(data)) 
    … … class TestEmitterEvents(test_appliance.TestAppliance): 
    9090                self.failUnlessEqual(event.value, new_event.value) 
    9191 
    9292    def _dump(self, events_filename, events): 
    93         print "="*30 
    94         print "EVENTS:" 
    95         print file(events_filename, 'rb').read() 
    96         print '-'*30 
    97         print "OUTPUT:" 
     93        print("="*30) 
     94        print("EVENTS:") 
     95        print(open(events_filename, 'rb').read()) 
     96        print('-'*30) 
     97        print("OUTPUT:") 
    9898        emit(events, sys.stdout) 
    9999         
    100100TestEmitterEvents.add_tests('testEmitterEvents', '.events') 

  • tests/test_errors.py 

    diff --git tests/test_errors.py tests/test_errors.py
index 7d6e0d2..02df778 100644
     
    22import test_appliance 
    33import test_emitter 
    44 
    5 import StringIO 
     5import io 
    66 
    77from yaml import * 
    88 
    … … class TestErrors(test_appliance.TestAppliance): 
    2121        self.failUnlessRaises(YAMLError, lambda: self._load_single(invalid_filename)) 
    2222 
    2323    def _testEmitterErrors(self, test_name, invalid_filename): 
    24         events = list(load(file(invalid_filename, 'rb').read(), 
     24        events = list(load(open(invalid_filename, 'rb').read(), 
    2525            Loader=test_emitter.EventsLoader)) 
    2626        self.failUnlessRaises(YAMLError, lambda: self._emit(events)) 
    2727 
    2828    def _testDumperErrors(self, test_name, invalid_filename): 
    29         code = file(invalid_filename, 'rb').read() 
     29        code = open(invalid_filename, 'r').read() 
    3030        self.failUnlessRaises(YAMLError, lambda: self._dump(code)) 
    3131 
    3232    def _dump(self, code): 
    3333        try: 
    34             exec code 
    35         except YAMLError, exc: 
    36             #print '.'*70 
    37             #print "%s:" % exc.__class__.__name__, exc 
     34            exec(code) 
     35        except YAMLError as exc: 
     36            #print('.'*70) 
     37            #print("%s:" % exc.__class__.__name__, exc) 
    3838            raise 
    3939 
    4040    def _emit(self, events): 
    4141        try: 
    4242            emit(events) 
    43         except YAMLError, exc: 
    44             #print '.'*70 
    45             #print "%s:" % exc.__class__.__name__, exc 
     43        except YAMLError as exc: 
     44            #print('.'*70) 
     45            #print("%s:" % exc.__class__.__name__, exc) 
    4646            raise 
    4747 
    4848    def _load(self, filename): 
    4949        try: 
    50             return list(load_all(file(filename, 'rb'))) 
    51         except YAMLError, exc: 
     50            return list(load_all(open(filename, 'rb'))) 
     51        except YAMLError as exc: 
    5252        #except ScannerError, exc: 
    5353        #except ParserError, exc: 
    5454        #except ComposerError, exc: 
    5555        #except ConstructorError, exc: 
    56             #print '.'*70 
    57             #print "%s:" % exc.__class__.__name__, exc 
     56            #print('.'*70) 
     57            #print("%s:" % exc.__class__.__name__, exc) 
    5858            raise 
    5959 
    6060    def _load_string(self, filename): 
    6161        try: 
    62             return list(load_all(file(filename, 'rb').read())) 
    63         except YAMLError, exc: 
     62            return list(load_all(open(filename, 'rb').read())) 
     63        except YAMLError as exc: 
    6464        #except ScannerError, exc: 
    6565        #except ParserError, exc: 
    6666        #except ComposerError, exc: 
    6767        #except ConstructorError, exc: 
    68             #print '.'*70 
    69             #print "%s:" % filename 
    70             #print "%s:" % exc.__class__.__name__, exc 
     68            #print('.'*70) 
     69            #print("%s:" % filename) 
     70            #print("%s:" % exc.__class__.__name__, exc) 
    7171            raise 
    7272 
    7373    def _load_single(self, filename): 
    7474        try: 
    75             return load(file(filename, 'rb').read()) 
    76         except YAMLError, exc: 
     75            return load(open(filename, 'rb').read()) 
     76        except YAMLError as exc: 
    7777        #except ScannerError, exc: 
    7878        #except ParserError, exc: 
    7979        #except ComposerError, exc: 
    8080        #except ConstructorError, exc: 
    81             #print '.'*70 
    82             #print "%s:" % filename 
    83             #print "%s:" % exc.__class__.__name__, exc 
     81            #print('.'*70) 
     82            #print("%s:" % filename) 
     83            #print("%s:" % exc.__class__.__name__, exc) 
    8484            raise 
    8585 
    8686TestErrors.add_tests('testLoaderErrors', '.loader-error') 

  • tests/test_mark.py 

    diff --git tests/test_mark.py tests/test_mark.py
index 4fa665e..12f73fa 100644
    from yaml.reader import Mark 
    66class TestMark(test_appliance.TestAppliance): 
    77 
    88    def _testMarks(self, test_name, marks_filename): 
    9         inputs = file(marks_filename, 'rb').read().split('---\n')[1:] 
     9        inputs = open(marks_filename, 'r').read().split('---\n')[1:] 
    1010        for input in inputs: 
    1111            index = 0 
    1212            line = 0 
    … … class TestMark(test_appliance.TestAppliance): 
    1818                else: 
    1919                    column += 1 
    2020                index += 1 
    21             mark = Mark(test_name, index, line, column, unicode(input), index) 
     21            mark = Mark(test_name, index, line, column, input, index) 
    2222            snippet = mark.get_snippet(indent=2, max_length=79) 
    23             #print "INPUT:" 
    24             #print input 
    25             #print "SNIPPET:" 
    26             #print snippet 
     23            #print("INPUT:") 
     24            #print(input) 
     25            #print("SNIPPET:") 
     26            #print(snippet) 
    2727            self.failUnless(isinstance(snippet, str)) 
    2828            self.failUnlessEqual(snippet.count('\n'), 1) 
    2929            data, pointer = snippet.split('\n') 

  • tests/test_reader.py 

    diff --git tests/test_reader.py tests/test_reader.py
index 1bfae1a..bafae4e 100644
    class TestReaderErrors(test_appliance.TestAppliance): 
    99    def _testReaderUnicodeErrors(self, test_name, stream_filename): 
    1010        for encoding in ['utf-8', 'utf-16-le', 'utf-16-be']: 
    1111            try: 
    12                 data = unicode(file(stream_filename, 'rb').read(), encoding) 
     12                data = open(stream_filename, 'rb').read().decode(encoding) 
    1313                break 
    1414            except: 
    1515                pass 
    … … class TestReaderErrors(test_appliance.TestAppliance): 
    2222        self.failUnlessRaises(ReaderError, 
    2323                lambda: self._load(codecs.open(stream_filename, encoding=encoding))) 
    2424 
    25     def _testReaderStringErrors(self, test_name, stream_filename): 
    26         data = file(stream_filename, 'rb').read() 
     25    def _testReaderBytesErrors(self, test_name, stream_filename): 
     26        data = open(stream_filename, 'rb').read() 
    2727        #self._load(data) 
    2828        self.failUnlessRaises(ReaderError, lambda: self._load(data)) 
    2929 
    3030    def _testReaderFileErrors(self, test_name, stream_filename): 
    31         data = file(stream_filename, 'rb') 
     31        data = open(stream_filename, 'rb').read() 
    3232        #self._load(data) 
    3333        self.failUnlessRaises(ReaderError, lambda: self._load(data)) 
    3434 
    3535    def _load(self, data): 
    3636        stream = Reader(data) 
    37         while stream.peek() != u'\0': 
     37        while stream.peek() != '\0': 
    3838            stream.forward() 
    3939 
    4040TestReaderErrors.add_tests('testReaderUnicodeErrors', '.stream-error') 
    41 TestReaderErrors.add_tests('testReaderStringErrors', '.stream-error') 
     41TestReaderErrors.add_tests('testReaderBytesErrors', '.stream-error') 
    4242TestReaderErrors.add_tests('testReaderFileErrors', '.stream-error') 
    4343 
    4444 

  • tests/test_recursive.py 

    diff --git tests/test_recursive.py tests/test_recursive.py
index 3c09264..a9cac1f 100644
    class AnInstanceWithState(AnInstance): 
    2727class TestRecursive(test_appliance.TestAppliance): 
    2828 
    2929    def _testRecursive(self, test_name, recursive_filename): 
    30         exec file(recursive_filename, 'r').read() 
    31         value1 = value 
     30        exec(open(recursive_filename, 'r').read()) 
     31        value1 = locals()['value'] 
    3232        output1 = None 
    3333        value2 = None 
    3434        output2 = None 
    3535        try: 
    3636            output1 = dump(value1) 
    37             #print "OUTPUT %s:" % test_name 
    38             #print output1 
     37            #print("OUTPUT %s:" % test_name) 
     38            #print(output1) 
    3939            value2 = load(output1) 
    4040            output2 = dump(value2) 
    4141            self.failUnlessEqual(output1, output2) 
    4242        except: 
    43             print "VALUE1:", value1 
    44             print "VALUE2:", value2 
    45             print "OUTPUT1:" 
    46             print output1 
    47             print "OUTPUT2:" 
    48             print output2 
     43            print("VALUE1:", value1) 
     44            print("VALUE2:", value2) 
     45            print("OUTPUT1:") 
     46            print(output1) 
     47            print("OUTPUT2:") 
     48            print(output2) 
    4949            raise 
    5050 
    5151TestRecursive.add_tests('testRecursive', '.recursive') 

  • tests/test_representer.py 

    diff --git tests/test_representer.py tests/test_representer.py
index 6746146..665def6 100644
    class TestRepresenterTypes(test_appliance.TestAppliance): 
    1010        return self._testTypes(test_name, data_filename, code_filename, allow_unicode=True) 
    1111 
    1212    def _testTypes(self, test_name, data_filename, code_filename, allow_unicode=False): 
    13         data1 = eval(file(code_filename, 'rb').read()) 
     13        data1 = eval(open(code_filename, 'rb').read()) 
    1414        data2 = None 
    1515        output = None 
    1616        try: 
    … … class TestRepresenterTypes(test_appliance.TestAppliance): 
    4848                else: 
    4949                    raise 
    5050        except: 
    51             print 
    52             print "OUTPUT:" 
    53             print output 
    54             print "NATIVES1:", data1 
    55             print "NATIVES2:", data2 
     51            print() 
     52            print("OUTPUT:") 
     53            print(output) 
     54            print("NATIVES1:", repr(data1)) 
     55            print("NATIVES2:", repr(data2)) 
    5656            raise 
    5757 
    5858TestRepresenterTypes.add_tests('testTypes', '.data', '.code') 

  • tests/test_resolver.py 

    diff --git tests/test_resolver.py tests/test_resolver.py
index a1845d8..b0693f2 100644
    class MyLoader(Loader): 
    99class MyDumper(Dumper): 
    1010    pass 
    1111 
    12 add_path_resolver(u'!root', [], 
     12add_path_resolver('!root', [], 
    1313        Loader=MyLoader, Dumper=MyDumper) 
    1414 
    15 add_path_resolver(u'!root/scalar', [], str, 
     15add_path_resolver('!root/scalar', [], str, 
    1616        Loader=MyLoader, Dumper=MyDumper) 
    1717 
    18 add_path_resolver(u'!root/key11/key12/*', ['key11', 'key12'], 
     18add_path_resolver('!root/key11/key12/*', ['key11', 'key12'], 
    1919        Loader=MyLoader, Dumper=MyDumper) 
    2020 
    21 add_path_resolver(u'!root/key21/1/*', ['key21', 1], 
     21add_path_resolver('!root/key21/1/*', ['key21', 1], 
    2222        Loader=MyLoader, Dumper=MyDumper) 
    2323 
    24 add_path_resolver(u'!root/key31/*/*/key14/map', ['key31', None, None, 'key14'], dict, 
     24add_path_resolver('!root/key31/*/*/key14/map', ['key31', None, None, 'key14'], dict, 
    2525        Loader=MyLoader, Dumper=MyDumper) 
    2626 
    2727class TestResolver(test_appliance.TestAppliance): 
    … … class TestResolver(test_appliance.TestAppliance): 
    3030        node = None 
    3131        correct_tag = None 
    3232        try: 
    33             correct_tag = file(detect_filename, 'rb').read().strip() 
    34             node = compose(file(data_filename, 'rb')) 
     33            correct_tag = open(detect_filename, 'r').read().strip() 
     34            node = compose(open(data_filename, 'rb')) 
    3535            self.failUnless(isinstance(node, SequenceNode)) 
    3636            for scalar in node.value: 
    3737                self.failUnless(isinstance(scalar, ScalarNode)) 
    3838                self.failUnlessEqual(scalar.tag, correct_tag) 
    3939        except: 
    40             print 
    41             print "DATA:" 
    42             print file(data_filename, 'rb').read() 
    43             print "CORRECT_TAG:" 
    44             print file(detect_filename, 'rb').read() 
    45             print "ROOT NODE:", node 
    46             print "SCALAR NODES:", node.value 
     40            print() 
     41            print("DATA:") 
     42            print(open(data_filename, 'rb').read()) 
     43            print("CORRECT_TAG:") 
     44            print(open(detect_filename, 'rb').read()) 
     45            print("ROOT NODE:", node) 
     46            print("SCALAR NODES:", node.value) 
    4747            raise 
    4848 
    4949    def _testPathResolverLoader(self, test_name, data_filename, path_filename): 
    50         #print serialize_all(compose_all(file(data_filename, 'rb').read(), Loader=MyLoader)) 
    51         nodes1 = compose_all(file(data_filename, 'rb').read(), Loader=MyLoader) 
    52         nodes2 = compose_all(file(path_filename, 'rb').read()) 
     50        #print(serialize_all(compose_all(open(data_filename, 'rb').read(), Loader=MyLoader))) 
     51        nodes1 = compose_all(open(data_filename, 'rb').read(), Loader=MyLoader) 
     52        nodes2 = compose_all(open(path_filename, 'rb').read()) 
    5353        for node1, node2 in zip(nodes1, nodes2): 
    5454            self.failUnlessEqual(self._convert(node1), self._convert(node2)) 
    5555 
    5656    def _testPathResolverDumper(self, test_name, data_filename, path_filename): 
    5757        for filename in [data_filename, path_filename]: 
    58             output = serialize_all(compose_all(file(filename, 'rb').read()), Dumper=MyDumper) 
    59             #print output 
     58            output = serialize_all(compose_all(open(filename, 'rb').read()), Dumper=MyDumper) 
     59            #print(output) 
    6060            nodes1 = compose_all(output) 
    61             nodes2 = compose_all(file(data_filename, 'rb').read()) 
     61            nodes2 = compose_all(open(data_filename, 'rb').read()) 
    6262            for node1, node2 in zip(nodes1, nodes2): 
    6363                self.failUnlessEqual(self._convert(node1), self._convert(node2)) 
    6464 

  • tests/test_structure.py 

    diff --git tests/test_structure.py tests/test_structure.py
index 0aef982..1919b47 100644
    class TestStructure(test_appliance.TestAppliance): 
    77 
    88    def _testStructure(self, test_name, data_filename, structure_filename): 
    99        node1 = None 
    10         node2 = eval(file(structure_filename, 'rb').read()) 
     10        node2 = eval(open(structure_filename, 'rb').read()) 
    1111        try: 
    12             loader = Loader(file(data_filename, 'rb')) 
     12            loader = Loader(open(data_filename, 'rb')) 
    1313            node1 = [] 
    1414            while not loader.check_event(StreamEndEvent): 
    1515                if not loader.check_event(StreamStartEvent, DocumentStartEvent, DocumentEndEvent): 
    … … class TestStructure(test_appliance.TestAppliance): 
    2121                node1 = node1[0] 
    2222            self.failUnlessEqual(node1, node2) 
    2323        except: 
    24             print 
    25             print "DATA:" 
    26             print file(data_filename, 'rb').read() 
    27             print "NODE1:", node1 
    28             print "NODE2:", node2 
     24            print() 
     25            print("DATA:") 
     26            print(open(data_filename, 'rb').read()) 
     27            print("NODE1:", node1) 
     28            print("NODE2:", node2) 
    2929            raise 
    3030 
    3131    def _convert(self, loader): 
    … … class TestParser(test_appliance.TestAppliance): 
    6666        events1 = None 
    6767        events2 = None 
    6868        try: 
    69             events1 = list(parse(file(data_filename, 'rb'))) 
    70             events2 = list(test_appliance.canonical_parse(file(canonical_filename, 'rb'))) 
     69            events1 = list(parse(open(data_filename, 'rb'))) 
     70            events2 = list(test_appliance.canonical_parse(open(canonical_filename, 'rb'))) 
    7171            self._compare(events1, events2) 
    7272        except: 
    73             print 
    74             print "DATA1:" 
    75             print file(data_filename, 'rb').read() 
    76             print "DATA2:" 
    77             print file(canonical_filename, 'rb').read() 
    78             print "EVENTS1:", events1 
    79             print "EVENTS2:", events2 
     73            print() 
     74            print("DATA1:") 
     75            print(open(data_filename, 'rb').read()) 
     76            print("DATA2:") 
     77            print(open(canonical_filename, 'rb').read()) 
     78            print("EVENTS1:", events1) 
     79            print("EVENTS2:", events2) 
    8080            raise 
    8181 
    8282    def _compare(self, events1, events2): 
    … … class TestResolver(test_appliance.TestAppliance): 
    103103        nodes1 = None 
    104104        nodes2 = None 
    105105        try: 
    106             nodes1 = list(compose_all(file(data_filename, 'rb'))) 
    107             nodes2 = list(test_appliance.canonical_compose_all(file(canonical_filename, 'rb'))) 
     106            nodes1 = list(compose_all(open(data_filename, 'rb'))) 
     107            nodes2 = list(test_appliance.canonical_compose_all(open(canonical_filename, 'rb'))) 
    108108            self.failUnlessEqual(len(nodes1), len(nodes2)) 
    109109            for node1, node2 in zip(nodes1, nodes2): 
    110110                self._compare(node1, node2) 
    111111        except: 
    112             print 
    113             print "DATA1:" 
    114             print file(data_filename, 'rb').read() 
    115             print "DATA2:" 
    116             print file(canonical_filename, 'rb').read() 
    117             print "NODES1:", nodes1 
    118             print "NODES2:", nodes2 
     112            print() 
     113            print("DATA1:") 
     114            print(open(data_filename, 'rb').read()) 
     115            print("DATA2:") 
     116            print(open(canonical_filename, 'rb').read()) 
     117            print("NODES1:", nodes1) 
     118            print("NODES2:", nodes2) 
    119119            raise 
    120120 
    121121    def _compare(self, node1, node2): 
    … … class TestResolver(test_appliance.TestAppliance): 
    129129                self._compare(item1, item2) 
    130130        elif isinstance(node1, MappingNode): 
    131131            self.failUnlessEqual(len(node1.value), len(node2.value)) 
    132             items1 = node1.value.items() 
    133             items1.sort(lambda (k1,v1), (k2,v2): cmp((k1.tag,k1.value,v1.tag,v1.value), 
    134                                                     (k2.tag,k2.value,v2.tag,v2.value))) 
    135             items2 = node2.value.items() 
    136             items2.sort(lambda (k1,v1), (k2,v2): cmp((k1.tag,k1.value,v1.tag,v1.value), 
    137                                                     (k2.tag,k2.value,v2.tag,v2.value))) 
     132            items1 = list(node1.value.items()) 
     133            items1.sort(key=lambda kv: (kv[0].tag, kv[0].value, kv[1].tag, kv[1].value)) 
     134            items2 = list(node2.value.items()) 
     135            items2.sort(key=lambda kv: (kv[0].tag, kv[0].value, kv[1].tag, kv[1].value)) 
    138136            for (key1, value1), (key2, value2) in zip(items1, items2): 
    139137                self._compare(key1, key2) 
    140138                self._compare(value1, value2) 
    … … class MyLoader(Loader): 
    147145 
    148146    def construct_mapping(self, node): 
    149147        pairs = self.construct_pairs(node) 
    150         pairs.sort() 
    151148        return pairs 
    152149 
    153150    def construct_undefined(self, node): 
    154151        return self.construct_scalar(node) 
    155152 
    156 MyLoader.add_constructor(u'tag:yaml.org,2002:map', MyLoader.construct_mapping) 
     153MyLoader.add_constructor('tag:yaml.org,2002:map', MyLoader.construct_mapping) 
    157154MyLoader.add_constructor(None, MyLoader.construct_undefined) 
    158155 
    159156class MyCanonicalLoader(test_appliance.CanonicalLoader): 
    … … class MyCanonicalLoader(test_appliance.CanonicalLoader): 
    163160 
    164161    def construct_mapping(self, node): 
    165162        pairs = self.construct_pairs(node) 
    166         pairs.sort() 
    167163        return pairs 
    168164 
    169165    def construct_undefined(self, node): 
    170166        return self.construct_scalar(node) 
    171167 
    172 MyCanonicalLoader.add_constructor(u'tag:yaml.org,2002:map', MyCanonicalLoader.construct_mapping) 
     168MyCanonicalLoader.add_constructor('tag:yaml.org,2002:map', MyCanonicalLoader.construct_mapping) 
    173169MyCanonicalLoader.add_constructor(None, MyCanonicalLoader.construct_undefined) 
    174170 
    175171class TestConstructor(test_appliance.TestAppliance): 
    … … class TestConstructor(test_appliance.TestAppliance): 
    178174        data1 = None 
    179175        data2 = None 
    180176        try: 
    181             data1 = list(load_all(file(data_filename, 'rb'), Loader=MyLoader)) 
    182             data2 = list(load_all(file(canonical_filename, 'rb'), Loader=MyCanonicalLoader)) 
     177            data1 = list(load_all(open(data_filename, 'rb'), Loader=MyLoader)) 
     178            data2 = list(load_all(open(canonical_filename, 'rb'), Loader=MyCanonicalLoader)) 
    183179            self.failUnlessEqual(data1, data2) 
    184180        except: 
    185             print 
    186             print "DATA1:" 
    187             print file(data_filename, 'rb').read() 
    188             print "DATA2:" 
    189             print file(canonical_filename, 'rb').read() 
    190             print "NATIVES1:", data1 
    191             print "NATIVES2:", data2 
     181            print() 
     182            print("DATA1:") 
     183            print(open(data_filename, 'rb').read()) 
     184            print("DATA2:") 
     185            print(open(canonical_filename, 'rb').read()) 
     186            print("NATIVES1:", data1) 
     187            print("NATIVES2:", data2) 
    192188            raise 
    193189 
    194190TestConstructor.add_tests('testConstructor', '.data', '.canonical') 
    … … class TestParserOnCanonical(test_appliance.TestAppliance): 
    199195        events1 = None 
    200196        events2 = None 
    201197        try: 
    202             events1 = list(parse(file(canonical_filename, 'rb'))) 
    203             events2 = list(test_appliance.canonical_parse(file(canonical_filename, 'rb'))) 
     198            events1 = list(parse(open(canonical_filename, 'rb'))) 
     199            events2 = list(test_appliance.canonical_parse(open(canonical_filename, 'rb'))) 
    204200            self._compare(events1, events2) 
    205201        except: 
    206             print 
    207             print "DATA:" 
    208             print file(canonical_filename, 'rb').read() 
    209             print "EVENTS1:", events1 
    210             print "EVENTS2:", events2 
     202            print() 
     203            print("DATA:") 
     204            print(open(canonical_filename, 'rb').read()) 
     205            print("EVENTS1:", events1) 
     206            print("EVENTS2:", events2) 
    211207            raise 
    212208 
    213209    def _compare(self, events1, events2): 

  • tests/test_syck.py 

    diff --git tests/test_syck.py tests/test_syck.py
index dd63056..95979c0 100644
    class TestSyck(test_appliance.TestAppliance): 
    77        try: 
    88            syck.parse(file(data_filename, 'rb')) 
    99        except: 
    10             print 
    11             print "DATA:" 
    12             print file(data_filename, 'rb').read() 
     10            print() 
     11            print("DATA:") 
     12            print(file(data_filename, 'rb').read()) 
    1313            raise 
    1414 
    1515    def _testSyckOnCanonicalTests(self, test_name, data_filename, canonical_filename): 
    1616        try: 
    1717            syck.parse(file(data_filename, 'rb')) 
    1818        except: 
    19             print 
    20             print "DATA:" 
    21             print file(data_filename, 'rb').read() 
     19            print() 
     20            print("DATA:") 
     21            print(file(data_filename, 'rb').read()) 
    2222            raise 
    2323 
    2424try: 

  • tests/test_tokens.py 

    diff --git tests/test_tokens.py tests/test_tokens.py
index 73d07b3..9af29c5 100644
    class TestTokens(test_appliance.TestAppliance): 
    4747 
    4848    def _testTokens(self, test_name, data_filename, tokens_filename): 
    4949        tokens1 = None 
    50         tokens2 = file(tokens_filename, 'rb').read().split() 
     50        tokens2 = open(tokens_filename, 'r').read().split() 
    5151        try: 
    5252            tokens1 = [] 
    53             for token in scan(file(data_filename, 'rb')): 
     53            for token in scan(open(data_filename, 'rb')): 
    5454                if not isinstance(token, (StreamStartToken, StreamEndToken)): 
    5555                    tokens1.append(token) 
    5656            tokens1 = [self.replaces[t.__class__] for t in tokens1] 
    5757            self.failUnlessEqual(tokens1, tokens2) 
    5858        except: 
    59             print 
    60             print "DATA:" 
    61             print file(data_filename, 'rb').read() 
    62             print "TOKENS1:", tokens1 
    63             print "TOKENS2:", tokens2 
     59            print() 
     60            print("DATA:") 
     61            print(open(data_filename, 'rb').read()) 
     62            print("TOKENS1:", tokens1) 
     63            print("TOKENS2:", tokens2) 
    6464            raise 
    6565 
    6666TestTokens.add_tests('testTokens', '.data', '.tokens') 
    … … class TestScanner(test_appliance.TestAppliance): 
    7272            tokens = None 
    7373            try: 
    7474                tokens = [] 
    75                 for token in scan(file(filename, 'rb')): 
     75                for token in scan(open(filename, 'rb')): 
    7676                    if not isinstance(token, (StreamStartToken, StreamEndToken)): 
    7777                        tokens.append(token.__class__.__name__) 
    7878            except: 
    79                 print 
    80                 print "DATA:" 
    81                 print file(data_filename, 'rb').read() 
    82                 print "TOKENS:", tokens 
     79                print() 
     80                print("DATA:") 
     81                print(open(data_filename, 'rb').read()) 
     82                print("TOKENS:", tokens) 
    8383                raise 
    8484 
    8585TestScanner.add_tests('testScanner', '.data', '.canonical') 

  • tests/test_yaml_ext.py 

    diff --git tests/test_yaml_ext.py tests/test_yaml_ext.py
index c5dd036..c987261 100644
    class TestCLoader(test_appliance.TestAppliance): 
    3535                if hasattr(token, 'value'): 
    3636                    self.failUnlessEqual(token.value, ext_token.value) 
    3737        except: 
    38             print 
    39             print "DATA:" 
    40             print file(data_filename, 'rb').read() 
    41             print "TOKENS:", tokens 
    42             print "EXT_TOKENS:", ext_tokens 
     38            print() 
     39            print("DATA:") 
     40            print(file(data_filename, 'rb').read()) 
     41            print("TOKENS:", tokens) 
     42            print("EXT_TOKENS:", ext_tokens) 
    4343            raise 
    4444 
    4545    def _testCParser(self, test_name, data_filename, canonical_filename, Loader=yaml.Loader): 
    … … class TestCLoader(test_appliance.TestAppliance): 
    4949        try: 
    5050            for event in yaml.parse(data, Loader=yaml.CLoader): 
    5151                ext_events.append(event) 
    52                 #print "EVENT:", event 
     52                #print("EVENT:", event) 
    5353            self.failUnlessEqual(len(events), len(ext_events)) 
    5454            for event, ext_event in zip(events, ext_events): 
    5555                self.failUnlessEqual(event.__class__, ext_event.__class__) 
    … … class TestCLoader(test_appliance.TestAppliance): 
    6868                if hasattr(event, 'tags'): 
    6969                    self.failUnlessEqual(event.tags, ext_event.tags) 
    7070        except: 
    71             print 
    72             print "DATA:" 
    73             print file(data_filename, 'rb').read() 
    74             print "EVENTS:", events 
    75             print "EXT_EVENTS:", ext_events 
     71            print() 
     72            print("DATA:") 
     73            print(file(data_filename, 'rb').read()) 
     74            print("EVENTS:", events) 
     75            print("EXT_EVENTS:", ext_events) 
    7676            raise 
    7777 
    7878TestCLoader.add_tests('testCScanner', '.data', '.canonical') 
    … … class TestCEmitter(test_appliance.TestAppliance): 
    108108                if hasattr(event, 'tags'): 
    109109                    self.failUnlessEqual(event.tags, ext_event.tags) 
    110110        except: 
    111             print 
    112             print "DATA1:" 
    113             print data1 
    114             print "DATA2:" 
    115             print data2 
    116             print "EVENTS:", events 
    117             print "EXT_EVENTS:", ext_events 
     111            print() 
     112            print("DATA1:") 
     113            print(data1) 
     114            print("DATA2:") 
     115            print(data2) 
     116            print("EVENTS:", events) 
     117            print("EXT_EVENTS:", ext_events) 
    118118            raise 
    119119 
    120120TestCEmitter.add_tests('testCEmitter', '.data', '.canonical')