Changes in trunk/lib/syck/dumpers.py [20:25]

File:

• trunk/lib/syck/dumpers.py (modified) (10 diffs)

trunk/lib/syck/dumpers.py

@@ +1 @@
+"""
+syck.dumpers is a high-level wrapper for the Syck YAML emitter.
+Do not use it directly, use the module 'syck' instead.
+"""
 
 import _syck
@@ -10 +14 @@
     'emit', 'dump', 'emit_documents', 'dump_documents']
 
-INF = 1e300000
-NEGINF = -INF
-NAN = INF/INF
-
-
 class GenericDumper(_syck.Emitter):
+    """
+    GenericDumper dumps native Python objects into YAML documents.
+    """
 
     def dump(self, object):
+        """Dumps the given Python object as a YAML document."""
         self.emit(self._convert(object, {}))
 
     def _convert(self, object, object_to_node):
         if id(object) in object_to_node and self.allow_aliases(object):
-            return object_to_node[id(object)]
+            return object_to_node[id(object)][1]
         node = self.represent(object)
-        object_to_node[id(object)] = node
+        object_to_node[id(object)] = object, node
         if node.kind == 'seq':
-            for index, item in enumerate(node.value):
+            for index in range(len(node.value)):
+                item = node.value[index]
                 node.value[index] = self._convert(item, object_to_node)
         elif node.kind == 'map':
-            for key in node.value.keys():
-                value = node.value[key]
-                del node.value[key]
-                node.value[self._convert(key, object_to_node)] =    \
-                        self._convert(value, object_to_node)
+            if isinstance(node.value, dict):
+                for key in node.value.keys():
+                    value = node.value[key]
+                    del node.value[key]
+                    node.value[self._convert(key, object_to_node)] =    \
+                            self._convert(value, object_to_node)
+            elif isinstance(node.value, list):
+                for index in range(len(node.value)):
+                    key, value = node.value[index]
+                    node.value[index] = (self._convert(key, object_to_node),
+                            self._convert(value, object_to_node))
 #        # Workaround against a Syck bug:
 #        if node.kind == 'scalar' and node.style not in ['1quote', '2quote'] \
@@ -41 +51 @@
 
     def represent(self, object):
+        """Represents the given Python object as a 'Node'."""
         if isinstance(object, dict):
             return _syck.Map(object.copy(), tag="tag:yaml.org,2002:map")
@@ -49 +60 @@
 
     def allow_aliases(self, object):
+        """Checks whether the given object can be aliased."""
         return True
 
 class Dumper(GenericDumper):
-
-    def __init__(self, *args, **kwds):
-        super(Dumper, self).__init__(*args, **kwds)
-
-    def represent(self, object):
+    """
+    Dumper dumps native Python objects into YAML documents.
+    """
+
+    INF = 1e300000
+    inf_value = repr(INF)
+    neginf_value = repr(-INF)
+    nan_value = repr(INF/INF)
+
+    def find_representer(self, object):
+        """
+        For the given object, find a method that can represent it as a 'Node'
+        object.
+
+        If the type of the object has the form 'package.module.type',
+        find_representer() returns the method 'represent_package_module_type'.
+        If this method does not exist, it checks the base types.
+        """
         for object_type in type(object).__mro__:
             if object_type.__module__ == '__builtin__':
@@ -62 +87 @@
             else:
                 name = '%s.%s' % (object_type.__module__, object_type.__name__)
-            method = 'represent_%s' % name.replace('.', '_')
+            method = 'represent_' + name.replace('.', '_')
             if hasattr(self, method):
-                return getattr(self, method)(object)
-        return super(Dumper, self).represent(object)
+                return getattr(self, method)
+
+    def represent(self, object):
+        """Represents the given Python object as a 'Node'."""
+        representer = self.find_representer(object)
+        if representer:
+            return representer(object)
+        else:
+            return super(Dumper, self).represent(object)
 
     def represent_object(self, object):
@@ -88 +120 @@
         return _syck.Scalar(repr(object), tag="tag:yaml.org,2002:int")
 
-    def represent_int(self, object):
-        return _syck.Scalar(repr(object), tag="tag:yaml.org,2002:int")
-
     def represent_float(self, object):
         value = repr(object)
-        if value == repr(INF):
+        if value == self.inf_value:
             value = '.inf'
-        elif value == repr(NEGINF):
+        elif value == self.neginf_value:
             value = '-.inf'
-        elif value == repr(NAN):
+        elif value == self.nan_value:
             value = '.nan'
         return _syck.Scalar(value, tag="tag:yaml.org,2002:float")
@@ -103 +132 @@
     def represent_sets_Set(self, object):
         return _syck.Seq(list(object), tag="tag:yaml.org,2002:set")
+    represent_set = represent_sets_Set
 
     def represent_datetime_datetime(self, object):
         return _syck.Scalar(object.isoformat(), tag="tag:yaml.org,2002:timestamp")
 
