def add_constructor(tag,
object_constructor,
Loader=None,
constructor=Constructor):
# type: (Any, Any, Any, Any) -> None
"""
Add an object constructor for the given tag.
object_onstructor is a function that accepts a Loader instance
and a node object and produces the corresponding Python object.
"""
if Loader is None:
constructor.add_constructor(tag, object_constructor)
else:
if hasattr(Loader, 'add_constructor'):
Loader.add_constructor(tag, object_constructor)
return
if issubclass(Loader, BaseLoader):
BaseConstructor.add_constructor(tag, object_constructor)
elif issubclass(Loader, SafeLoader):
SafeConstructor.add_constructor(tag, object_constructor)
elif issubclass(Loader, Loader):
Constructor.add_constructor(tag, object_constructor)
elif issubclass(Loader, RoundTripLoader):
RoundTripConstructor.add_constructor(tag, object_constructor)
else:
raise NotImplementedError
def add_multi_constructor(tag_prefix,
multi_constructor,
Loader=None,
constructor=Constructor):
# type: (Any, Any, Any, Any) -> None
"""
Add a multi-constructor for the given tag prefix.
Multi-constructor is called for a node if its tag starts with tag_prefix.
Multi-constructor accepts a Loader instance, a tag suffix,
and a node object and produces the corresponding Python object.
"""
if Loader is None:
constructor.add_multi_constructor(tag_prefix, multi_constructor)
else:
if False and hasattr(Loader, 'add_multi_constructor'):
Loader.add_multi_constructor(tag_prefix, constructor)
return
if issubclass(Loader, BaseLoader):
BaseConstructor.add_multi_constructor(tag_prefix,
multi_constructor)
elif issubclass(Loader, SafeLoader):
SafeConstructor.add_multi_constructor(tag_prefix,
multi_constructor)
elif issubclass(Loader, ruamel.yaml.loader.Loader):
Constructor.add_multi_constructor(tag_prefix, multi_constructor)
elif issubclass(Loader, RoundTripLoader):
RoundTripConstructor.add_multi_constructor(tag_prefix,
multi_constructor)
else:
raise NotImplementedError
def __init__(self, stream, version=None, preserve_quotes=None):
Reader.__init__(self, stream)
RoundTripScanner.__init__(self)
RoundTripParser.__init__(self)
Composer.__init__(self)
RoundTripConstructor.__init__(self, preserve_quotes=preserve_quotes)
VersionedResolver.__init__(self, version)
def __init__(self, stream, version=None, preserve_quotes=None):
Reader.__init__(self, stream)
RoundTripScanner.__init__(self)
RoundTripParser.__init__(self)
Composer.__init__(self)
RoundTripConstructor.__init__(self, preserve_quotes=preserve_quotes)
VersionedResolver.__init__(self, version)
def __init__(self, stream):
"""Initialise loader."""
Reader.__init__(self, stream)
RoundTripScanner.__init__(self)
Parser.__init__(self)
Composer.__init__(self)
RoundTripConstructor.__init__(self)
MpfResolver.__init__(self)
def __init__(self, stream, version=None, preserve_quotes=None):
# type: (StreamTextType, Optional[VersionType], Optional[bool]) -> None
# self.reader = Reader.__init__(self, stream)
Reader.__init__(self, stream, loader=self)
RoundTripScanner.__init__(self, loader=self)
RoundTripParser.__init__(self, loader=self)
Composer.__init__(self, loader=self)
RoundTripConstructor.__init__(self, preserve_quotes=preserve_quotes, loader=self)
VersionedResolver.__init__(self, version, loader=self)
def __init__(self, stream, version=None, preserve_quotes=None):
"""Initialise loader."""
del version
Reader.__init__(self, stream, loader=self)
RoundTripScanner.__init__(self, loader=self)
Parser.__init__(self, loader=self)
Composer.__init__(self, loader=self)
RoundTripConstructor.__init__(self,
preserve_quotes=preserve_quotes,
loader=self)
MpfResolver.__init__(self, loadumper=self)
def construct_mapping(self, node, maptyp, deep=False): # type: ignore
for i, (key_node, value_node) in enumerate(node.value):
# Upgrade a ScalarNode into a MappingNode so it can be added as a merge reference
if key_node.tag == u'tag:yaml.org,2002:merge' and value_node.tag == 'tag:github.com,2020:expression':
assert isinstance(value_node, yaml.nodes.ScalarNode), value_node
new_node = MapExpressionNode('tag:github.com,2020:expression', value_node.value)
node.value[i] = (key_node, new_node)
return RoundTripConstructor.construct_mapping(self, node, maptyp, deep)
def load_yaml(fname: str) -> JSON_TYPE:
"""Load a YAML file."""
from ruamel.yaml import YAML
from ruamel.yaml.constructor import RoundTripConstructor
from ruamel.yaml.error import YAMLError
RoundTripConstructor.add_constructor(None, _yaml_unsupported)
yaml = YAML(typ='rt')
try:
with open(fname, encoding='utf-8') as conf_file:
# If configuration file is empty YAML returns None
# We convert that to an empty dict
return yaml.load(conf_file) or OrderedDict()
except YAMLError as exc:
_LOGGER.error("YAML error in %s: %s", fname, exc)
raise HomeAssistantError(exc)
except UnicodeDecodeError as exc:
_LOGGER.error("Unable to read file %s: %s", fname, exc)
raise HomeAssistantError(exc)
global jinja
template = jinja.get_template(path)
yaml = YAML(typ='rt')
yaml.preserve_quotes = True
yaml.Constructor = RoundTripConstructor
return yaml.load(template.render(args) + '\n')
def include_statement(loader, node):
fn, *args = node.value.split(' ', 1)
if args:
args = json.loads(args[0])
return process_file(fn, args)
RoundTripConstructor.add_constructor("!include", include_statement)
def file_statement(loader, node):
path = node.value
timestamp = time.time()
if '?' in path:
return '{}&{}'.format(path, str(timestamp))
else:
return '{}?{}'.format(path, str(timestamp))
RoundTripConstructor.add_constructor("!file", file_statement)
def main():
def construct_expression(self, node):
if isinstance(node, MapExpressionNode):
return CommentedMapExpression(node.value)
assert isinstance(node, yaml.nodes.ScalarNode), (type(node), node)
v = node.value
if isinstance(v, str):
v = exp.parse(v)
assert isinstance(v, exp.Expression), (type(v), v)
return v
RoundTripConstructor.add_constructor(u'tag:github.com,2020:expression', construct_expression)
# ==============================================================
class CommentedMapExpression(yaml.comments.CommentedMap):
def __init__(self, a0, *args, **kw):
yaml.comments.CommentedMap.__init__(self, [], *args, **kw)
if isinstance(a0, str):
a0 = exp.parse(a0)
self.exp_value = a0
def __repr__(self):
