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

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

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

Legend:

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

    r248 r328  
    33    'RepresenterError'] 
    44 
    5 from error import * 
    6 from nodes import * 
    7  
    8 import datetime 
    9  
    10 try: 
    11     set 
    12 except NameError: 
    13     from sets import Set as set 
    14  
    15 import sys, copy_reg, types 
     5from .error import * 
     6from .nodes import * 
     7 
     8import datetime, sys, copyreg, types, base64 
    169 
    1710class RepresenterError(YAMLError): 
    1811    pass 
    1912 
    20 class BaseRepresenter(object): 
     13class BaseRepresenter: 
    2114 
    2215    yaml_representers = {} 
     
    3629        self.object_keeper = [] 
    3730        self.alias_key = None 
    38  
    39     def get_classobj_bases(self, cls): 
    40         bases = [cls] 
    41         for base in cls.__bases__: 
    42             bases.extend(self.get_classobj_bases(base)) 
    43         return bases 
    4431 
    4532    def represent_data(self, data): 
     
    5744            self.object_keeper.append(data) 
    5845        data_types = type(data).__mro__ 
    59         if type(data) is types.InstanceType: 
    60             data_types = self.get_classobj_bases(data.__class__)+list(data_types) 
    6146        if data_types[0] in self.yaml_representers: 
    6247            node = self.yaml_representers[data_types[0]](self, data) 
     
    7257                    node = self.yaml_representers[None](self, data) 
    7358                else: 
    74                     node = ScalarNode(None, unicode(data)) 
     59                    node = ScalarNode(None, str(data)) 
    7560        #if alias_key is not None: 
    7661        #    self.represented_objects[alias_key] = node 
    7762        return node 
    7863 
     64    @classmethod 
    7965    def add_representer(cls, data_type, representer): 
    8066        if not 'yaml_representers' in cls.__dict__: 
    8167            cls.yaml_representers = cls.yaml_representers.copy() 
    8268        cls.yaml_representers[data_type] = representer 
    83     add_representer = classmethod(add_representer) 
    84  
     69 
     70    @classmethod 
    8571    def add_multi_representer(cls, data_type, representer): 
    8672        if not 'yaml_multi_representers' in cls.__dict__: 
    8773            cls.yaml_multi_representers = cls.yaml_multi_representers.copy() 
    8874        cls.yaml_multi_representers[data_type] = representer 
    89     add_multi_representer = classmethod(add_multi_representer) 
    9075 
    9176    def represent_scalar(self, tag, value, style=None): 
     
    122107        best_style = True 
    123108        if hasattr(mapping, 'items'): 
    124             mapping = mapping.items() 
    125             mapping.sort() 
     109            mapping = list(mapping.items()) 
     110            try: 
     111                mapping = sorted(mapping) 
     112            except TypeError: 
     113                pass 
    126114        for item_key, item_value in mapping: 
    127115            node_key = self.represent_data(item_key) 
     
    147135        if data in [None, ()]: 
    148136            return True 
    149         if isinstance(data, (str, unicode, bool, int, float)): 
     137        if isinstance(data, (str, bytes, bool, int, float)): 
    150138            return True 
    151139 
    152140    def represent_none(self, data): 
    153         return self.represent_scalar(u'tag:yaml.org,2002:null', 
    154                 u'null') 
     141        return self.represent_scalar('tag:yaml.org,2002:null', 'null') 
    155142 
    156143    def represent_str(self, data): 
    157         tag = None 
    158         style = None 
    159         try: 
    160             data = unicode(data, 'ascii') 
    161             tag = u'tag:yaml.org,2002:str' 
    162         except UnicodeDecodeError: 
    163             try: 
    164                 data = unicode(data, 'utf-8') 
    165                 tag = u'tag:yaml.org,2002:str' 
    166             except UnicodeDecodeError: 
    167                 data = data.encode('base64') 
    168                 tag = u'tag:yaml.org,2002:binary' 
    169                 style = '|' 
    170         return self.represent_scalar(tag, data, style=style) 
    171  
    172     def represent_unicode(self, data): 
    173         return self.represent_scalar(u'tag:yaml.org,2002:str', data) 
     144        return self.represent_scalar('tag:yaml.org,2002:str', data) 
     145 
     146    def represent_binary(self, data): 
     147        data = base64.encodestring(data).decode('ascii') 
     148        return self.represent_scalar('tag:yaml.org,2002:binary', data, style='|') 
    174149 
    175150    def represent_bool(self, data): 
    176151        if data: 
    177             value = u'true' 
    178         else: 
    179             value = u'false' 
    180         return self.represent_scalar(u'tag:yaml.org,2002:bool', value) 
     152            value = 'true' 
     153        else: 
     154            value = 'false' 
     155        return self.represent_scalar('tag:yaml.org,2002:bool', value) 
    181156 
    182157    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)) 
     158        return self.represent_scalar('tag:yaml.org,2002:int', str(data)) 
    187159 
    188160    inf_value = 1e300 
     
    192164    def represent_float(self, data): 
    193165        if data != data or (data == 0.0 and data == 1.0): 
    194             value = u'.nan' 
     166            value = '.nan' 
    195167        elif data == self.inf_value: 
    196             value = u'.inf' 
     168            value = '.inf' 
    197169        elif data == -self.inf_value: 
    198             value = u'-.inf' 
    199         else: 
    200             value = unicode(repr(data)).lower() 
     170            value = '-.inf' 
     171        else: 
     172            value = repr(data).lower() 
    201173            # Note that in some cases `repr(data)` represents a float number 
    202174            # without the decimal parts.  For instance: 
     
    206178            # to the definition of the `!!float` tag.  We fix this by adding 
    207179            # '.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) 
     180            if '.' not in value and 'e' in value: 
     181                value = value.replace('e', '.0e', 1) 
     182        return self.represent_scalar('tag:yaml.org,2002:float', value) 
    211183 
    212184    def represent_list(self, data): 
     
    218190        #            break 
    219191        #if not pairs: 
    220             return self.represent_sequence(u'tag:yaml.org,2002:seq', data) 
     192            return self.represent_sequence('tag:yaml.org,2002:seq', data) 
    221193        #value = [] 
    222194        #for item_key, item_value in data: 
     
    226198 
    227199    def represent_dict(self, data): 
    228         return self.represent_mapping(u'tag:yaml.org,2002:map', data) 
     200        return self.represent_mapping('tag:yaml.org,2002:map', data) 
    229201 
    230202    def represent_set(self, data): 
     
    232204        for key in data: 
    233205            value[key] = None 
    234         return self.represent_mapping(u'tag:yaml.org,2002:set', value) 
     206        return self.represent_mapping('tag:yaml.org,2002:set', value) 
    235207 
    236208    def represent_date(self, data): 
    237         value = unicode(data.isoformat()) 
    238         return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value) 
     209        value = data.isoformat() 
     210        return self.represent_scalar('tag:yaml.org,2002:timestamp', value) 
    239211 
    240212    def represent_datetime(self, data): 
    241         value = unicode(data.isoformat(' ')) 
    242         return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value) 
     213        value = data.isoformat(' ') 
     214        return self.represent_scalar('tag:yaml.org,2002:timestamp', value) 
    243215 
    244216    def represent_yaml_object(self, tag, data, cls, flow_style=None): 
     
    258230        SafeRepresenter.represent_str) 
    259231 
    260 SafeRepresenter.add_representer(unicode, 
    261         SafeRepresenter.represent_unicode) 
     232SafeRepresenter.add_representer(bytes, 
     233        SafeRepresenter.represent_binary) 
    262234 
    263235SafeRepresenter.add_representer(bool, 
     
    267239        SafeRepresenter.represent_int) 
    268240 
    269 SafeRepresenter.add_representer(long, 
    270         SafeRepresenter.represent_long) 
    271  
    272241SafeRepresenter.add_representer(float, 
    273242        SafeRepresenter.represent_float) 
     
    287256SafeRepresenter.add_representer(datetime.date, 
    288257        SafeRepresenter.represent_date) 
     258 
    289259SafeRepresenter.add_representer(datetime.datetime, 
    290260        SafeRepresenter.represent_datetime) 
     
    295265class Representer(SafeRepresenter): 
    296266 
    297     def represent_str(self, data): 
    298         tag = None 
    299         style = None 
    300         try: 
    301             data = unicode(data, 'ascii') 
    302             tag = u'tag:yaml.org,2002:str' 
    303         except UnicodeDecodeError: 
    304             try: 
    305                 data = unicode(data, 'utf-8') 
    306                 tag = u'tag:yaml.org,2002:python/str' 
    307             except UnicodeDecodeError: 
    308                 data = data.encode('base64') 
    309                 tag = u'tag:yaml.org,2002:binary' 
    310                 style = '|' 
    311         return self.represent_scalar(tag, data, style=style) 
    312  
    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' 
    320         return self.represent_scalar(tag, data) 
    321  
    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  
    328267    def represent_complex(self, data): 
    329268        if data.imag == 0.0: 
    330             data = u'%r' % data.real 
     269            data = '%r' % data.real 
    331270        elif data.real == 0.0: 
    332             data = u'%rj' % data.imag 
     271            data = '%rj' % data.imag 
    333272        elif data.imag > 0: 
    334             data = u'%r+%rj' % (data.real, data.imag) 
    335         else: 
    336             data = u'%r%rj' % (data.real, data.imag) 
    337         return self.represent_scalar(u'tag:yaml.org,2002:python/complex', data) 
     273            data = '%r+%rj' % (data.real, data.imag) 
     274        else: 
     275            data = '%r%rj' % (data.real, data.imag) 
     276        return self.represent_scalar('tag:yaml.org,2002:python/complex', data) 
    338277 
    339278    def represent_tuple(self, data): 
    340         return self.represent_sequence(u'tag:yaml.org,2002:python/tuple', data) 
     279        return self.represent_sequence('tag:yaml.org,2002:python/tuple', data) 
    341280 
    342281    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'') 
     282        name = '%s.%s' % (data.__module__, data.__name__) 
     283        return self.represent_scalar('tag:yaml.org,2002:python/name:'+name, '') 
    345284 
    346285    def represent_module(self, data): 
    347286        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) 
     287                'tag:yaml.org,2002:python/module:'+data.__name__, '') 
    390288 
    391289    def represent_object(self, data): 
     
    407305 
    408306        cls = type(data) 
    409         if cls in copy_reg.dispatch_table: 
    410             reduce = copy_reg.dispatch_table[cls](data) 
     307        if cls in copyreg.dispatch_table: 
     308            reduce = copyreg.dispatch_table[cls](data) 
    411309        elif hasattr(data, '__reduce_ex__'): 
    412310            reduce = data.__reduce_ex__(2) 
     
    427325            function = args[0] 
    428326            args = args[1:] 
    429             tag = u'tag:yaml.org,2002:python/object/new:' 
     327            tag = 'tag:yaml.org,2002:python/object/new:' 
    430328            newobj = True 
    431329        else: 
    432             tag = u'tag:yaml.org,2002:python/object/apply:' 
     330            tag = 'tag:yaml.org,2002:python/object/apply:' 
    433331            newobj = False 
    434         function_name = u'%s.%s' % (function.__module__, function.__name__) 
     332        function_name = '%s.%s' % (function.__module__, function.__name__) 
    435333        if not args and not listitems and not dictitems \ 
    436334                and isinstance(state, dict) and newobj: 
    437335            return self.represent_mapping( 
    438                     u'tag:yaml.org,2002:python/object:'+function_name, state) 
     336                    'tag:yaml.org,2002:python/object:'+function_name, state) 
    439337        if not listitems and not dictitems  \ 
    440338                and isinstance(state, dict) and not state: 
     
    451349        return self.represent_mapping(tag+function_name, value) 
    452350 
    453 Representer.add_representer(str, 
    454         Representer.represent_str) 
    455  
    456 Representer.add_representer(unicode, 
    457         Representer.represent_unicode) 
    458  
    459 Representer.add_representer(long, 
    460         Representer.represent_long) 
    461  
    462351Representer.add_representer(complex, 
    463352        Representer.represent_complex) 
     
    469358        Representer.represent_name) 
    470359 
    471 Representer.add_representer(types.ClassType, 
    472         Representer.represent_name) 
    473  
    474360Representer.add_representer(types.FunctionType, 
    475361        Representer.represent_name) 
     
    481367        Representer.represent_module) 
    482368 
    483 Representer.add_multi_representer(types.InstanceType, 
    484         Representer.represent_instance) 
    485  
    486369Representer.add_multi_representer(object, 
    487370        Representer.represent_object) 
Note: See TracChangeset for help on using the changeset viewer.