Python yaml.serialize函数代码示例

def multi_constructor_obj(loader, tag_suffix, node):
    """
    Callback used by PyYAML when a "!obj:" tag is encountered.

    See PyYAML documentation for details on the call signature.
    """
    yaml_src = yaml.serialize(node)
    construct_mapping(node)
    mapping = loader.construct_mapping(node)

    assert hasattr(mapping, 'keys')
    assert hasattr(mapping, 'values')

    for key in mapping.keys():
        if not isinstance(key, basestring):
            message = "Received non string object (%s) as " \
                      "key in mapping." % str(key)
            raise TypeError(message)
    if '.' not in tag_suffix:
        # TODO: I'm not sure how this was ever working without eval().
        callable = eval(tag_suffix)
    else:
        callable = try_to_import(tag_suffix)
    rval = Proxy(callable=callable, yaml_src=yaml_src, positionals=(),
                 keywords=mapping)
    return rval

def multi_constructor(loader, tag_suffix, node) :
    """
    Constructor function passed to PyYAML telling it how to construct
    objects from argument descriptions. See PyYAML documentation for
    details on the call signature.
    """

    yaml_src = yaml.serialize(node)
    mapping = loader.construct_mapping(node)
    if '.' not in tag_suffix:
        classname = tag_suffix
        rval = ObjectProxy(classname, mapping, yaml_src)
    else:
        components = tag_suffix.split('.')
        modulename = '.'.join(components[:-1])

        try:
            exec('import %s' % modulename)
        except ImportError, e:
            raise ImportError("Could not import "+modulename+". python wanted to phrase this as: "+str(e))
        try:
            classname = eval(tag_suffix)
        except AttributeError:
            raise AttributeError('Could not evaluate %s' % tag_suffix)
        rval =  ObjectProxy(classname, mapping, yaml_src)

def multi_constructor_obj(loader, tag_suffix, node):
    """
    Callback used by PyYAML when a "!obj:" tag is encountered.

    See PyYAML documentation for details on the call signature.
    """
    yaml_src = yaml.serialize(node)
    construct_mapping(node)
    mapping = loader.construct_mapping(node)

    assert hasattr(mapping, "keys")
    assert hasattr(mapping, "values")

    for key in mapping.keys():
        if not isinstance(key, basestring):
            message = "Received non string object (%s) as " "key in mapping." % str(key)
            raise TypeError(message)

    if "." not in tag_suffix:
        classname = tag_suffix
        rval = ObjectProxy(classname, mapping, yaml_src)
    else:
        classname = try_to_import(tag_suffix)
        rval = ObjectProxy(classname, mapping, yaml_src)

    return rval

def multi_constructor_obj(loader, tag_suffix, node):
    """
    Converts "key: !obj:python.path { }," to "key: { __obj__: python.path }".
    """
    yaml_src = yaml.serialize(node)
    mapping = loader.construct_mapping(node)
    mapping['__obj__'] = tag_suffix
    return mapping

def multi_constructor_import(loader, tag_suffix, node):
    yaml_src = yaml.serialize(node)
    mapping = loader.construct_mapping(node)
    if '.' not in tag_suffix:
        raise yaml.YAMLError("import tag suffix contains no '.'")
    else:
        rval = try_to_import(tag_suffix)
    return rval

def constructor_int(loader, node):
    """
    Callback used by PyYAML when a "!int <str>" tag is encountered.
    This tag expects a (quoted) string as argument.
    """
    yaml_src = yaml.serialize(node)
    value = loader.construct_scalar(node)
    return Proxy(callable=delayed_constructor_int, yaml_src=yaml_src, positionals=(),
                 keywords={'value': value})

def constructor_setting(loader, node):
    """Callback used by PyYAML when a "!setting" tag is encountered.
    See PyYAML documentation for details on the call signature.
    """
    yaml_src = yaml.serialize(node)
    value = loader.construct_scalar(node)
    proxy = Proxy(callable=Setting, keywords={"name": value}, yaml_src=yaml_src)

    return proxy

