outerbounds 0.3.55rc8__py3-none-any.whl → 0.3.133__py3-none-any.whl

outerbounds/_vendor/yaml/constructor.py

@@ -0,0 +1,862 @@
+__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