def __init__(self,
stream,
default_style=None,
default_flow_style=None,
canonical=None,
indent=None,
width=None,
allow_unicode=None,
line_break=None,
encoding=None,
explicit_start=None,
explicit_end=None,
version=None,
tags=None,
sort_keys=False,
**kwargs):
IndentingEmitter.__init__(self,
stream,
canonical=canonical,
indent=indent,
width=width,
allow_unicode=allow_unicode,
line_break=line_break)
Serializer.__init__(self,
encoding=encoding,
explicit_start=explicit_start,
explicit_end=explicit_end,
version=version,
tags=tags)
SafeRepresenter.__init__(self,
default_style=default_style,
default_flow_style=default_flow_style)
Resolver.__init__(self)
def __write_state_file(self, address, data_center, environment):
host = parse_hostname(address)
state_path = os.path.join(STATE_PATH, self.team, self.project, host)
if not os.path.exists(state_path):
os.makedirs(state_path)
state_file = os.path.join(state_path, "{0}.yml".format(os.getpid()))
if os.path.isfile(state_file):
raise RuntimeError("Unable to run freight forwarder pid already in use.")
else:
# TODO: move to a yaml util
def config_unicode_presenter(dumper, data):
return dumper.represent_scalar('tag:yaml.org,2002:str', data)
SafeRepresenter.add_representer(ConfigUnicode, config_unicode_presenter)
with open(state_file, 'w') as f:
f.write(
yaml.safe_dump(
{
"team": self.team,
"project": self.project,
"environment": environment,
"data_center": data_center,
"host": host,
"pid": os.getpid()
}
)
)
def __write_state_file(self, address, data_center, environment):
host = parse_hostname(address)
state_path = os.path.join(STATE_PATH, self.team, self.project, host)
if not os.path.exists(state_path):
os.makedirs(state_path)
state_file = os.path.join(state_path, "{0}.yml".format(os.getpid()))
if os.path.isfile(state_file):
raise RuntimeError(
"Unable to run freight forwarder pid already in use.")
else:
# TODO: move to a yaml util
def config_unicode_presenter(dumper, data):
return dumper.represent_scalar('tag:yaml.org,2002:str', data)
SafeRepresenter.add_representer(ConfigUnicode,
config_unicode_presenter)
with open(state_file, 'w') as f:
f.write(
yaml.safe_dump({
"team": self.team,
"project": self.project,
"environment": environment,
"data_center": data_center,
"host": host,
"pid": os.getpid()
}))
def _represent_str(cls, dumper, orig_data):
try:
data = unicode(orig_data, 'ascii')
if data.count('\n') == 0:
return SafeRepresenter.represent_str(dumper, orig_data)
except UnicodeDecodeError:
try:
data = unicode(orig_data, 'utf-8')
if data.count('\n') == 0:
return SafeRepresenter.represent_str(dumper, orig_data)
except UnicodeDecodeError:
return SafeRepresenter.represent_str(dumper, orig_data)
return dumper.represent_scalar(u'tag:yaml.org,2002:str',
data, style='|')
def represent_data(self, data):
"""
This is very hackish. There is for sure a better way either by using
the add_multi_representer or add_representer, the issue though lies in
the fact that Scapy packets are metaclasses that leads to
yaml.representer.get_classobj_bases to not be able to properly get the
base of class of a Scapy packet.
XXX fully debug this problem
"""
if isinstance(data, Packet):
data = createPacketReport(data)
return SafeRepresenter.represent_data(self, data)
def represent_data(self, data):
"""
This is very hackish. There is for sure a better way either by using
the add_multi_representer or add_representer, the issue though lies in
the fact that Scapy packets are metaclasses that leads to
yaml.representer.get_classobj_bases to not be able to properly get the
base of class of a Scapy packet.
XXX fully debug this problem
"""
if isinstance(data, Packet):
data = createPacketReport(data)
return SafeRepresenter.represent_data(self, data)
def to_yaml(dumper, data):
""" Converts OrderedBunch to a representation node.
>>> 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'
# 'explicit_start' : True,
}
def toyaml(*records, **kw):
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)
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)
# Setup to use freezegun with pyyaml
from freezegun.api import FakeDatetime
from yaml.representer import SafeRepresenter
SafeRepresenter.add_representer(FakeDatetime,
SafeRepresenter.represent_datetime)
self.x_attr_dict = kwargs.pop('x_attr_dict', {})
super().__init__(*args, **kwargs)
def ignore_aliases(self, data):
if isinstance(data, int): # py2 vs future int
return True
class XLoader(yaml.Loader):
def __init__(self, *args, **kwargs):
self.x_attr_dict = kwargs.pop('x_attr_dict', {})
super().__init__(*args, **kwargs)
if PY2:
XDumper.add_representer(
int,
lambda dumper, data: SafeRepresenter.represent_int(
dumper, native(data)))
XDumper.add_representer(
dict,
lambda dumper, data: SafeRepresenter.represent_dict(
dumper, native(data)))
for kl in [DolfinMeshTag, DolfinFunctionTag,
DolfinMeshFunctionSizetTag,
DolfinMeshFunctionIntTag,
DolfinMeshFunctionDoubleTag,
DolfinMeshFunctionBoolTag,
FrozenSetTag, PintQTag]:
kl.register_in_dumper(XDumper)
kl.register_in_loader(XLoader)
def _load(stream, Loader=None, x_attr_dict=None,
for item in result[c.name]:
if isinstance(item, SAModelMixin):
item = copy(item)
item._embedded_as = c
l.append(item)
result[c.name] = l
return result
@staticmethod
def yaml_safe_representer(dumper, data):
return dumper.represent_mapping(
u'tag:yaml.org,2002:map', data.as_dict().items(), flow_style=False)
try:
from yaml.representer import SafeRepresenter
SafeRepresenter.add_multi_representer(
SAModelMixin, SAModelMixin.yaml_safe_representer)
del SafeRepresenter
except ImportError: # pragma: no cover
pass
def hasUserMixin(owner_id_field):
"""
Quite specific helper, that was made to ease working with permissions
for models referencing Django-like user objects.
"""
class HasUserMixin(object):
@classmethod
def check_class_permissions(cls, user=None):
if user is None and hasattr(g, "user"):
user = g.user
#!/usr/bin/env python3
import sys
import yaml
import datetime
import fvm
import fvol
from collections import defaultdict
from yaml.representer import SafeRepresenter
# to serialize defaultdicts normally
SafeRepresenter.add_representer(defaultdict, SafeRepresenter.represent_dict)
arguments = yaml.safe_load(sys.stdin)
vm_ids = list(arguments.get('instances', {}).keys())
def multidict():
return defaultdict(multidict)
vm_infos = {}
for vmid in vm_ids:
vm = fvm.load(vmid)
if vm:
status = {
'flags': {
'active': True,
'converging': False,
'failed': bool(vm.model.get('failure'))
def timestamp_representer(dumper, data):
return SafeRepresenter.represent_datetime(dumper, data.to_pydatetime())
>>> 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)
for loader_name in ("BaseLoader", "FullLoader", "SafeLoader", "Loader", "UnsafeLoader", "DangerLoader"):
LoaderCls = getattr(yaml, loader_name, None)
if LoaderCls is None:
# This code supports both PyYAML 4.x and 5.x versions
continue
yaml.add_constructor(u('!munch'), from_yaml, Loader=LoaderCls)
yaml.add_constructor(u('!munch.Munch'), from_yaml, Loader=LoaderCls)
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)
best_style = True
if self.alias_key is not None:
self.represented_objects[self.alias_key] = node
if hasattr(mapping, 'items'):
mapping = list(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, yaml.ScalarNode) and not node_key.style):
best_style = False
if not (isinstance(node_value, yaml.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
BaseRepresenter.represent_mapping = represent_ordered_mapping
SafeRepresenter.add_representer(OrderedDict, SafeRepresenter.represent_dict)
Representer.add_representer(OrderedDict, SafeRepresenter.represent_dict)
yaml.add_representer(OrderedDict, SafeRepresenter.represent_dict)
LOGGER = logging.getLogger('cekit')
class Map(dict):
"""
Class to enable access via properties to dictionaries.
"""
__getattr__ = dict.get
__setattr__ = dict.__setitem__
__delattr__ = dict.__delitem__
# Make sure YAML can understand how to represent the Map object
SafeRepresenter.add_representer(Map, SafeRepresenter.represent_dict)
def load_descriptor(descriptor):
""" parses descriptor and validate it against requested schema type
Args:
descriptor - yaml descriptor or path to a descriptor to be loaded.
If a path is provided it must be an absolute path. In other case it's
assumed that it is a yaml descriptor.
Returns descriptor as a dictionary
"""
try:
data = yaml.safe_load(descriptor)
def bytes_representer(dumper: SafeRepresenter, data: bytes) -> ScalarNode:
return dumper.represent_str(data.decode("UTF-8"))
"""
A docker composition.
"""
from collections import OrderedDict
from yaml import dump, load
from yaml.representer import SafeRepresenter
try:
from yaml import CSafeDumper as SafeDumper, CSafeLoader as SafeLoader
except ImportError:
from yaml import SafeDumper, SafeLoader
finally:
# Register OrderedDict to dump like a regular dict
SafeRepresenter.add_representer(OrderedDict,
SafeRepresenter.represent_dict)
from docker_etude.models.base import Model
from docker_etude.models.network import Network
from docker_etude.models.service import Service
from docker_etude.models.volume import Volume
class Composition(Model):
"""
The top-level model for a docker composition.
Maps to/from a docker-compose.yml file.
"""
def __init__(self,
networks=None,
def _represent_unicode(cls, dumper, data):
if data.count('\n') == 0:
return SafeRepresenter.represent_unicode(dumper, data)
return dumper.represent_scalar(u'tag:yaml.org,2002:str',
data, style='|')
return dumper.represent_dict(data)
def to_yaml(dumper, data):
""" Converts Chunk to a representation node.
>>> 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)
import testtools
import fixtures
from acceptable import __main__ as main
from acceptable import get_metadata
from acceptable.tests._fixtures import (
CleanUpModuleImport,
TemporaryModuleFixture,
)
if PY2:
# teach yaml about future's newlist and newdict py3 backports
from future.types.newlist import newlist
from future.types.newdict import newdict
SafeRepresenter.add_representer(newlist, SafeRepresenter.represent_list)
SafeRepresenter.add_representer(newdict, SafeRepresenter.represent_dict)
# sys.exit on error, but rather throws an exception, so we can catch that in
# our tests:
class SaneArgumentParser(argparse.ArgumentParser):
def error(self, message):
raise RuntimeError(message)
class ParseArgsTests(testtools.TestCase):
def test_error_with_no_args(self):
self.assertRaisesRegex(
RuntimeError,
'arguments are required' if not PY2 else 'too few arguments',
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)
"""Parse header of text notebooks
"""
import re
import yaml
from yaml.representer import SafeRepresenter
import nbformat
from nbformat.v4.nbbase import new_raw_cell
from .version import __version__
from .languages import _SCRIPT_EXTENSIONS, comment_lines
from .metadata_filter import filter_metadata, _DEFAULT_NOTEBOOK_METADATA
from .pep8 import pep8_lines_between_cells
SafeRepresenter.add_representer(nbformat.NotebookNode,
SafeRepresenter.represent_dict)
_HEADER_RE = re.compile(r"^---\s*$")
_BLANK_RE = re.compile(r"^\s*$")
_JUPYTER_RE = re.compile(r"^jupyter\s*:\s*$")
_LEFTSPACE_RE = re.compile(r"^\s")
_UTF8_HEADER = " -*- coding: utf-8 -*-"
# Change this to False in tests
INSERT_AND_CHECK_VERSION_NUMBER = True
def insert_or_test_version_number():
"""Should the format name and version number be inserted in text
representations (not in tests!)"""
return INSERT_AND_CHECK_VERSION_NUMBER
def represent_literal_str(self, data):
node = SafeRepresenter.represent_str(self, data)
if '\n' in data:
node.style = '|'
return node
res[k] = combine_dict(*v, cls=cls)
return res
class attrdict(dict):
"""A dictionary which can be accessed via attributes, for convenience"""
def __getattr__(self, a):
if a.startswith("_"):
return object.__getattr__(self, a)
try:
return self[a]
except KeyError:
raise AttributeError(a) from None
def __setattr__(self, a, b):
if a.startswith("_"):
super(attrdict, self).__setattr__(a, b)
else:
self[a] = b
def __delattr__(self, a):
try:
del self[a]
except KeyError:
raise AttributeError(a) from None
from yaml.representer import SafeRepresenter
SafeRepresenter.add_representer(attrdict, SafeRepresenter.represent_dict)
def _represent_hasstr(obj, value: HasStr):
from yaml.representer import SafeRepresenter
return SafeRepresenter.represent_str(obj, str(value))
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()
def _represent_enum(obj, value: Enum):
from yaml.representer import SafeRepresenter
return SafeRepresenter.represent_str(obj, value.value)
return dumper.represent_dict(data)
def to_yaml(dumper, data):
""" Converts Munch to a representation node.
>>> 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)
def _represent_uuid(obj, value: UUID):
from yaml.representer import SafeRepresenter
return SafeRepresenter.represent_str(obj, str(value))
return dumper.represent_dict(data)
def to_yaml(dumper, data):
""" Converts OrderedBunch to a representation node.
>>> 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)
def watermark_representer(dumper: SafeRepresenter,
data: Watermark) -> SequenceNode:
return dumper.represent_list(list(data))
__author__ = "Yuan Chang"
__copyright__ = "Copyright (C) 2016-2021"
__license__ = "AGPL"
__email__ = "*****@*****.**"
from re import sub
from numpy import float64
from yaml import safe_load, safe_dump
from yaml.error import YAMLError
from yaml.representer import SafeRepresenter
from qtpy.QtWidgets import QMessageBox
from .format_editor import FormatEditor, ProjectFormat
# Add a patch for numpy numbers
SafeRepresenter.add_representer(float64, SafeRepresenter.represent_float)
class YamlEditor(FormatEditor):
"""YAML reader and writer."""
def __init__(self, *args):
super(YamlEditor, self).__init__(*args)
@staticmethod
def test(file_name: str) -> bool:
"""Test the file is valid."""
with open(file_name, 'r', encoding='utf-8') as f:
try:
yaml_script = f.read()
safe_load(yaml_script)
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()