+    def represent_long(self, object):
+        return _syck.Scalar(repr(object), tag="tag:python.yaml.org,2002:long")
+
+    def represent_unicode(self, object):
+        return _syck.Scalar(object.encode('utf-8'), tag="tag:python.yaml.org,2002:unicode")
+
+    def represent_tuple(self, object):
+        return _syck.Seq(list(object), tag="tag:python.yaml.org,2002:tuple")
+
+    def represent_type(self, object):
+        name = '%s.%s' % (object.__module__, object.__name__)
+        return _syck.Scalar('', tag="tag:python.yaml.org,2002:name:"+name)
+    represent_classobj = represent_type
+    represent_class = represent_type
+    # TODO: Python 2.2 does not provide the module name of a function
+    represent_function = represent_type
+    represent_builtin_function_or_method = represent_type
+
+    def represent_instance(self, object):
+        cls = object.__class__
+        class_name = '%s.%s' % (cls.__module__, cls.__name__)
+        args = ()
+        state = {}
+        if hasattr(object, '__getinitargs__'):
+            args = object.__getinitargs__()
+        if hasattr(object, '__getstate__'):
+            state = object.__getstate__()
+        elif not hasattr(object, '__getinitargs__'):
+            state = object.__dict__.copy()
+        if not args and isinstance(state, dict):
+            return _syck.Map(state.copy(),
+                    tag="tag:python.yaml.org,2002:object:"+class_name)
+        value = {}
+        if args:
+            value['args'] = list(args)
+        if state or not isinstance(state, dict):
+            value['state'] = state
+        return _syck.Map(value,
+                tag="tag:python.yaml.org,2002:new:"+class_name)
+
+    def represent_object(self, object): # Do you understand this? I don't.
+        cls = type(object)
+        class_name = '%s.%s' % (cls.__module__, cls.__name__)
+        args = ()
+        state = {}
+        if cls.__reduce__ is type.__reduce__:
+            if hasattr(object, '__reduce_ex__'):
+                reduce = object.__reduce_ex__(2)
+                args = reduce[1][1:]
+            else:
+                reduce = object.__reduce__()
+            if len(reduce) > 2:
+                state = reduce[2]
+            if state is None:
+                state = {}
+            if not args and isinstance(state, dict):
+                return _syck.Map(state.copy(),
+                        tag="tag:python.yaml.org,2002:object:"+class_name)
+            if not state and isinstance(state, dict):
+                return _syck.Seq(list(args),
+                        tag="tag:python.yaml.org,2002:new:"+class_name)
+            value = {}
+            if args:
+                value['args'] = list(args)
+            if state or not isinstance(state, dict):
+                value['state'] = state
+            return _syck.Map(value,
+                    tag="tag:python.yaml.org,2002:new:"+class_name)
+        else:
+            reduce = object.__reduce__()
+            cls = reduce[0]
+            class_name = '%s.%s' % (cls.__module__, cls.__name__)
+            args = reduce[1]
+            state = None
+            if len(reduce) > 2:
+                state = reduce[2]
+            if state is None:
+                state = {}
+            if not state and isinstance(state, dict):
+                return _syck.Seq(list(args),
+                        tag="tag:python.yaml.org,2002:apply:"+class_name)
+            value = {}
+            if args:
+                value['args'] = list(args)
+            if state or not isinstance(state, dict):
+                value['state'] = state
+            return _syck.Map(value,
+                    tag="tag:python.yaml.org,2002:apply:"+class_name)
+
+    def represent__syck_Node(self, object):
+        object_type = type(object)
+        type_name = '%s.%s' % (object_type.__module__, object_type.__name__)
+        state = []
+        if hasattr(object_type, '__slotnames__'):
+            for name in object_type.__slotnames__:
+                value = getattr(object, name)
+                if value:
+                    state.append((name, value))
+        return _syck.Map(state,
+                tag="tag:python.yaml.org,2002:object:"+type_name)
+
     def allow_aliases(self, object):
+        """Checks whether the given object can be aliased."""
         if object is None or type(object) in [int, bool, float]:
             return False
         if type(object) is str and (not object or object.isalnum()):
             return False
+        if type(object) is tuple and not object:
+            return False
         return True
 
-def emit(node, output=None, **parameters):
+def emit(node, output=None, Dumper=Dumper, **parameters):
+    """
+    Emits the given node to the output.
+
+    If output is None, returns the produced YAML document.
+    """
     if output is None:
         dumper = Dumper(StringIO.StringIO(), **parameters)
@@ -123 +262 @@
         return dumper.output.getvalue()
 
-def dump(object, output=None, **parameters):
+def dump(object, output=None, Dumper=Dumper, **parameters):
+    """
+    Dumps the given object to the output.
+
+    If output is None, returns the produced YAML document.
+    """
     if output is None:
         dumper = Dumper(StringIO.StringIO(), **parameters)
@@ -132 +276 @@
         return dumper.output.getvalue()
 
-def emit_documents(nodes, output=None, **parameters):
+def emit_documents(nodes, output=None, Dumper=Dumper, **parameters):
+    """
+    Emits the list of nodes to the output.
+    
+    If output is None, returns the produced YAML document.
+    """
     if output is None:
         dumper = Dumper(StringIO.StringIO(), **parameters)
@@ -142 +291 @@
         return dumper.output.getvalue()
 
-def dump_documents(objects, output=None, **parameters):
+def dump_documents(objects, output=None, Dumper=Dumper, **parameters):
+    """
+    Dumps the list of objects to the output.
+    
+    If output is None, returns the produced YAML document.
+    """
     if output is None:
         dumper = Dumper(StringIO.StringIO(), **parameters)