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

	def test_dump_1(self):
		""" generate node object for 1 story """
		
		m = "This is a story"
		storylist_orig = dpcore.load_stories(m)
		
		nodelist = dpcore.yamlnodedump_stories(storylist_orig[0])
		
		yml = yaml.serialize(nodelist)
		#print yml
		c = yaml.load(yml)
		
		storylist_comp = dpcore.load_stories(c)
		self.assertEqual(storylist_comp[0].story, storylist_orig[0].story)
		self.assertEqual(storylist_comp[0].note, storylist_orig[0].note)

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:
        classname = try_to_import(tag_suffix)
        rval = ObjectProxy(classname, mapping, yaml_src)

    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:
        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 test_dump_2(self):
		""" generate node object2 for 2 task """
		
		m = ["This is log 1.", "this is log message 2."]
		loglist_orig = dpcore.load_logs(m)
		
		nodeobjlist = dpcore.yamlnodedump_logs(loglist_orig)
		nodelist = yaml.SequenceNode(tag=u"tag:yaml.org,2002:seq", value=nodeobjlist, flow_style=False)
		
		yml = yaml.serialize(nodelist)
		#print yml
		c = yaml.load(yml)
		
		loglist_comp = dpcore.load_logs(c)
		for idx in range(2):
			self.assertEqual(loglist_comp[idx].log, loglist_orig[idx].log)
			self.assertEqual(loglist_comp[idx].action, loglist_orig[idx].action)

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:
            # We know it's an ImportError, but is it an ImportError related to
            # this path,
            #o r did the module we're importing have an unrelated ImportError?
            # and yes, this test can still have false positives, feel free to
            # improve it
            pieces = modulename.split('.')
            str_e = str(e)
            found = True in [piece.find(str(e)) != -1 for piece in pieces]

            if found:
                # The yaml file is probably to blame.
                # Report the problem with the full module path from the YAML
                # file
                raise ImportError("Could not import %s; ImportError was %s" %
                                  (modulename, str_e))
            else:
                # The module being imported contains an error.
                # Pass the original exception on up, with the original stack
                # trace preserved
                raise
        try:
            classname = eval(tag_suffix)
        except AttributeError:
            raise AttributeError('Could not evaluate %s' % tag_suffix)
        rval = ObjectProxy(classname, mapping, yaml_src)