def represent_mapping(self, tag, mapping, flow_style=None):
value = []
node = MappingNode(tag, value, flow_style=flow_style)
if self.alias_key is not None:
self.represented_objects[self.alias_key] = node
best_style = True
if hasattr(mapping, 'items'):
# if it's a syaml_dict, preserve OrderedDict order.
# Otherwise do the default thing.
sort = not isinstance(mapping, syaml_dict)
mapping = list(mapping.items())
if sort:
mapping.sort()
for item_key, item_value in mapping:
node_key = self.represent_data(item_key)
node_value = self.represent_data(item_value)
if not (isinstance(node_key, ScalarNode) and not node_key.style):
best_style = False
if not (isinstance(node_value, ScalarNode)
and not node_value.style):
best_style = False
value.append((node_key, node_value))
if flow_style is None:
if self.default_flow_style is not None:
node.flow_style = self.default_flow_style
else:
node.flow_style = best_style
return node
def test_set_comparison(self):
null = ScalarNode(YAML_NULL_TAG, "")
n1 = MappingNode(YAML_SET_TAG, [(ystr("a"), null), (ystr("b"), null)])
n2 = MappingNode(YAML_SET_TAG, [(ystr("b"), null), (ystr("a"), null)])
n3 = MappingNode(YAML_SET_TAG, [(ystr("b"), null), (ystr("a"), null),
(ystr("c"), null)])
n4 = MappingNode(YAML_SET_TAG, [(ystr("b"), null), (ystr("a"), null),
(ystr("d"), null)])
self.assertTrue(nodes_equal(n1, n2))
self.assertFalse(nodes_equal(n1, n3))
self.assertFalse(nodes_equal(n3, n1))
self.assertFalse(nodes_equal(n3, n4))
self.assertFalse(nodes_equal(n4, n3))
def _accept_mapping(self, anchor, sink_node):
start_event = self._event_next()
tag = self._resolve_tag(start_event.tag, MappingNode, None, start_event.implicit)
start_event.tag = tag
yield start_event
node = MappingNode(tag, [], start_event.start_mark, None,
flow_style=start_event.flow_style)
self._set_anchor(anchor, node)
while not self._event_peek_isa(MappingEndEvent):
sink_key = _Sink()
sink_value = _Sink()
if self._settings.with_extra_events:
mark = self._event_peek().start_mark
yield PairStartEvent(mark)
yield PairKeyStartEvent(mark)
for ee in self._accept_any_value(node, None, sink_key): yield ee
if self._settings.with_extra_events:
mark = self._event_peek().start_mark
yield PairKeyEndEvent(mark)
yield PairValueStartEvent(mark)
for ee in self._accept_any_value(node, sink_key.value,
sink_value): yield ee
if self._settings.with_extra_events:
mark = self._event_peek().start_mark
yield PairValueEndEvent(mark)
yield PairEndEvent(mark)
if self._settings.composing_fully:
node.value.append((sink_key.value, sink_value.value))
end_event = self._event_next()
yield end_event
node.end_mark = end_event.end_mark
_put(sink_node, node)
def test_unknown_tag_comparison(self):
n1 = ScalarNode(YAML_NS + "xyz", "foo")
n2 = ScalarNode(YAML_NS + "xyz", "foo")
n3 = ScalarNode(YAML_NS + "xyz", "bar")
self.assertTrue(nodes_equal(n1, n2))
self.assertFalse(nodes_equal(n1, n3))
n1 = SequenceNode(YAML_NS + "xyz", [ystr("foo")])
n2 = SequenceNode(YAML_NS + "xyz", [ystr("foo")])
n3 = SequenceNode(YAML_NS + "xyz", [ystr("bar")])
self.assertTrue(nodes_equal(n1, n2))
self.assertFalse(nodes_equal(n1, n3))
n1 = MappingNode(YAML_NS + "xyz", [(ystr("foo"), ystr("bar"))])
n2 = MappingNode(YAML_NS + "xyz", [(ystr("foo"), ystr("bar"))])
n3 = MappingNode(YAML_NS + "xyz", [(ystr("foo"), ystr("baz"))])
self.assertTrue(nodes_equal(n1, n2))
self.assertFalse(nodes_equal(n1, n3))
def test_map_misordered_comparison(self):
n1 = MappingNode(YAML_MAP_TAG, [(ystr("a"), ystr("foo")),
(ystr("b"), ystr("bar"))])
n2 = MappingNode(YAML_MAP_TAG, [(ystr("b"), ystr("bar")),
(ystr("a"), ystr("foo"))])
n3 = MappingNode(YAML_MAP_TAG, [(ystr("a"), ystr("bar")),
(ystr("b"), ystr("foo")),
(ystr("c"), ystr("baz"))])
n4 = MappingNode(YAML_MAP_TAG, [(ystr("a"), ystr("bar")),
(ystr("b"), ystr("foo")),
(ystr("c"), ystr("xxx"))])
n5 = MappingNode(YAML_MAP_TAG, [(ystr("a"), ystr("bar")),
(ystr("b"), ystr("foo")),
(ystr("d"), ystr("xxx"))])
self.assertTrue(nodes_equal(n1, n2))
self.assertTrue(nodes_equal(n2, n1))
self.assertFalse(nodes_equal(n1, n3))
self.assertFalse(nodes_equal(n3, n4))
self.assertFalse(nodes_equal(n4, n5))
def represent_map(self, mapping):
value = []
node = MappingNode('tag:yaml.org,2002:map', value)
if self.alias_key is not None:
self.represented_objects[self.alias_key] = node
best_style = True
if hasattr(mapping, 'items'):
mapping = mapping.items()
for item_key, item_value in mapping:
node_key = self.represent_data(item_key)
node_value = self.represent_data(item_value)
if not (isinstance(node_key, ScalarNode) and not node_key.style):
best_style = False
if not (isinstance(node_value, ScalarNode) and not node_value.style):
best_style = False
value.append((node_key, node_value))
if self.default_flow_style is not None:
node.flow_style = self.default_flow_style
else:
node.flow_style = best_style
return node
def represent_ordered_mapping(dumper, tag, mapping, flow_style=None):
value = []
node = MappingNode(tag, value, flow_style=flow_style)
if dumper.alias_key is not None:
dumper.represented_objects[dumper.alias_key] = node
best_style = True
if hasattr(mapping, 'items'):
mapping = list(mapping.items())
for item_key, item_value in mapping:
node_key = dumper.represent_data(item_key)
node_value = dumper.represent_data(item_value)
if not (isinstance(node_key, ScalarNode) and not node_key.style):
best_style = False
if not (isinstance(node_value, ScalarNode) and not node_value.style):
best_style = False
value.append((node_key, node_value))
if flow_style is None:
if dumper.default_flow_style is not None:
node.flow_style = dumper.default_flow_style
else:
node.flow_style = best_style
return node
def _represent_ordered_dict(self, mapping, flow_style=None):
value = []
node = MappingNode(_YAML_MAP_TAG, value, flow_style=flow_style)
if self.alias_key is not None:
self.represented_objects[self.alias_key] = node
best_style = True
if hasattr(mapping, 'items'):
mapping = mapping.items()
for item_key, item_value in mapping:
node_key = self.represent_data(item_key)
node_value = self.represent_data(item_value)
if not (isinstance(node_key, ScalarNode) and not node_key.style):
best_style = False
if not (isinstance(node_value, ScalarNode) and not node_value.style):
best_style = False
value.append((node_key, node_value))
if flow_style is None:
if self.default_flow_style is not None:
node.flow_style = self.default_flow_style
else:
node.flow_style = best_style
return node
def merge_nodes(a, b):
"""
merge_nodes(a, b) -> node
Merge the values of the two nodes together to produce a new node.
"""
if a.tag == YAML_NULL_TAG:
node = b
elif b.tag == YAML_NULL_TAG:
node = a
elif isinstance(a, ScalarNode):
raise AssemblyError("Cannot merge %s value at" % simplify_tag(b.tag),
b.start_mark,
"into %s value at" % simplify_tag(a.tag),
a.start_mark)
elif isinstance(a, SequenceNode):
if not isinstance(b, SequenceNode) or b.tag != a.tag:
raise AssemblyError(
"Cannot merge %s value at" % simplify_tag(b.tag), b.start_mark,
"into %s value at" % simplify_tag(a.tag), a.start_mark)
node = SequenceNode(a.tag, a.value + b.value)
elif isinstance(a, MappingNode):
if not isinstance(b, MappingNode) or b.tag != a.tag:
raise AssemblyError(
"Cannot merge %s value at" % simplify_tag(b.tag), b.start_mark,
"into %s value at" % simplify_tag(a.tag), a.start_mark)
# If the existing value is a regular map (not an omap), we need to
# look for duplicate keys and raise an exception if one
# is found. Since YAML allows for complex keys (sequences, etc.),
# PyYAML stores mappings as an unordered list of (key, value) tuples.
if a.tag == YAML_MAP_TAG:
for bkey, _ in b.value:
pos = mapping_find(a, bkey)
if pos is not None:
akey = pos[1]
raise AssemblyError(
"Cannot merge duplicate mapping key '%s' at" %
bkey.value, bkey.start_mark,
"into existing mapping at", akey.start_mark)
# Extend the existing mapping
node = MappingNode(a.tag, a.value + b.value)
else:
raise RuntimeError("Unable to handle node of type %s" %
type(a).__name__)
return node
def test_construct_map_duplicate(self):
mark = Mark(None, None, 8, 8, None, None)
children = [
(
ScalarNode("tag:yaml.org,2002:str", "node1", start_mark=mark),
ScalarNode("tag:yaml.org,2002:str", "node1", start_mark=mark),
),
(
ScalarNode("tag:yaml.org,2002:str", "node1", start_mark=mark),
ScalarNode("tag:yaml.org,2002:str", "node1", start_mark=mark),
)
]
node = MappingNode("tag:yaml.org,2002:map", children, start_mark=mark)
with pytest.raises(ConstructorError):
res, = Constructor("map").construct_yaml_map(node)
def represent_omap(dumper, mapping, flow_style=None):
value = []
tag = 'tag:yaml.org,2002:omap'
node = SequenceNode(tag, value, flow_style=flow_style)
if dumper.alias_key is not None:
dumper.represented_objects[dumper.alias_key] = node
best_style = True
for item_key, item_value in mapping.items():
node_key = dumper.represent_data(item_key)
node_value = dumper.represent_data(item_value)
subnode = MappingNode('tag:yaml.org,2002:map', [ ( node_key,node_value ) ])
value.append(subnode)
node.flow_style = True
return node
def test_construct_map(self):
mark = Mark(None, None, 8, 8, None, None)
children = [(
ScalarNode("tag:yaml.org,2002:str", str(i), start_mark=mark),
ScalarNode("tag:yaml.org,2002:int", str(i), start_mark=mark),
) for i in range(2)]
node = MappingNode(None, children, start_mark=mark)
res, = Constructor("map").construct_yaml_map(node)
assert {
"0": 0,
"1": 1
} == {k.value: v.value
for k, v in res.value.items()}
assert res.loc.line == 9
assert res.loc.column == 9
assert res.loc.stream_name == "map"
def filector(basector, node):
if len(node.value) > 1 and len(
node.value[1]) and node.value[1][0].value == 'addresses':
games = defaultctor(
basector,
SequenceNode(yaml.resolver.BaseResolver.DEFAULT_SEQUENCE_TAG,
[node.value[0][1]]))
d = dict()
for value in MappingNode(
yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG,
node.value[1][1].value).value:
result = AliasData(defaultctor(basector, value[0]))
nextnode = value[1]
if isinstance(nextnode, ScalarNode):
result.setvalue('*', nextnode.value)
else:
for v in nextnode.value:
result.setvalue(defaultctor(basector, v[0]),
defaultctor(basector, v[1]))
d[result.alias] = result
return AliasList(games[0], d)
return defaultctor(basector, node)
