>>> 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)