def constructor_range(loader, node):
    """
    Callback used by PyYAML when a "!range <str>" tag is encountered.
    This tag expects a (quoted) string as argument.
    """
    yaml_src = yaml.serialize(node)
    mseq = MultiSeq.get_instance()
    value = loader.construct_scalar(node)
    rng_var = mseq.add_range_var(value)
    return Proxy(callable=MultiSeq.get_value, yaml_src=yaml_src, positionals=(),
             keywords={'rng_var': rng_var})

def multi_constructor_pkl(loader, tag_suffix, node):
    """
    Callback used by PyYAML when a "!pkl:" tag is encountered.
    """
    global additional_environ
    if tag_suffix != "" and tag_suffix != u"":
        raise AssertionError('Expected tag_suffix to be "" but it is "' + tag_suffix +
                    '": Put space between !pkl: and the filename.')

    mapping = loader.construct_yaml_str(node)
    rval = ObjectProxy(None, {}, yaml.serialize(node))
    rval.instance = serial.load(preprocess(mapping, additional_environ))

    return rval

def multi_constructor_obj(loader, tag_suffix, node):
    """Callback used by PyYAML when a "!obj:" tag is encountered.
    See PyYAML documentation for details on the call signature.
    """
    yaml_src = yaml.serialize(node)
    mapping = loader.construct_mapping(node)

    if '.' not in tag_suffix:
        callable = eval(tag_suffix)
    else:
        callable = try_to_import(tag_suffix)

    proxy = Proxy(callable=callable,keywords=mapping,yaml_src=yaml_src)

    return proxy

	def test_dump_1(self):
		""" generate node object for 1 log """
		
		m = "This is a log record"
		loglist_orig = dpcore.load_logs(m)
		
		nodelist = dpcore.yamlnodedump_logs(loglist_orig[0])
		
		yml = yaml.serialize(nodelist)
		#print yml
		c = yaml.load(yml)
		
		loglist_comp = dpcore.load_logs(c)
		self.assertEqual(loglist_comp[0].log, loglist_orig[0].log)
		self.assertEqual(loglist_comp[0].action, loglist_orig[0].action)

	def test_dump_1(self):
		""" generate node object for 1 task """
		
		m = "This is a task"
		tasklist_orig = dpcore.load_tasks(m)
		
		nodelist = dpcore.yamlnodedump_tasks(tasklist_orig[0])
		
		yml = yaml.serialize(nodelist)
		#print yml
		c = yaml.load(yml)
		
		tasklist_comp = dpcore.load_tasks(c)
		self.assertEqual(tasklist_comp[0].task, tasklist_orig[0].task)
		self.assertEqual(tasklist_comp[0].note, tasklist_orig[0].note)

def multi_constructor_pkl(loader, tag_suffix, node):
    """
    Callback used by PyYAML when a "!pkl:" tag is encountered.
    """
    global additional_environ
    if tag_suffix != "" and tag_suffix != u"":
        raise AssertionError('Expected tag_suffix to be "" but it is "'
                             + tag_suffix +
                             '": Put space between !pkl: and the filename.')

    mapping = loader.construct_yaml_str(node)
    obj = serial.load(preprocess(mapping, additional_environ))
    proxy = Proxy(callable=do_not_recurse, positionals=(),
                  keywords={'value': obj}, yaml_src=yaml.serialize(node))
    return proxy

def multi_constructor_pkl(loader, tag_suffix, node):
    """
    Constructor function passed to PyYAML telling it how to load
    objects from paths to .pkl files. See PyYAML documentation for
    details on the call signature.
    """

    mapping = loader.construct_yaml_str(node)
    if tag_suffix != "" and tag_suffix != u"":
        raise AssertionError('Expected tag_suffix to be "" but it is "'+tag_suffix+'"')

    rval = ObjectProxy(None, {}, yaml.serialize(node))
    rval.instance = serial.load(mapping)

    return rval

def multi_constructor_pkl(loader, tag_suffix, node):
    """
    Constructor function passed to PyYAML telling it how to load
    objects from paths to .pkl files. See PyYAML documentation for
    details on the call signature.
    """

    #print dir(loader)
    mapping = loader.construct_yaml_str(node)
    assert tag_suffix == ""

    rval = ObjectProxy(None,{},yaml.serialize(node))
    rval.instance = serial.load(mapping)

    return rval