Changes in trunk/lib/syck/loaders.py [18:25]

File:

• trunk/lib/syck/loaders.py (modified) (11 diffs)

trunk/lib/syck/loaders.py

@@ +1 @@
+"""
+syck.loaders is a high-level wrapper for the Syck YAML parser.
+Do not use it directly, use the module 'syck' instead.
+"""
 
 # Python 2.2 compatibility
@@ -21 +25 @@
 import _syck
 
-import re
+import sys, re
 
 __all__ = ['GenericLoader', 'Loader',
@@ -27 +31 @@
 
 class GenericLoader(_syck.Parser):
+    """
+    GenericLoader constructs primitive Python objects from YAML documents.
+    """
 
     def load(self):
+        """
+        Loads a YAML document from the source and return a native Python
+        object. On EOF, returns None and set the eof attribute on.
+        """
         node = self.parse()
         if self.eof:
@@ -50 +61 @@
                 value_object = self._convert(node.value[key_node],
                         node_to_object)
-                if key_object in value:
-                    value = None
-                    break
                 try:
+                    if key_object in value:
+                        value = None
+                        break
                     value[key_object] = value_object
                 except TypeError:
@@ -61 +72 @@
                 value = []
                 for key_node in node.value:
-                    key_object = self_convert(key_node, node_to_object)
+                    key_object = self._convert(key_node, node_to_object)
                     value_object = self._convert(node.value[key_node],
                             node_to_object)
@@ -71 +82 @@
 
     def construct(self, node):
+        """Constructs a Python object by the given node."""
         return node.value
 
 class Merge:
+    """Represents the merge key '<<'."""
     pass
 
 class Default:
+    """Represents the default key '='."""
     pass
 
 class Loader(GenericLoader):
+    """
+    Loader constructs native Python objects from YAML documents.
+    """
 
     inf_value = 1e300000
     nan_value = inf_value/inf_value
 
-    ymd_expr = re.compile(r'(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d)')
     timestamp_expr = re.compile(r'(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d)'
             r'(?:'
@@ -95 +111 @@
     default_key = Default()
 
-    def __init__(self, *args, **kwds):
-        super(Loader, self).__init__(*args, **kwds)
-        self.tags = {}
-        self.add_builtin_types()
-
-    def add_builtin_types(self):
-        self.add_builtin_type('null', lambda node: None)
-        self.add_builtin_type('bool#yes', lambda node: True)
-        self.add_builtin_type('bool#no', lambda node: False)
-        self.add_builtin_type('float#fix', lambda node: float(node.value))
-        self.add_builtin_type('float#exp', lambda node: float(node.value))
-        self.add_builtin_type('float#base60', 'construct_base60_float')
-        self.add_builtin_type('float#inf', lambda node: self.inf_value)
-        self.add_builtin_type('float#neginf', lambda node: -self.inf_value)
-        self.add_builtin_type('float#nan', lambda node: self.nan_value)
-        self.add_builtin_type('int', lambda node: int(node.value))
-        self.add_builtin_type('int#hex', lambda node: int(node.value, 16))
-        self.add_builtin_type('int#oct', lambda node: int(node.value, 8))
-        self.add_builtin_type('int#base60', 'construct_base60_int')
-        self.add_builtin_type('binary', lambda node: node.value.decode('base64'))
-        self.add_builtin_type('timestamp#ymd', 'construct_timestamp')
-        self.add_builtin_type('timestamp#iso8601', 'construct_timestamp')
-        self.add_builtin_type('timestamp#spaced', 'construct_timestamp')
-        self.add_builtin_type('timestamp', 'construct_timestamp')
-        self.add_builtin_type('merge', 'construct_merge')
-        self.add_builtin_type('default', 'construct_default')
-        self.add_builtin_type('omap', 'construct_omap')
-        self.add_builtin_type('pairs', 'construct_pairs')
-        self.add_builtin_type('set', 'construct_set')
-
-    def add_type(self, type_tag, constuctor):
-        self.tags[type_tag] = constructor
-
-    def add_domain_type(self, domain, type_tag, constructor):
-        self.tags['tag:%s:%s' % (domain, type_tag)] = constructor
-
-    def add_builtin_type(self, type_tag, constructor):
-        self.tags['tag:yaml.org,2002:'+type_tag] = constructor
-
-    def add_python_type(self, type_tag, constructor):
-        self.tags['tag:python.yaml.org,2002:'+type_tag] = constructor
-
-    def add_private_type(self, type_tag, constructor):
-        self.tags['x-private:'+type_tag] = constructor
+    non_ascii = []
+    for i in range(256):
+        ch = chr(i)
+        if ch.isalnum():
+            non_ascii.append(ch)
+        else:
+            non_ascii.append('_')
+    non_ascii = ''.join(non_ascii)
+
+    python_bools = {'True': True, 'False': False}
+
+    class python_class:
+        pass
+
+    def find_constructor(self, node):
+        """
+        Returns the contructor for generating a Python object for the given
+        node.
+
+        The node tags are mapped to constructors by the following rule:
+
+        Tag                             Constructor
+        ---                             -----------
+        tag:yaml.org,2002:type          construct_type
+        tag:python.yaml.org,2002:type   construct_python_type
+        x-private:type                  construct_private_type
+        tag:domain.tld,2002:type        construct_domain_tld_2002_type
+
+        See the method code for more details.
+        """
+        parts = []
+        if node.tag:
+            parts = node.tag.split(':')
+        if parts:
+            if parts[0] == 'tag':
+                parts.pop(0)
+                if parts:
+                    if parts[0] == 'yaml.org,2002':
+                        parts.pop(0)
+                    elif parts[0] == 'python.yaml.org,2002':
+                        parts[0] = 'python'
+            elif parts[0] == 'x-private':
+                parts[0] = 'private'
+        parts = [part.translate(self.non_ascii) for part in parts]
+        while parts:
+            method = 'construct_'+'_'.join(parts)
+            if hasattr(self, method):
+                return getattr(self, method)
+            parts.pop()
 
     def construct(self, node):
+        """Constructs a Python object by the given node."""
         if node.kind == 'map' and self.merge_key in node.value:
             self.merge_maps(node)
-        if node.tag in self.tags:
-            constructor = self.tags[node.tag]
-            if isinstance(constructor, str):
-                constructor = getattr(self, constructor)
+        constructor = self.find_constructor(node)
+        if constructor:
             return constructor(node)
         else:
             return node.value
 
-    def construct_base60_float(self, node):
-        return self.construct_base60(float, node)
-
-    def construct_base60_int(self, node):
-        return self.construct_base60(int, node)
-
-    def construct_base60(self, num_type, node):
+    def construct_null(self, node):
+        return None
+
+    def construct_bool_yes(self, node):
+        return True
+
+    def construct_bool_no(self, node):
+        return False
+
+    def construct_numeric_base60(self, num_type, node):
         digits = [num_type(part) for part in node.value.split(':')]
         digits.reverse()
@@ -166 +189 @@
             base *= 60
         return value
+
+    def construct_int(self, node):
+        return int(node.value)
+
+    def construct_int_hex(self, node):
+        return int(node.value, 16)
+
+    def construct_int_oct(self, node):
+        return int(node.value, 8)
+
+    def construct_int_base60(self, node):
+        return self.construct_numeric_base60(int, node)
+
+    def construct_float(self, node):
+        return float(node.value)
+    construct_float_fix = construct_float
+    construct_float_exp = construct_float
+
+    def construct_float_base60(self, node):
+        return self.construct_numeric_base60(float, node)
+
+    def construct_float_inf(self, node):
+        return self.inf_value
+
+    def construct_float_neginf(self, node):
+        return -self.inf_value
+
+    def construct_float_nan(self, node):
+        return self.nan_value
+
+    def construct_binary(self, node):
+        return node.value.decode('base64')
 
     def construct_timestamp(self, node):
@@ -183 +238 @@
         diff = datetime.timedelta(hours=values['zhour'], minutes=values['zminute'])
         return stamp-diff
+    construct_timestamp_ymd = construct_timestamp
+    construct_timestamp_iso8601 = construct_timestamp
+    construct_timestamp_spaced = construct_timestamp
 
     def construct_merge(self, node):
@@ -217 +275 @@
         return sets.Set(node.value)
 
-def parse(source):
+    def construct_python_none(self, node):
+        return None
+
+    def construct_python_bool(self, node):
+        return self.python_bools[node.value]
+
+    def construct_python_int(self, node):
+        return int(node.value)
+
+    def construct_python_long(self, node):
+        return long(node.value)
+
+    def construct_python_float(self, node):
+        return float(node.value)
+
+    def construct_python_str(self, node):
+        return str(node.value)
+
+    def construct_python_unicode(self, node):
+        return unicode(node.value, 'utf-8')
+
+    def construct_python_list(self, node):
+        return node.value
+
+    def construct_python_tuple(self, node):
+        return tuple(node.value)
+
+    def construct_python_dict(self, node):
+        return node.value
+
+    def find_python_object(self, node):
+        full_name = node.tag.split(':')[3]
+        parts = full_name.split('.')
+        object_name = parts.pop()
+        module_name = '.'.join(parts)
+        if not module_name:
+            module_name = '__builtin__'
+        else:
+            __import__(module_name)
+        return getattr(sys.modules[module_name], object_name)
+
+    def find_python_state(self, node):
+        if node.kind == 'seq':
+            args = node.value
+            kwds = {}
+            state = {}
+        else:
+            args = node.value.get('args', [])
+            kwds = node.value.get('kwds', {})
+            state = node.value.get('state', {})
+        return args, kwds, state
+
+    def set_python_state(self, object, state):
+        if hasattr(object, '__setstate__'):
+            object.__setstate__(state)
+        else:
+            slotstate = {}
+            if isinstance(state, tuple) and len(state) == 2:
+                state, slotstate = state
+            if hasattr(object, '__dict__'):
+                object.__dict__.update(state)
+            elif state:
+                slotstate.update(state)
+            for key, value in slotstate.items():
+                setattr(object, key, value)
+
+    def construct_python_name(self, node):
+        return self.find_python_object(node)
+
+    def construct_python_object(self, node):
+        cls = self.find_python_object(node)
+        if type(cls) is type(self.python_class):
+            if hasattr(cls, '__getnewargs__'):
+                object = cls()
+            else:
+                object = self.python_class()
+                object.__class__ = cls
+        else:
+            object = cls.__new__(cls)
+        self.set_python_state(object, node.value)
+        return object
+
+    def construct_python_new(self, node):
+        cls = self.find_python_object(node)
+        args, kwds, state = self.find_python_state(node)
+        if type(cls) is type(self.python_class):
+            object = cls(*args, **kwds)
+        else:
+            object = cls.__new__(cls, *args, **kwds)
+        self.set_python_state(object, state)
+        return object
+
+    def construct_python_apply(self, node):
+        constructor = self.find_python_object(node)
+        args, kwds, state = self.find_python_state(node)
+        object = constructor(*args, **kwds)
+        self.set_python_state(object, state)
+        return object
+
+def parse(source, Loader=Loader, **parameters):
     """Parses 'source' and returns the root of the 'Node' graph."""
-    loader = Loader(source)
+    loader = Loader(source, **parameters)
     return loader.parse()
 
-def load(source):
+def load(source, Loader=Loader, **parameters):
     """Parses 'source' and returns the root object."""
-    loader = Loader(source)
+    loader = Loader(source, **parameters)
     return loader.load()
 
-def parse_documents(source):
-    """Iterates over 'source' and yields the root node of each document."""
-    loader = Loader(source)
+def parse_documents(source, Loader=Loader, **parameters):
+    """Iterates over 'source' and yields the root 'Node' for each document."""
+    loader = Loader(source, **parameters)
     while True:
         node = loader.parse()
@@ -236 +393 @@
         yield node
 
-def load_documents(source):
-    """Iterates over 'source' and yields the root object of each document."""
-    loader = Loader(source)
+def load_documents(source, Loader=Loader, **parameters):
+    """Iterates over 'source' and yields the root object for each document."""
+    loader = Loader(source, **parameters)
     while True:
         object = loader.load()