>>> b = Bunch(foo=['bar', Bunch(lol=True)], hello=42)
>>> import yaml
>>> yaml.dump(b, default_flow_style=True)
'!bunch.Bunch {foo: [bar, !bunch.Bunch {lol: true}], hello: 42}\\n'
"""
return dumper.represent_mapping('!bunch.Bunch', data)
yaml.add_constructor('!bunch', from_yaml)
yaml.add_constructor('!bunch.Bunch', from_yaml)
SafeRepresenter.add_representer(Bunch, to_yaml_safe)
SafeRepresenter.add_multi_representer(Bunch, to_yaml_safe)
Representer.add_representer(Bunch, to_yaml)
Representer.add_multi_representer(Bunch, to_yaml)
# Instance methods for YAML conversion
def toYAML(self, **options):
""" Serializes this Bunch to YAML, using `yaml.safe_dump()` if
no `Dumper` is provided. See the PyYAML documentation for more info.
>>> b = Bunch(foo=['bar', Bunch(lol=True)], hello=42)
>>> import yaml
>>> yaml.safe_dump(b, default_flow_style=True)
'{foo: [bar, {lol: true}], hello: 42}\\n'
>>> b.toYAML(default_flow_style=True)
'{foo: [bar, {lol: true}], hello: 42}\\n'
>>> yaml.dump(b, default_flow_style=True)
'!bunch.Bunch {foo: [bar, !bunch.Bunch {lol: true}], hello: 42}\\n'
>>> b.toYAML(Dumper=yaml.Dumper, default_flow_style=True)
>>> b = OrderedBunch(foo=['bar', OrderedBunch(lol=True)], hello=42)
>>> import yaml
>>> yaml.dump(b, default_flow_style=True)
'!bunch.OrderedBunch {foo: [bar, !bunch.OrderedBunch {lol: true}], hello: 42}\\n'
"""
return dumper.represent_mapping(u'!orderedbunch.OrderedBunch', data)
yaml.add_constructor(u'!orderedbunch', from_yaml)
yaml.add_constructor(u'!orderedbunch.OrderedBunch', from_yaml)
SafeRepresenter.add_representer(OrderedBunch, to_yaml_safe)
SafeRepresenter.add_multi_representer(OrderedBunch, to_yaml_safe)
Representer.add_representer(OrderedBunch, to_yaml)
Representer.add_multi_representer(OrderedBunch, to_yaml)
# Instance methods for YAML conversion
def toYAML(self, **options):
""" Serializes this OrderedBunch to YAML, using `yaml.safe_dump()` if
no `Dumper` is provided. See the PyYAML documentation for more info.
>>> b = OrderedBunch(foo=['bar', OrderedBunch(lol=True)], hello=42)
>>> import yaml
>>> yaml.safe_dump(b, default_flow_style=True)
'{foo: [bar, {lol: true}], hello: 42}\\n'
>>> b.toYAML(default_flow_style=True)
'{foo: [bar, {lol: true}], hello: 42}\\n'
>>> yaml.dump(b, default_flow_style=True)
'!bunch.OrderedBunch {foo: [bar, !bunch.OrderedBunch {lol: true}], hello: 42}\\n'
>>> b.toYAML(Dumper=yaml.Dumper, default_flow_style=True)
>>> b = OrderedBunch(foo=['bar', OrderedBunch(lol=True)], hello=42)
>>> import yaml
>>> yaml.dump(b, default_flow_style=True)
'!bunch.OrderedBunch {foo: [bar, !bunch.OrderedBunch {lol: true}], hello: 42}\\n'
"""
return dumper.represent_mapping(u'!orderedbunch.OrderedBunch', data)
yaml.add_constructor(u'!orderedbunch', from_yaml)
yaml.add_constructor(u'!orderedbunch.OrderedBunch', from_yaml)
SafeRepresenter.add_representer(OrderedBunch, to_yaml_safe)
SafeRepresenter.add_multi_representer(OrderedBunch, to_yaml_safe)
Representer.add_representer(OrderedBunch, to_yaml)
Representer.add_multi_representer(OrderedBunch, to_yaml)
# Instance methods for YAML conversion
def toYAML(self, **options):
""" Serializes this OrderedBunch to YAML, using `yaml.safe_dump()` if
no `Dumper` is provided. See the PyYAML documentation for more info.
>>> b = OrderedBunch(foo=['bar', OrderedBunch(lol=True)], hello=42)
>>> import yaml
>>> yaml.safe_dump(b, default_flow_style=True)
'{foo: [bar, {lol: true}], hello: 42}\\n'
>>> b.toYAML(default_flow_style=True)
'{foo: [bar, {lol: true}], hello: 42}\\n'
>>> yaml.dump(b, default_flow_style=True)
'!bunch.OrderedBunch {foo: [bar, !bunch.OrderedBunch {lol: true}], hello: 42}\\n'
>>> b = Munch(foo=['bar', Munch(lol=True)], hello=42)
>>> import yaml
>>> yaml.dump(b, default_flow_style=True)
'!munch.Munch {foo: [bar, !munch.Munch {lol: true}], hello: 42}\\n'
"""
return dumper.represent_mapping(u('!munch.Munch'), data)
yaml.add_constructor(u('!munch'), from_yaml)
yaml.add_constructor(u('!munch.Munch'), from_yaml)
SafeRepresenter.add_representer(Munch, to_yaml_safe)
SafeRepresenter.add_multi_representer(Munch, to_yaml_safe)
Representer.add_representer(Munch, to_yaml)
Representer.add_multi_representer(Munch, to_yaml)
# Instance methods for YAML conversion
def toYAML(self, **options):
""" Serializes this Munch to YAML, using `yaml.safe_dump()` if
no `Dumper` is provided. See the PyYAML documentation for more info.
>>> b = Munch(foo=['bar', Munch(lol=True)], hello=42)
>>> import yaml
>>> yaml.safe_dump(b, default_flow_style=True)
'{foo: [bar, {lol: true}], hello: 42}\\n'
>>> b.toYAML(default_flow_style=True)
'{foo: [bar, {lol: true}], hello: 42}\\n'
>>> yaml.dump(b, default_flow_style=True)
'!munch.Munch {foo: [bar, !munch.Munch {lol: true}], hello: 42}\\n'
>>> b.toYAML(Dumper=yaml.Dumper, default_flow_style=True)
if kw: records += (kw,)
# SafeDumper will not emit python/foo tags for unicode or objects
return yaml.safe_dump_all(records, **DEFAULT_OPTIONS)
def write_yaml(*records, **options):
options = merge({}, DEFAULT_OPTIONS, options)
return yaml.safe_dump_all(records, **options)
from path import path
from yaml.representer import Representer, SafeRepresenter
SafeRepresenter.add_representer(path, SafeRepresenter.represent_unicode)
SafeRepresenter.add_multi_representer(path, SafeRepresenter.represent_unicode)
Representer.add_representer(path, Representer.represent_unicode)
Representer.add_multi_representer(path, Representer.represent_unicode)
import types
from yaml import Dumper, SafeDumper
class PPDumper(SafeDumper, Dumper):
pass
# PPDumper.add_representer(unicode, SafeDumper.represent_unicode)
# PPDumper.add_representer(types.ClassType, Dumper.represent_name)
# PPDumper.add_representer(types.FunctionType, Dumper.represent_name)
# PPDumper.add_representer(types.BuiltinFunctionType, Dumper.represent_name)
# PPDumper.add_representer(types.ModuleType, Dumper.represent_module)
# PPDumper.add_multi_representer(types.InstanceType, Dumper.represent_instance)
# PPDumper.add_multi_representer(object, Dumper.represent_object)
def dict_dump(self):
return unstitch(self)
def from_yaml(loader, node):
data = Threads()
yield data
value = loader.construct_mapping(node)
data.update(value)
def to_yaml(dumper, data):
return dumper.represent_mapping(six.u('!threads.Threads'), data)
def to_yaml_safe(dumper, data):
return dumper.represent_dict(data)
yaml.add_constructor(six.u('!threads'), from_yaml)
yaml.add_constructor(six.u('!threads.Threads'), from_yaml)
Representer.add_representer(Threads, to_yaml)
Representer.add_multi_representer(Threads, to_yaml)
SafeRepresenter.add_representer(Threads, to_yaml_safe)
SafeRepresenter.add_multi_representer(Threads, to_yaml_safe)
items = Threads(a=0, b=1, c=[0, 2], d=Threads(x=0, y=1, z=2))
print items.yaml_dump()
raise ConstructorError(
'while constructing a mapping', node.start_mark,
'found unacceptable key (%s)' % exc, key_node.start_mark)
attrdict[key] = loader.construct_object(value_node, deep=False)
class AttrDictYAMLLoader(Loader):
'''A YAML loader that loads mappings into ordered AttrDict.
>>> attrdict = yaml.load('x: 1\ny: 2', Loader=AttrDictYAMLLoader)
'''
def __init__(self, *args, **kwargs):
super(AttrDictYAMLLoader, self).__init__(*args, **kwargs)
self.add_constructor(u'tag:yaml.org,2002:map', from_yaml)
self.add_constructor(u'tag:yaml.org,2002:omap', from_yaml)
def to_yaml(dumper, data):
'Convert AttrDict to dictionary, preserving order'
# yaml.representer.BaseRepresenter.represent_mapping sorts keys if the
# object has .items(). So instead, pass the items directly.
return dumper.represent_mapping(u'tag:yaml.org,2002:map', data.items())
SafeRepresenter.add_representer(AttrDict, to_yaml)
SafeRepresenter.add_multi_representer(AttrDict, to_yaml)
Representer.add_representer(AttrDict, to_yaml)
Representer.add_multi_representer(AttrDict, to_yaml)
>>> b = Chunk(foo=['bar', Chunk(lol=True)], hello=42)
>>> import yaml
>>> yaml.dump(b, default_flow_style=True)
'!chunk.Chunk {foo: [bar, !chunk.Chunk {lol: true}], hello: 42}\\n'
"""
return dumper.represent_mapping(u('!chunk.Chunk'), data)
yaml.add_constructor(u('!chunk'), from_yaml)
yaml.add_constructor(u('!chunk.Chunk'), from_yaml)
SafeRepresenter.add_representer(Chunk, to_yaml_safe)
SafeRepresenter.add_multi_representer(Chunk, to_yaml_safe)
Representer.add_representer(Chunk, to_yaml)
Representer.add_multi_representer(Chunk, to_yaml)
# Instance methods for YAML conversion
def toYAML(self, **options):
""" Serializes this Chunk to YAML, using `yaml.safe_dump()` if
no `Dumper` is provided. See the PyYAML documentation for more info.
>>> b = Chunk(foo=['bar', Chunk(lol=True)], hello=42)
>>> import yaml
>>> yaml.safe_dump(b, default_flow_style=True)
'{foo: [bar, {lol: true}], hello: 42}\\n'
>>> b.toYAML(default_flow_style=True)
'{foo: [bar, {lol: true}], hello: 42}\\n'
>>> yaml.dump(b, default_flow_style=True)
'!chunk.Chunk {foo: [bar, !chunk.Chunk {lol: true}], hello: 42}\\n'
>>> b.toYAML(Dumper=yaml.Dumper, default_flow_style=True)
version=version, tags=tags)
Representer.__init__(self, default_style=default_style,
default_flow_style=default_flow_style, sort_keys=sort_keys)
Resolver.__init__(self)
def represent_unity_class(dumper, instance):
data = {instance.__class__.__name__: instance.get_serialized_properties_dict()}
node = dumper.represent_mapping('{}{}'.format(UNITY_TAG_URI, instance.__class_id), data, False)
# UNITY: set MappingNode anchor and all set all it's descendants anchors to None
dumper.anchors[node] = instance.anchor
dumper.extra_anchor_data[instance.anchor] = instance.extra_anchor_data
for key, value in node.value:
dumper.anchor_node(key)
dumper.anchor_node(value)
return node
def represent_ordered_flow_dict(dumper, instance):
return dumper.represent_mapping(Resolver.DEFAULT_MAPPING_TAG, instance.items(),
flow_style=instance.get_flow_style())
def represent_none(dumper, instance):
return dumper.represent_scalar('tag:yaml.org,2002:null', '')
Representer.add_multi_representer(UnityClass, represent_unity_class)
Representer.add_representer(OrderedFlowDict, represent_ordered_flow_dict)
Representer.add_representer(type(None), represent_none)
raise ConstructorError('while constructing a mapping',
node.start_mark,
'found unacceptable key (%s)' % exc,
key_node.start_mark)
attrdict[key] = loader.construct_object(value_node, deep=False)
class AttrDictYAMLLoader(Loader):
'''A YAML loader that loads mappings into ordered AttrDict.
>>> attrdict = yaml.load('x: 1\ny: 2', Loader=AttrDictYAMLLoader)
'''
def __init__(self, *args, **kwargs):
super(AttrDictYAMLLoader, self).__init__(*args, **kwargs)
self.add_constructor(u'tag:yaml.org,2002:map', from_yaml)
self.add_constructor(u'tag:yaml.org,2002:omap', from_yaml)
def to_yaml(dumper, data):
'Convert AttrDict to dictionary, preserving order'
# yaml.representer.BaseRepresenter.represent_mapping sorts keys if the
# object has .items(). So instead, pass the items directly.
return dumper.represent_mapping(u'tag:yaml.org,2002:map', data.items())
SafeRepresenter.add_representer(AttrDict, to_yaml)
SafeRepresenter.add_multi_representer(AttrDict, to_yaml)
Representer.add_representer(AttrDict, to_yaml)
Representer.add_multi_representer(AttrDict, to_yaml)
def dict_dump(self):
return unstitch(self)
def from_yaml(loader, node):
data = Threads()
yield data
value = loader.construct_mapping(node)
data.update(value)
def to_yaml(dumper, data):
return dumper.represent_mapping(six.u('!threads.Threads'), data)
def to_yaml_safe(dumper, data):
return dumper.represent_dict(data)
yaml.add_constructor(six.u('!threads'), from_yaml)
yaml.add_constructor(six.u('!threads.Threads'), from_yaml)
Representer.add_representer(Threads, to_yaml)
Representer.add_multi_representer(Threads, to_yaml)
SafeRepresenter.add_representer(Threads, to_yaml_safe)
SafeRepresenter.add_multi_representer(Threads, to_yaml_safe)
items = Threads(a=0, b=1, c=[0, 2], d=Threads(x=0, y=1, z=2))
print items.yaml_dump()
