mirror of
https://github.com/clinton-hall/nzbToMedia.git
synced 2024-11-14 17:40:24 -08:00
56c6773c6b
Updates colorama to 0.4.6 Adds confuse version 1.7.0 Updates jellyfish to 0.9.0 Adds mediafile 0.10.1 Updates munkres to 1.1.4 Updates musicbrainzngs to 0.7.1 Updates mutagen to 1.46.0 Updates pyyaml to 6.0 Updates unidecode to 1.3.6
749 lines
28 KiB
Python
749 lines
28 KiB
Python
|
|
__all__ = [
|
|
'BaseConstructor',
|
|
'SafeConstructor',
|
|
'FullConstructor',
|
|
'UnsafeConstructor',
|
|
'Constructor',
|
|
'ConstructorError'
|
|
]
|
|
|
|
from .error import *
|
|
from .nodes import *
|
|
|
|
import collections.abc, datetime, base64, binascii, re, sys, types
|
|
|
|
class ConstructorError(MarkedYAMLError):
|
|
pass
|
|
|
|
class BaseConstructor:
|
|
|
|
yaml_constructors = {}
|
|
yaml_multi_constructors = {}
|
|
|
|
def __init__(self):
|
|
self.constructed_objects = {}
|
|
self.recursive_objects = {}
|
|
self.state_generators = []
|
|
self.deep_construct = False
|
|
|
|
def check_data(self):
|
|
# If there are more documents available?
|
|
return self.check_node()
|
|
|
|
def check_state_key(self, key):
|
|
"""Block special attributes/methods from being set in a newly created
|
|
object, to prevent user-controlled methods from being called during
|
|
deserialization"""
|
|
if self.get_state_keys_blacklist_regexp().match(key):
|
|
raise ConstructorError(None, None,
|
|
"blacklisted key '%s' in instance state found" % (key,), None)
|
|
|
|
def get_data(self):
|
|
# Construct and return the next document.
|
|
if self.check_node():
|
|
return self.construct_document(self.get_node())
|
|
|
|
def get_single_data(self):
|
|
# Ensure that the stream contains a single document and construct it.
|
|
node = self.get_single_node()
|
|
if node is not None:
|
|
return self.construct_document(node)
|
|
return None
|
|
|
|
def construct_document(self, node):
|
|
data = self.construct_object(node)
|
|
while self.state_generators:
|
|
state_generators = self.state_generators
|
|
self.state_generators = []
|
|
for generator in state_generators:
|
|
for dummy in generator:
|
|
pass
|
|
self.constructed_objects = {}
|
|
self.recursive_objects = {}
|
|
self.deep_construct = False
|
|
return data
|
|
|
|
def construct_object(self, node, deep=False):
|
|
if node in self.constructed_objects:
|
|
return self.constructed_objects[node]
|
|
if deep:
|
|
old_deep = self.deep_construct
|
|
self.deep_construct = True
|
|
if node in self.recursive_objects:
|
|
raise ConstructorError(None, None,
|
|
"found unconstructable recursive node", node.start_mark)
|
|
self.recursive_objects[node] = None
|
|
constructor = None
|
|
tag_suffix = None
|
|
if node.tag in self.yaml_constructors:
|
|
constructor = self.yaml_constructors[node.tag]
|
|
else:
|
|
for tag_prefix in self.yaml_multi_constructors:
|
|
if tag_prefix is not None and node.tag.startswith(tag_prefix):
|
|
tag_suffix = node.tag[len(tag_prefix):]
|
|
constructor = self.yaml_multi_constructors[tag_prefix]
|
|
break
|
|
else:
|
|
if None in self.yaml_multi_constructors:
|
|
tag_suffix = node.tag
|
|
constructor = self.yaml_multi_constructors[None]
|
|
elif None in self.yaml_constructors:
|
|
constructor = self.yaml_constructors[None]
|
|
elif isinstance(node, ScalarNode):
|
|
constructor = self.__class__.construct_scalar
|
|
elif isinstance(node, SequenceNode):
|
|
constructor = self.__class__.construct_sequence
|
|
elif isinstance(node, MappingNode):
|
|
constructor = self.__class__.construct_mapping
|
|
if tag_suffix is None:
|
|
data = constructor(self, node)
|
|
else:
|
|
data = constructor(self, tag_suffix, node)
|
|
if isinstance(data, types.GeneratorType):
|
|
generator = data
|
|
data = next(generator)
|
|
if self.deep_construct:
|
|
for dummy in generator:
|
|
pass
|
|
else:
|
|
self.state_generators.append(generator)
|
|
self.constructed_objects[node] = data
|
|
del self.recursive_objects[node]
|
|
if deep:
|
|
self.deep_construct = old_deep
|
|
return data
|
|
|
|
def construct_scalar(self, node):
|
|
if not isinstance(node, ScalarNode):
|
|
raise ConstructorError(None, None,
|
|
"expected a scalar node, but found %s" % node.id,
|
|
node.start_mark)
|
|
return node.value
|
|
|
|
def construct_sequence(self, node, deep=False):
|
|
if not isinstance(node, SequenceNode):
|
|
raise ConstructorError(None, None,
|
|
"expected a sequence node, but found %s" % node.id,
|
|
node.start_mark)
|
|
return [self.construct_object(child, deep=deep)
|
|
for child in node.value]
|
|
|
|
def construct_mapping(self, node, deep=False):
|
|
if not isinstance(node, MappingNode):
|
|
raise ConstructorError(None, None,
|
|
"expected a mapping node, but found %s" % node.id,
|
|
node.start_mark)
|
|
mapping = {}
|
|
for key_node, value_node in node.value:
|
|
key = self.construct_object(key_node, deep=deep)
|
|
if not isinstance(key, collections.abc.Hashable):
|
|
raise ConstructorError("while constructing a mapping", node.start_mark,
|
|
"found unhashable key", key_node.start_mark)
|
|
value = self.construct_object(value_node, deep=deep)
|
|
mapping[key] = value
|
|
return mapping
|
|
|
|
def construct_pairs(self, node, deep=False):
|
|
if not isinstance(node, MappingNode):
|
|
raise ConstructorError(None, None,
|
|
"expected a mapping node, but found %s" % node.id,
|
|
node.start_mark)
|
|
pairs = []
|
|
for key_node, value_node in node.value:
|
|
key = self.construct_object(key_node, deep=deep)
|
|
value = self.construct_object(value_node, deep=deep)
|
|
pairs.append((key, value))
|
|
return pairs
|
|
|
|
@classmethod
|
|
def add_constructor(cls, tag, constructor):
|
|
if not 'yaml_constructors' in cls.__dict__:
|
|
cls.yaml_constructors = cls.yaml_constructors.copy()
|
|
cls.yaml_constructors[tag] = constructor
|
|
|
|
@classmethod
|
|
def add_multi_constructor(cls, tag_prefix, multi_constructor):
|
|
if not 'yaml_multi_constructors' in cls.__dict__:
|
|
cls.yaml_multi_constructors = cls.yaml_multi_constructors.copy()
|
|
cls.yaml_multi_constructors[tag_prefix] = multi_constructor
|
|
|
|
class SafeConstructor(BaseConstructor):
|
|
|
|
def construct_scalar(self, node):
|
|
if isinstance(node, MappingNode):
|
|
for key_node, value_node in node.value:
|
|
if key_node.tag == 'tag:yaml.org,2002:value':
|
|
return self.construct_scalar(value_node)
|
|
return super().construct_scalar(node)
|
|
|
|
def flatten_mapping(self, node):
|
|
merge = []
|
|
index = 0
|
|
while index < len(node.value):
|
|
key_node, value_node = node.value[index]
|
|
if key_node.tag == 'tag:yaml.org,2002:merge':
|
|
del node.value[index]
|
|
if isinstance(value_node, MappingNode):
|
|
self.flatten_mapping(value_node)
|
|
merge.extend(value_node.value)
|
|
elif isinstance(value_node, SequenceNode):
|
|
submerge = []
|
|
for subnode in value_node.value:
|
|
if not isinstance(subnode, MappingNode):
|
|
raise ConstructorError("while constructing a mapping",
|
|
node.start_mark,
|
|
"expected a mapping for merging, but found %s"
|
|
% subnode.id, subnode.start_mark)
|
|
self.flatten_mapping(subnode)
|
|
submerge.append(subnode.value)
|
|
submerge.reverse()
|
|
for value in submerge:
|
|
merge.extend(value)
|
|
else:
|
|
raise ConstructorError("while constructing a mapping", node.start_mark,
|
|
"expected a mapping or list of mappings for merging, but found %s"
|
|
% value_node.id, value_node.start_mark)
|
|
elif key_node.tag == 'tag:yaml.org,2002:value':
|
|
key_node.tag = 'tag:yaml.org,2002:str'
|
|
index += 1
|
|
else:
|
|
index += 1
|
|
if merge:
|
|
node.value = merge + node.value
|
|
|
|
def construct_mapping(self, node, deep=False):
|
|
if isinstance(node, MappingNode):
|
|
self.flatten_mapping(node)
|
|
return super().construct_mapping(node, deep=deep)
|
|
|
|
def construct_yaml_null(self, node):
|
|
self.construct_scalar(node)
|
|
return None
|
|
|
|
bool_values = {
|
|
'yes': True,
|
|
'no': False,
|
|
'true': True,
|
|
'false': False,
|
|
'on': True,
|
|
'off': False,
|
|
}
|
|
|
|
def construct_yaml_bool(self, node):
|
|
value = self.construct_scalar(node)
|
|
return self.bool_values[value.lower()]
|
|
|
|
def construct_yaml_int(self, node):
|
|
value = self.construct_scalar(node)
|
|
value = value.replace('_', '')
|
|
sign = +1
|
|
if value[0] == '-':
|
|
sign = -1
|
|
if value[0] in '+-':
|
|
value = value[1:]
|
|
if value == '0':
|
|
return 0
|
|
elif value.startswith('0b'):
|
|
return sign*int(value[2:], 2)
|
|
elif value.startswith('0x'):
|
|
return sign*int(value[2:], 16)
|
|
elif value[0] == '0':
|
|
return sign*int(value, 8)
|
|
elif ':' in value:
|
|
digits = [int(part) for part in value.split(':')]
|
|
digits.reverse()
|
|
base = 1
|
|
value = 0
|
|
for digit in digits:
|
|
value += digit*base
|
|
base *= 60
|
|
return sign*value
|
|
else:
|
|
return sign*int(value)
|
|
|
|
inf_value = 1e300
|
|
while inf_value != inf_value*inf_value:
|
|
inf_value *= inf_value
|
|
nan_value = -inf_value/inf_value # Trying to make a quiet NaN (like C99).
|
|
|
|
def construct_yaml_float(self, node):
|
|
value = self.construct_scalar(node)
|
|
value = value.replace('_', '').lower()
|
|
sign = +1
|
|
if value[0] == '-':
|
|
sign = -1
|
|
if value[0] in '+-':
|
|
value = value[1:]
|
|
if value == '.inf':
|
|
return sign*self.inf_value
|
|
elif value == '.nan':
|
|
return self.nan_value
|
|
elif ':' in value:
|
|
digits = [float(part) for part in value.split(':')]
|
|
digits.reverse()
|
|
base = 1
|
|
value = 0.0
|
|
for digit in digits:
|
|
value += digit*base
|
|
base *= 60
|
|
return sign*value
|
|
else:
|
|
return sign*float(value)
|
|
|
|
def construct_yaml_binary(self, node):
|
|
try:
|
|
value = self.construct_scalar(node).encode('ascii')
|
|
except UnicodeEncodeError as exc:
|
|
raise ConstructorError(None, None,
|
|
"failed to convert base64 data into ascii: %s" % exc,
|
|
node.start_mark)
|
|
try:
|
|
if hasattr(base64, 'decodebytes'):
|
|
return base64.decodebytes(value)
|
|
else:
|
|
return base64.decodestring(value)
|
|
except binascii.Error as exc:
|
|
raise ConstructorError(None, None,
|
|
"failed to decode base64 data: %s" % exc, node.start_mark)
|
|
|
|
timestamp_regexp = re.compile(
|
|
r'''^(?P<year>[0-9][0-9][0-9][0-9])
|
|
-(?P<month>[0-9][0-9]?)
|
|
-(?P<day>[0-9][0-9]?)
|
|
(?:(?:[Tt]|[ \t]+)
|
|
(?P<hour>[0-9][0-9]?)
|
|
:(?P<minute>[0-9][0-9])
|
|
:(?P<second>[0-9][0-9])
|
|
(?:\.(?P<fraction>[0-9]*))?
|
|
(?:[ \t]*(?P<tz>Z|(?P<tz_sign>[-+])(?P<tz_hour>[0-9][0-9]?)
|
|
(?::(?P<tz_minute>[0-9][0-9]))?))?)?$''', re.X)
|
|
|
|
def construct_yaml_timestamp(self, node):
|
|
value = self.construct_scalar(node)
|
|
match = self.timestamp_regexp.match(node.value)
|
|
values = match.groupdict()
|
|
year = int(values['year'])
|
|
month = int(values['month'])
|
|
day = int(values['day'])
|
|
if not values['hour']:
|
|
return datetime.date(year, month, day)
|
|
hour = int(values['hour'])
|
|
minute = int(values['minute'])
|
|
second = int(values['second'])
|
|
fraction = 0
|
|
tzinfo = None
|
|
if values['fraction']:
|
|
fraction = values['fraction'][:6]
|
|
while len(fraction) < 6:
|
|
fraction += '0'
|
|
fraction = int(fraction)
|
|
if values['tz_sign']:
|
|
tz_hour = int(values['tz_hour'])
|
|
tz_minute = int(values['tz_minute'] or 0)
|
|
delta = datetime.timedelta(hours=tz_hour, minutes=tz_minute)
|
|
if values['tz_sign'] == '-':
|
|
delta = -delta
|
|
tzinfo = datetime.timezone(delta)
|
|
elif values['tz']:
|
|
tzinfo = datetime.timezone.utc
|
|
return datetime.datetime(year, month, day, hour, minute, second, fraction,
|
|
tzinfo=tzinfo)
|
|
|
|
def construct_yaml_omap(self, node):
|
|
# Note: we do not check for duplicate keys, because it's too
|
|
# CPU-expensive.
|
|
omap = []
|
|
yield omap
|
|
if not isinstance(node, SequenceNode):
|
|
raise ConstructorError("while constructing an ordered map", node.start_mark,
|
|
"expected a sequence, but found %s" % node.id, node.start_mark)
|
|
for subnode in node.value:
|
|
if not isinstance(subnode, MappingNode):
|
|
raise ConstructorError("while constructing an ordered map", node.start_mark,
|
|
"expected a mapping of length 1, but found %s" % subnode.id,
|
|
subnode.start_mark)
|
|
if len(subnode.value) != 1:
|
|
raise ConstructorError("while constructing an ordered map", node.start_mark,
|
|
"expected a single mapping item, but found %d items" % len(subnode.value),
|
|
subnode.start_mark)
|
|
key_node, value_node = subnode.value[0]
|
|
key = self.construct_object(key_node)
|
|
value = self.construct_object(value_node)
|
|
omap.append((key, value))
|
|
|
|
def construct_yaml_pairs(self, node):
|
|
# Note: the same code as `construct_yaml_omap`.
|
|
pairs = []
|
|
yield pairs
|
|
if not isinstance(node, SequenceNode):
|
|
raise ConstructorError("while constructing pairs", node.start_mark,
|
|
"expected a sequence, but found %s" % node.id, node.start_mark)
|
|
for subnode in node.value:
|
|
if not isinstance(subnode, MappingNode):
|
|
raise ConstructorError("while constructing pairs", node.start_mark,
|
|
"expected a mapping of length 1, but found %s" % subnode.id,
|
|
subnode.start_mark)
|
|
if len(subnode.value) != 1:
|
|
raise ConstructorError("while constructing pairs", node.start_mark,
|
|
"expected a single mapping item, but found %d items" % len(subnode.value),
|
|
subnode.start_mark)
|
|
key_node, value_node = subnode.value[0]
|
|
key = self.construct_object(key_node)
|
|
value = self.construct_object(value_node)
|
|
pairs.append((key, value))
|
|
|
|
def construct_yaml_set(self, node):
|
|
data = set()
|
|
yield data
|
|
value = self.construct_mapping(node)
|
|
data.update(value)
|
|
|
|
def construct_yaml_str(self, node):
|
|
return self.construct_scalar(node)
|
|
|
|
def construct_yaml_seq(self, node):
|
|
data = []
|
|
yield data
|
|
data.extend(self.construct_sequence(node))
|
|
|
|
def construct_yaml_map(self, node):
|
|
data = {}
|
|
yield data
|
|
value = self.construct_mapping(node)
|
|
data.update(value)
|
|
|
|
def construct_yaml_object(self, node, cls):
|
|
data = cls.__new__(cls)
|
|
yield data
|
|
if hasattr(data, '__setstate__'):
|
|
state = self.construct_mapping(node, deep=True)
|
|
data.__setstate__(state)
|
|
else:
|
|
state = self.construct_mapping(node)
|
|
data.__dict__.update(state)
|
|
|
|
def construct_undefined(self, node):
|
|
raise ConstructorError(None, None,
|
|
"could not determine a constructor for the tag %r" % node.tag,
|
|
node.start_mark)
|
|
|
|
SafeConstructor.add_constructor(
|
|
'tag:yaml.org,2002:null',
|
|
SafeConstructor.construct_yaml_null)
|
|
|
|
SafeConstructor.add_constructor(
|
|
'tag:yaml.org,2002:bool',
|
|
SafeConstructor.construct_yaml_bool)
|
|
|
|
SafeConstructor.add_constructor(
|
|
'tag:yaml.org,2002:int',
|
|
SafeConstructor.construct_yaml_int)
|
|
|
|
SafeConstructor.add_constructor(
|
|
'tag:yaml.org,2002:float',
|
|
SafeConstructor.construct_yaml_float)
|
|
|
|
SafeConstructor.add_constructor(
|
|
'tag:yaml.org,2002:binary',
|
|
SafeConstructor.construct_yaml_binary)
|
|
|
|
SafeConstructor.add_constructor(
|
|
'tag:yaml.org,2002:timestamp',
|
|
SafeConstructor.construct_yaml_timestamp)
|
|
|
|
SafeConstructor.add_constructor(
|
|
'tag:yaml.org,2002:omap',
|
|
SafeConstructor.construct_yaml_omap)
|
|
|
|
SafeConstructor.add_constructor(
|
|
'tag:yaml.org,2002:pairs',
|
|
SafeConstructor.construct_yaml_pairs)
|
|
|
|
SafeConstructor.add_constructor(
|
|
'tag:yaml.org,2002:set',
|
|
SafeConstructor.construct_yaml_set)
|
|
|
|
SafeConstructor.add_constructor(
|
|
'tag:yaml.org,2002:str',
|
|
SafeConstructor.construct_yaml_str)
|
|
|
|
SafeConstructor.add_constructor(
|
|
'tag:yaml.org,2002:seq',
|
|
SafeConstructor.construct_yaml_seq)
|
|
|
|
SafeConstructor.add_constructor(
|
|
'tag:yaml.org,2002:map',
|
|
SafeConstructor.construct_yaml_map)
|
|
|
|
SafeConstructor.add_constructor(None,
|
|
SafeConstructor.construct_undefined)
|
|
|
|
class FullConstructor(SafeConstructor):
|
|
# 'extend' is blacklisted because it is used by
|
|
# construct_python_object_apply to add `listitems` to a newly generate
|
|
# python instance
|
|
def get_state_keys_blacklist(self):
|
|
return ['^extend$', '^__.*__$']
|
|
|
|
def get_state_keys_blacklist_regexp(self):
|
|
if not hasattr(self, 'state_keys_blacklist_regexp'):
|
|
self.state_keys_blacklist_regexp = re.compile('(' + '|'.join(self.get_state_keys_blacklist()) + ')')
|
|
return self.state_keys_blacklist_regexp
|
|
|
|
def construct_python_str(self, node):
|
|
return self.construct_scalar(node)
|
|
|
|
def construct_python_unicode(self, node):
|
|
return self.construct_scalar(node)
|
|
|
|
def construct_python_bytes(self, node):
|
|
try:
|
|
value = self.construct_scalar(node).encode('ascii')
|
|
except UnicodeEncodeError as exc:
|
|
raise ConstructorError(None, None,
|
|
"failed to convert base64 data into ascii: %s" % exc,
|
|
node.start_mark)
|
|
try:
|
|
if hasattr(base64, 'decodebytes'):
|
|
return base64.decodebytes(value)
|
|
else:
|
|
return base64.decodestring(value)
|
|
except binascii.Error as exc:
|
|
raise ConstructorError(None, None,
|
|
"failed to decode base64 data: %s" % exc, node.start_mark)
|
|
|
|
def construct_python_long(self, node):
|
|
return self.construct_yaml_int(node)
|
|
|
|
def construct_python_complex(self, node):
|
|
return complex(self.construct_scalar(node))
|
|
|
|
def construct_python_tuple(self, node):
|
|
return tuple(self.construct_sequence(node))
|
|
|
|
def find_python_module(self, name, mark, unsafe=False):
|
|
if not name:
|
|
raise ConstructorError("while constructing a Python module", mark,
|
|
"expected non-empty name appended to the tag", mark)
|
|
if unsafe:
|
|
try:
|
|
__import__(name)
|
|
except ImportError as exc:
|
|
raise ConstructorError("while constructing a Python module", mark,
|
|
"cannot find module %r (%s)" % (name, exc), mark)
|
|
if name not in sys.modules:
|
|
raise ConstructorError("while constructing a Python module", mark,
|
|
"module %r is not imported" % name, mark)
|
|
return sys.modules[name]
|
|
|
|
def find_python_name(self, name, mark, unsafe=False):
|
|
if not name:
|
|
raise ConstructorError("while constructing a Python object", mark,
|
|
"expected non-empty name appended to the tag", mark)
|
|
if '.' in name:
|
|
module_name, object_name = name.rsplit('.', 1)
|
|
else:
|
|
module_name = 'builtins'
|
|
object_name = name
|
|
if unsafe:
|
|
try:
|
|
__import__(module_name)
|
|
except ImportError as exc:
|
|
raise ConstructorError("while constructing a Python object", mark,
|
|
"cannot find module %r (%s)" % (module_name, exc), mark)
|
|
if module_name not in sys.modules:
|
|
raise ConstructorError("while constructing a Python object", mark,
|
|
"module %r is not imported" % module_name, mark)
|
|
module = sys.modules[module_name]
|
|
if not hasattr(module, object_name):
|
|
raise ConstructorError("while constructing a Python object", mark,
|
|
"cannot find %r in the module %r"
|
|
% (object_name, module.__name__), mark)
|
|
return getattr(module, object_name)
|
|
|
|
def construct_python_name(self, suffix, node):
|
|
value = self.construct_scalar(node)
|
|
if value:
|
|
raise ConstructorError("while constructing a Python name", node.start_mark,
|
|
"expected the empty value, but found %r" % value, node.start_mark)
|
|
return self.find_python_name(suffix, node.start_mark)
|
|
|
|
def construct_python_module(self, suffix, node):
|
|
value = self.construct_scalar(node)
|
|
if value:
|
|
raise ConstructorError("while constructing a Python module", node.start_mark,
|
|
"expected the empty value, but found %r" % value, node.start_mark)
|
|
return self.find_python_module(suffix, node.start_mark)
|
|
|
|
def make_python_instance(self, suffix, node,
|
|
args=None, kwds=None, newobj=False, unsafe=False):
|
|
if not args:
|
|
args = []
|
|
if not kwds:
|
|
kwds = {}
|
|
cls = self.find_python_name(suffix, node.start_mark)
|
|
if not (unsafe or isinstance(cls, type)):
|
|
raise ConstructorError("while constructing a Python instance", node.start_mark,
|
|
"expected a class, but found %r" % type(cls),
|
|
node.start_mark)
|
|
if newobj and isinstance(cls, type):
|
|
return cls.__new__(cls, *args, **kwds)
|
|
else:
|
|
return cls(*args, **kwds)
|
|
|
|
def set_python_instance_state(self, instance, state, unsafe=False):
|
|
if hasattr(instance, '__setstate__'):
|
|
instance.__setstate__(state)
|
|
else:
|
|
slotstate = {}
|
|
if isinstance(state, tuple) and len(state) == 2:
|
|
state, slotstate = state
|
|
if hasattr(instance, '__dict__'):
|
|
if not unsafe and state:
|
|
for key in state.keys():
|
|
self.check_state_key(key)
|
|
instance.__dict__.update(state)
|
|
elif state:
|
|
slotstate.update(state)
|
|
for key, value in slotstate.items():
|
|
if not unsafe:
|
|
self.check_state_key(key)
|
|
setattr(instance, key, value)
|
|
|
|
def construct_python_object(self, suffix, node):
|
|
# Format:
|
|
# !!python/object:module.name { ... state ... }
|
|
instance = self.make_python_instance(suffix, node, newobj=True)
|
|
yield instance
|
|
deep = hasattr(instance, '__setstate__')
|
|
state = self.construct_mapping(node, deep=deep)
|
|
self.set_python_instance_state(instance, state)
|
|
|
|
def construct_python_object_apply(self, suffix, node, newobj=False):
|
|
# Format:
|
|
# !!python/object/apply # (or !!python/object/new)
|
|
# args: [ ... arguments ... ]
|
|
# kwds: { ... keywords ... }
|
|
# state: ... state ...
|
|
# listitems: [ ... listitems ... ]
|
|
# dictitems: { ... dictitems ... }
|
|
# or short format:
|
|
# !!python/object/apply [ ... arguments ... ]
|
|
# The difference between !!python/object/apply and !!python/object/new
|
|
# is how an object is created, check make_python_instance for details.
|
|
if isinstance(node, SequenceNode):
|
|
args = self.construct_sequence(node, deep=True)
|
|
kwds = {}
|
|
state = {}
|
|
listitems = []
|
|
dictitems = {}
|
|
else:
|
|
value = self.construct_mapping(node, deep=True)
|
|
args = value.get('args', [])
|
|
kwds = value.get('kwds', {})
|
|
state = value.get('state', {})
|
|
listitems = value.get('listitems', [])
|
|
dictitems = value.get('dictitems', {})
|
|
instance = self.make_python_instance(suffix, node, args, kwds, newobj)
|
|
if state:
|
|
self.set_python_instance_state(instance, state)
|
|
if listitems:
|
|
instance.extend(listitems)
|
|
if dictitems:
|
|
for key in dictitems:
|
|
instance[key] = dictitems[key]
|
|
return instance
|
|
|
|
def construct_python_object_new(self, suffix, node):
|
|
return self.construct_python_object_apply(suffix, node, newobj=True)
|
|
|
|
FullConstructor.add_constructor(
|
|
'tag:yaml.org,2002:python/none',
|
|
FullConstructor.construct_yaml_null)
|
|
|
|
FullConstructor.add_constructor(
|
|
'tag:yaml.org,2002:python/bool',
|
|
FullConstructor.construct_yaml_bool)
|
|
|
|
FullConstructor.add_constructor(
|
|
'tag:yaml.org,2002:python/str',
|
|
FullConstructor.construct_python_str)
|
|
|
|
FullConstructor.add_constructor(
|
|
'tag:yaml.org,2002:python/unicode',
|
|
FullConstructor.construct_python_unicode)
|
|
|
|
FullConstructor.add_constructor(
|
|
'tag:yaml.org,2002:python/bytes',
|
|
FullConstructor.construct_python_bytes)
|
|
|
|
FullConstructor.add_constructor(
|
|
'tag:yaml.org,2002:python/int',
|
|
FullConstructor.construct_yaml_int)
|
|
|
|
FullConstructor.add_constructor(
|
|
'tag:yaml.org,2002:python/long',
|
|
FullConstructor.construct_python_long)
|
|
|
|
FullConstructor.add_constructor(
|
|
'tag:yaml.org,2002:python/float',
|
|
FullConstructor.construct_yaml_float)
|
|
|
|
FullConstructor.add_constructor(
|
|
'tag:yaml.org,2002:python/complex',
|
|
FullConstructor.construct_python_complex)
|
|
|
|
FullConstructor.add_constructor(
|
|
'tag:yaml.org,2002:python/list',
|
|
FullConstructor.construct_yaml_seq)
|
|
|
|
FullConstructor.add_constructor(
|
|
'tag:yaml.org,2002:python/tuple',
|
|
FullConstructor.construct_python_tuple)
|
|
|
|
FullConstructor.add_constructor(
|
|
'tag:yaml.org,2002:python/dict',
|
|
FullConstructor.construct_yaml_map)
|
|
|
|
FullConstructor.add_multi_constructor(
|
|
'tag:yaml.org,2002:python/name:',
|
|
FullConstructor.construct_python_name)
|
|
|
|
class UnsafeConstructor(FullConstructor):
|
|
|
|
def find_python_module(self, name, mark):
|
|
return super(UnsafeConstructor, self).find_python_module(name, mark, unsafe=True)
|
|
|
|
def find_python_name(self, name, mark):
|
|
return super(UnsafeConstructor, self).find_python_name(name, mark, unsafe=True)
|
|
|
|
def make_python_instance(self, suffix, node, args=None, kwds=None, newobj=False):
|
|
return super(UnsafeConstructor, self).make_python_instance(
|
|
suffix, node, args, kwds, newobj, unsafe=True)
|
|
|
|
def set_python_instance_state(self, instance, state):
|
|
return super(UnsafeConstructor, self).set_python_instance_state(
|
|
instance, state, unsafe=True)
|
|
|
|
UnsafeConstructor.add_multi_constructor(
|
|
'tag:yaml.org,2002:python/module:',
|
|
UnsafeConstructor.construct_python_module)
|
|
|
|
UnsafeConstructor.add_multi_constructor(
|
|
'tag:yaml.org,2002:python/object:',
|
|
UnsafeConstructor.construct_python_object)
|
|
|
|
UnsafeConstructor.add_multi_constructor(
|
|
'tag:yaml.org,2002:python/object/new:',
|
|
UnsafeConstructor.construct_python_object_new)
|
|
|
|
UnsafeConstructor.add_multi_constructor(
|
|
'tag:yaml.org,2002:python/object/apply:',
|
|
UnsafeConstructor.construct_python_object_apply)
|
|
|
|
# Constructor is same as UnsafeConstructor. Need to leave this in place in case
|
|
# people have extended it directly.
|
|
class Constructor(UnsafeConstructor):
|
|
pass
|