def representTextStruct(dumper, data):
dataList = [
#(stringNode('index'), stringNode('0x' + myhex(data.index, 4))),
]
if len(data.indices) != 1:
extraIndexList = data.indices
assert (extraIndexList == sorted(extraIndexList))
nameList = [stringNode(getTextName(x)) for x in extraIndexList]
dataList.append((stringNode('name'),
yaml.SequenceNode('tag:yaml.org,2002:seq',
nameList)))
extraIndexList = [
intNode('0x' + myhex(x & 0xff, 2)) for x in extraIndexList
]
dataList.append((stringNode('index'),
yaml.SequenceNode('tag:yaml.org,2002:seq',
extraIndexList)))
else:
assert (data.indices[0] == data.index)
dataList.append(stringMap('name', data.name))
dataList.append((stringNode('index'),
intNode('0x' + myhex(data.index & 0xff, 2))))
dataList.append((stringNode('text'),
dumper.represent_scalar(stringTag, data.textData,
'|')))
if not data.hasNullTerminator:
dataList.append((stringNode('null_terminator'),
boolNode(data.hasNullTerminator)))
return yaml.MappingNode('tag:yaml.org,2002:map', dataList)
def get_representation(self, value, v_type):
''''''
if v_type.startswith("dict"):
return self.represent_dict(value)
elif v_type.startswith('list'):
if 'ExtraPath' in v_type:
# Represent this as a list of lists of quoted strings (each on one line).
paths = []
for path in list(value):
# Force the regular expressions to be quoted, so we don't have any issues with that.
pathnodes = [
self.represent_scalar(u'tag:yaml.org,2002:str',
x,
style="'") for x in path
]
paths.append(
yaml.SequenceNode(u'tag:yaml.org,2002:seq',
pathnodes,
flow_style=True))
return yaml.SequenceNode(u'tag:yaml.org,2002:seq',
paths,
flow_style=False)
elif 'class' in v_type:
# The "class" in this context is either a class reference or
# a class name (string) that refers to a class defined in
# this ZenPackSpec.
classes = [
isinstance(x, type) and self.class_to_str(x) or x
for x in value
]
return self.represent_list(classes)
else:
return self.represent_list(value)
else:
m = re.match('^SpecsParameter\((.*)\)$', v_type)
if m:
spectype = m.group(1)
specmapping = OrderedDict()
defaults = value.get('DEFAULTS', None)
if defaults:
value.pop('DEFAULTS')
for key, spec in value.items():
if type(spec).__name__ != spectype:
raise yaml.representer.RepresenterError(
"Unable to serialize {} object ({}): Expected an object of type {}"
.format(type(spec).__name__, key, spectype))
else:
specmapping[self.represent_str(
key)] = self.represent_spec(spec,
defaults=defaults)
return self.dict_representer(specmapping)
else:
self.LOG.debug("Using represent_data for {} ({})".format(
value, v_type))
return self.represent_data(value)
return None
def _repr_pairs(dump, tag, sequence, flow_style=None):
"""
This is the same code as BaseRepresenter.represent_sequence(),
but the value passed to dump.represent_data() in the loop is a
dictionary instead of a tuple.
Source: https://gist.github.com/weaver/317164
License: Unspecified
"""
import yaml
value = []
node = yaml.SequenceNode(tag, value, flow_style=flow_style)
if dump.alias_key is not None:
dump.represented_objects[dump.alias_key] = node
best_style = True
for (key, val) in sequence:
item = dump.represent_data({key: val})
if not (isinstance(item, yaml.ScalarNode) and not item.style):
best_style = False
value.append(item)
if flow_style is None:
if dump.default_flow_style is not None:
node.flow_style = dump.default_flow_style
else:
node.flow_style = best_style
return node
def aws_cloudformation_intrinsic_function(loader, node):
fn = f"Fn::{node.tag[1:]}"
if node.tag in ('!Ref', '!Condition'):
fn = 'Ref'
elif node.tag == '!GetAtt' and isinstance(node.value, str):
path = node.value.split(".", maxsplit=2)
node = yaml.SequenceNode(tag="tag:yaml.org,2002:seq",
value=[str_node(p) for p in path])
sub_node: yaml.Node
if isinstance(node, yaml.SequenceNode):
sub_node = seq_node(node.value)
elif isinstance(node, yaml.MappingNode):
sub_node = map_node(node.value)
elif node.value is None:
sub_node = yaml.ScalarNode('tag:yaml.org,2002:null', node.value)
elif isinstance(node.value, str):
sub_node = yaml.ScalarNode('tag:yaml.org,2002:str', node.value)
elif isinstance(node.value, bool):
sub_node = yaml.ScalarNode('tag:yaml.org,2002:bool', node.value)
elif isinstance(node.value, int):
sub_node = yaml.ScalarNode('tag:yaml.org,2002:int', node.value)
elif isinstance(node.value, float):
sub_node = yaml.ScalarNode('tag:yaml.org,2002:float', node.value)
else:
raise ValueError(node)
new_node = map_node([(str_node(fn), sub_node)])
return loader.construct_object(new_node)
def format_node(cls, mapping, metric):
if mapping.tag in [
'tag:yaml.org,2002:str', Bytes2Kibibytes.yaml_tag,
Number.yaml_tag, StripExtraDash.yaml_tag
]:
return yaml.ScalarNode(mapping.tag, mapping.value.format(**metric))
elif mapping.tag == 'tag:yaml.org,2002:map':
values = []
for key, value in mapping.value:
values.append((yaml.ScalarNode(key.tag, key.value),
cls.format_node(value, metric)))
return yaml.MappingNode(mapping.tag, values)
elif mapping.tag in [ArrayItem.yaml_tag, ValueItem.yaml_tag]:
values = []
for seq in mapping.value:
map_values = list()
for key, value in seq.value:
if key.value == 'SELECT':
map_values.append((yaml.ScalarNode(key.tag, key.value),
cls.format_node(value, metric)))
else:
map_values.append((yaml.ScalarNode(key.tag,
key.value), value))
values.append(yaml.MappingNode(seq.tag, map_values))
return yaml.SequenceNode(mapping.tag, values)
elif mapping.tag in [MapValue.yaml_tag]:
values = []
for key, value in mapping.value:
if key.value == 'VALUE':
values.append((yaml.ScalarNode(key.tag, key.value),
cls.format_node(value, metric)))
else:
values.append((yaml.ScalarNode(key.tag, key.value), value))
return yaml.MappingNode(mapping.tag, values)
return mapping
def _node(self):
"""
Create a yaml node object.
"""
node = yaml.SequenceNode(
tag='tag:yaml.org,2002:seq',
value=[
yaml.ScalarNode(tag='tag:yaml.org,2002:str', value='a'),
yaml.ScalarNode(tag='tag:yaml.org,2002:str', value='b'),
yaml.ScalarNode(tag='tag:yaml.org,2002:str', value='c'),
])
return node
def represent_ordereddict(dumper, data):
# TODO: Again, adjust for preferred flow style, and other stylistic details
# NOTE: For block style this uses the compact omap notation, but for flow style
# it does not.
values = []
node = yaml.SequenceNode(u'tag:yaml.org,2002:seq', values, flow_style=True)
if dumper.alias_key is not None:
dumper.represented_objects[dumper.alias_key] = node
for key, value in data.items():
key_item = dumper.represent_data(key)
value_item = dumper.represent_data(value)
node_item = yaml.MappingNode(u'tag:yaml.org,2002:map', [(key_item, value_item)],
flow_style=False)
values.append(node_item)
return node
def represent_ordered_mapping(dumper, tag, data):
# TODO: Again, adjust for preferred flow style, and other stylistic details
# NOTE: For block style this uses the compact omap notation, but for flow style
# it does not.
# TODO: Need to see if I can figure out a mechanism so that classes that
# use this representer can specify which values should use flow style
values = []
node = yaml.SequenceNode(tag, values, flow_style=dumper.default_flow_style)
if dumper.alias_key is not None:
dumper.represented_objects[dumper.alias_key] = node
for key, value in data.items():
key_item = dumper.represent_data(key)
value_item = dumper.represent_data(value)
node_item = yaml.MappingNode(YAML_OMAP_TAG, [(key_item, value_item)],
flow_style=False)
values.append(node_item)
return node
def seq_node(value) -> yaml.SequenceNode:
return yaml.SequenceNode(tag="tag:yaml.org,2002:seq", value=value)
