def __init__(self, stream):
    try:
        self._root = os.path.dirname(stream.name)
    except AttributeError:
        # this happens when `stream` is a string
        self._root = None
    super().__init__(stream)

def add_indent(self, column):
    # Check if we need to increase indentation.
    if self.indent < column:
        self.indents.append(self.indent)
        self.indent = column
        return True
    return False

def ascend_resolver(self):
    if not self.yaml_path_resolvers:
        return
    self.resolver_exact_paths.pop()
    self.resolver_prefix_paths.pop()

def check_block_entry(self):
    # BLOCK-ENTRY:      '-' (' '|'\n')
    return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029'

def check_data(self):
    # If there are more documents available?
    return self.check_node()

def check_directive(self):
    # DIRECTIVE:        ^ '%' ...
    # The '%' indicator is already checked.
    if self.column == 0:
        return True

def check_document_end(self):
    # DOCUMENT-END:     ^ '...' (' '|'\n')
    if self.column == 0:
        if self.prefix(3) == '...'  \
                and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
            return True

def check_document_start(self):
    # DOCUMENT-START:   ^ '---' (' '|'\n')
    if self.column == 0:
        if self.prefix(3) == '---'  \
                and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
            return True

def check_event(self, *choices):
    # Check the type of the next event.
    if self.current_event is None:
        if self.state:
            self.current_event = self.state()
    if self.current_event is not None:
        if not choices:
            return True
        for choice in choices:
            if isinstance(self.current_event, choice):
                return True
    return False

def check_key(self):
    # KEY(flow context):    '?'
    if self.flow_level:
        return True
    # KEY(block context):   '?' (' '|'\n')
    else:
        return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029'

def check_node(self):
    # Drop the STREAM-START event.
    if self.check_event(StreamStartEvent):
        self.get_event()
    # If there are more documents available?
    return not self.check_event(StreamEndEvent)

def check_plain(self):
    # A plain scalar may start with any non-space character except:
    #   '-', '?', ':', ',', '[', ']', '{', '}',
    #   '#', '&', '*', '!', '|', '>', '\'', '\"',
    #   '%', '@', '`'.
    #
    # It may also start with
    #   '-', '?', ':'
    # if it is followed by a non-space character.
    #
    # Note that we limit the last rule to the block context (except the
    # '-' character) because we want the flow context to be space
    # independent.
    ch = self.peek()
    return ch not in '\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`'  \
            or (self.peek(1) not in '\0 \t\r\n\x85\u2028\u2029'
                    and (ch == '-' or (not self.flow_level and ch in '?:')))

def check_printable(self, data):
    match = self.NON_PRINTABLE.search(data)
    if match:
        character = match.group()
        position = self.index+(len(self.buffer)-self.pointer)+match.start()
        raise ReaderError(self.name, position, ord(character),
                'unicode', "special characters are not allowed")

def check_resolver_prefix(self, depth, path, kind,
        current_node, current_index):
    node_check, index_check = path[depth-1]
    if isinstance(node_check, str):
        if current_node.tag != node_check:
            return
    elif node_check is not None:
        if not isinstance(current_node, node_check):
            return
    if index_check is True and current_index is not None:
        return
    if (index_check is False or index_check is None)    \
            and current_index is None:
        return
    if isinstance(index_check, str):
        if not (isinstance(current_index, ScalarNode)
                and index_check == current_index.value):
            return
    elif isinstance(index_check, int) and not isinstance(index_check, bool):
        if index_check != current_index:
            return
    return True

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 check_token(self, *choices):
    # Check if the next token is one of the given types.
    while self.need_more_tokens():
        self.fetch_more_tokens()
    if self.tokens:
        if not choices:
            return True
        for choice in choices:
            if isinstance(self.tokens[0], choice):
                return True
    return False

def check_value(self):
    # VALUE(flow context):  ':'
    if self.flow_level:
        return True
    # VALUE(block context): ':' (' '|'\n')
    else:
        return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029'

def compose_document(self):
    # Drop the DOCUMENT-START event.
    self.get_event()
    # Compose the root node.
    node = self.compose_node(None, None)
    # Drop the DOCUMENT-END event.
    self.get_event()
    self.anchors = {}
    return node

def compose_mapping_node(self, anchor):
    start_event = self.get_event()
    tag = start_event.tag
    if tag is None or tag == '!':
        tag = self.resolve(MappingNode, None, start_event.implicit)
    node = MappingNode(tag, [],
            start_event.start_mark, None,
            flow_style=start_event.flow_style)
    if anchor is not None:
        self.anchors[anchor] = node
    while not self.check_event(MappingEndEvent):
        #key_event = self.peek_event()
        item_key = self.compose_node(node, None)
        #if item_key in node.value:
        #    raise ComposerError("while composing a mapping", start_event.start_mark,
        #            "found duplicate key", key_event.start_mark)
        item_value = self.compose_node(node, item_key)
        #node.value[item_key] = item_value
        node.value.append((item_key, item_value))
    end_event = self.get_event()
    node.end_mark = end_event.end_mark
    return node

def compose_node(self, parent, index):
    if self.check_event(AliasEvent):
        event = self.get_event()
        anchor = event.anchor
        if anchor not in self.anchors:
            raise ComposerError(None, None, "found undefined alias %r"
                    % anchor, event.start_mark)
        return self.anchors[anchor]
    event = self.peek_event()
    anchor = event.anchor
    if anchor is not None:
        if anchor in self.anchors:
            raise ComposerError("found duplicate anchor %r; first occurrence"
                    % anchor, self.anchors[anchor].start_mark,
                    "second occurrence", event.start_mark)
    self.descend_resolver(parent, index)
    if self.check_event(ScalarEvent):
        node = self.compose_scalar_node(anchor)
    elif self.check_event(SequenceStartEvent):
        node = self.compose_sequence_node(anchor)
    elif self.check_event(MappingStartEvent):
        node = self.compose_mapping_node(anchor)
    self.ascend_resolver()
    return node

def compose_scalar_node(self, anchor):
    event = self.get_event()
    tag = event.tag
    if tag is None or tag == '!':
        tag = self.resolve(ScalarNode, event.value, event.implicit)
    node = ScalarNode(tag, event.value,
            event.start_mark, event.end_mark, style=event.style)
    if anchor is not None:
        self.anchors[anchor] = node
    return node

def compose_sequence_node(self, anchor):
    start_event = self.get_event()
    tag = start_event.tag
    if tag is None or tag == '!':
        tag = self.resolve(SequenceNode, None, start_event.implicit)
    node = SequenceNode(tag, [],
            start_event.start_mark, None,
            flow_style=start_event.flow_style)
    if anchor is not None:
        self.anchors[anchor] = node
    index = 0
    while not self.check_event(SequenceEndEvent):
        node.value.append(self.compose_node(node, index))
        index += 1
    end_event = self.get_event()
    node.end_mark = end_event.end_mark
    return node

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_mapping(self, node, deep=False):
    if isinstance(node, MappingNode):
        self.flatten_mapping(node)
    return super().construct_mapping(node, deep=deep)

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

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 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_undefined(self, node):
    raise ConstructorError(None, None,
            "could not determine a constructor for the tag %r" % node.tag,
            node.start_mark)

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)

def construct_yaml_bool(self, node):
    value = self.construct_scalar(node)
    return self.bool_values[value.lower()]

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

def construct_yaml_map(self, node):
    data = {}
    yield data
    value = self.construct_mapping(node)
    data.update(value)

def construct_yaml_null(self, node):
    self.construct_scalar(node)
    return None

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_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_seq(self, node):
    data = []
    yield data
    data.extend(self.construct_sequence(node))

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_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 descend_resolver(self, current_node, current_index):
    if not self.yaml_path_resolvers:
        return
    exact_paths = {}
    prefix_paths = []
    if current_node:
        depth = len(self.resolver_prefix_paths)
        for path, kind in self.resolver_prefix_paths[-1]:
            if self.check_resolver_prefix(depth, path, kind,
                    current_node, current_index):
                if len(path) > depth:
                    prefix_paths.append((path, kind))
                else:
                    exact_paths[kind] = self.yaml_path_resolvers[path, kind]
    else:
        for path, kind in self.yaml_path_resolvers:
            if not path:
                exact_paths[kind] = self.yaml_path_resolvers[path, kind]
            else:
                prefix_paths.append((path, kind))
    self.resolver_exact_paths.append(exact_paths)
    self.resolver_prefix_paths.append(prefix_paths)

def determine_encoding(self):
    while not self.eof and (self.raw_buffer is None or len(self.raw_buffer) < 2):
        self.update_raw()
    if isinstance(self.raw_buffer, bytes):
        if self.raw_buffer.startswith(codecs.BOM_UTF16_LE):
            self.raw_decode = codecs.utf_16_le_decode
            self.encoding = 'utf-16-le'
        elif self.raw_buffer.startswith(codecs.BOM_UTF16_BE):
            self.raw_decode = codecs.utf_16_be_decode
            self.encoding = 'utf-16-be'
        else:
            self.raw_decode = codecs.utf_8_decode
            self.encoding = 'utf-8'
    self.update(1)

def dispose(self):
    # Reset the state attributes (to clear self-references)
    self.states = []
    self.state = None

def fetch_alias(self):
    # ALIAS could be a simple key.
    self.save_possible_simple_key()
    # No simple keys after ALIAS.
    self.allow_simple_key = False
    # Scan and add ALIAS.
    self.tokens.append(self.scan_anchor(AliasToken))

def fetch_anchor(self):
    # ANCHOR could start a simple key.
    self.save_possible_simple_key()
    # No simple keys after ANCHOR.
    self.allow_simple_key = False
    # Scan and add ANCHOR.
    self.tokens.append(self.scan_anchor(AnchorToken))

def fetch_block_entry(self):
    # Block context needs additional checks.
    if not self.flow_level:
        # Are we allowed to start a new entry?
        if not self.allow_simple_key:
            raise ScannerError(None, None,
                    "sequence entries are not allowed here",
                    self.get_mark())
        # We may need to add BLOCK-SEQUENCE-START.
        if self.add_indent(self.column):
            mark = self.get_mark()
            self.tokens.append(BlockSequenceStartToken(mark, mark))
    # It's an error for the block entry to occur in the flow context,
    # but we let the parser detect this.
    else:
        pass
    # Simple keys are allowed after '-'.
    self.allow_simple_key = True
    # Reset possible simple key on the current level.
    self.remove_possible_simple_key()
    # Add BLOCK-ENTRY.
    start_mark = self.get_mark()
    self.forward()
    end_mark = self.get_mark()
    self.tokens.append(BlockEntryToken(start_mark, end_mark))

def fetch_block_scalar(self, style):
    # A simple key may follow a block scalar.
    self.allow_simple_key = True
    # Reset possible simple key on the current level.
    self.remove_possible_simple_key()
    # Scan and add SCALAR.
    self.tokens.append(self.scan_block_scalar(style))

def fetch_directive(self):
    
    # Set the current indentation to -1.
    self.unwind_indent(-1)
    # Reset simple keys.
    self.remove_possible_simple_key()
    self.allow_simple_key = False
    # Scan and add DIRECTIVE.
    self.tokens.append(self.scan_directive())

def fetch_document_end(self):
    self.fetch_document_indicator(DocumentEndToken)

def fetch_document_indicator(self, TokenClass):
    # Set the current indentation to -1.
    self.unwind_indent(-1)
    # Reset simple keys. Note that there could not be a block collection
    # after '---'.
    self.remove_possible_simple_key()
    self.allow_simple_key = False
    # Add DOCUMENT-START or DOCUMENT-END.
    start_mark = self.get_mark()
    self.forward(3)
    end_mark = self.get_mark()
    self.tokens.append(TokenClass(start_mark, end_mark))

def fetch_document_start(self):
    self.fetch_document_indicator(DocumentStartToken)

def fetch_double(self):
    self.fetch_flow_scalar(style='"')

def fetch_flow_collection_end(self, TokenClass):
    # Reset possible simple key on the current level.
    self.remove_possible_simple_key()
    # Decrease the flow level.
    self.flow_level -= 1
    # No simple keys after ']' or '}'.
    self.allow_simple_key = False
    # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END.
    start_mark = self.get_mark()
    self.forward()
    end_mark = self.get_mark()
    self.tokens.append(TokenClass(start_mark, end_mark))

def fetch_flow_collection_start(self, TokenClass):
    # '[' and '{' may start a simple key.
    self.save_possible_simple_key()
    # Increase the flow level.
    self.flow_level += 1
    # Simple keys are allowed after '[' and '{'.
    self.allow_simple_key = True
    # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START.
    start_mark = self.get_mark()
    self.forward()
    end_mark = self.get_mark()
    self.tokens.append(TokenClass(start_mark, end_mark))

def fetch_flow_entry(self):
    # Simple keys are allowed after ','.
    self.allow_simple_key = True
    # Reset possible simple key on the current level.
    self.remove_possible_simple_key()
    # Add FLOW-ENTRY.
    start_mark = self.get_mark()
    self.forward()
    end_mark = self.get_mark()
    self.tokens.append(FlowEntryToken(start_mark, end_mark))

def fetch_flow_mapping_end(self):
    self.fetch_flow_collection_end(FlowMappingEndToken)

def fetch_flow_mapping_start(self):
    self.fetch_flow_collection_start(FlowMappingStartToken)

def fetch_flow_scalar(self, style):
    # A flow scalar could be a simple key.
    self.save_possible_simple_key()
    # No simple keys after flow scalars.
    self.allow_simple_key = False
    # Scan and add SCALAR.
    self.tokens.append(self.scan_flow_scalar(style))

def fetch_flow_sequence_end(self):
    self.fetch_flow_collection_end(FlowSequenceEndToken)

def fetch_flow_sequence_start(self):
    self.fetch_flow_collection_start(FlowSequenceStartToken)

def fetch_folded(self):
    self.fetch_block_scalar(style='>')

def fetch_key(self):
    
    # Block context needs additional checks.
    if not self.flow_level:
        # Are we allowed to start a key (not necessary a simple)?
        if not self.allow_simple_key:
            raise ScannerError(None, None,
                    "mapping keys are not allowed here",
                    self.get_mark())
        # We may need to add BLOCK-MAPPING-START.
        if self.add_indent(self.column):
            mark = self.get_mark()
            self.tokens.append(BlockMappingStartToken(mark, mark))
    # Simple keys are allowed after '?' in the block context.
    self.allow_simple_key = not self.flow_level
    # Reset possible simple key on the current level.
    self.remove_possible_simple_key()
    # Add KEY.
    start_mark = self.get_mark()
    self.forward()
    end_mark = self.get_mark()
    self.tokens.append(KeyToken(start_mark, end_mark))

def fetch_literal(self):
    self.fetch_block_scalar(style='|')

def fetch_more_tokens(self):
    # Eat whitespaces and comments until we reach the next token.
    self.scan_to_next_token()
    # Remove obsolete possible simple keys.
    self.stale_possible_simple_keys()
    # Compare the current indentation and column. It may add some tokens
    # and decrease the current indentation level.
    self.unwind_indent(self.column)
    # Peek the next character.
    ch = self.peek()
    # Is it the end of stream?
    if ch == '\0':
        return self.fetch_stream_end()
    # Is it a directive?
    if ch == '%' and self.check_directive():
        return self.fetch_directive()
    # Is it the document start?
    if ch == '-' and self.check_document_start():
        return self.fetch_document_start()
    # Is it the document end?
    if ch == '.' and self.check_document_end():
        return self.fetch_document_end()
    # TODO: support for BOM within a stream.
    #if ch == '\uFEFF':
    #    return self.fetch_bom()    <-- issue BOMToken
    # Note: the order of the following checks is NOT significant.
    # Is it the flow sequence start indicator?
    if ch == '[':
        return self.fetch_flow_sequence_start()
    # Is it the flow mapping start indicator?
    if ch == '{':
        return self.fetch_flow_mapping_start()
    # Is it the flow sequence end indicator?
    if ch == ']':
        return self.fetch_flow_sequence_end()
    # Is it the flow mapping end indicator?
    if ch == '}':
        return self.fetch_flow_mapping_end()
    # Is it the flow entry indicator?
    if ch == ',':
        return self.fetch_flow_entry()
    # Is it the block entry indicator?
    if ch == '-' and self.check_block_entry():
        return self.fetch_block_entry()
    # Is it the key indicator?
    if ch == '?' and self.check_key():
        return self.fetch_key()
    # Is it the value indicator?
    if ch == ':' and self.check_value():
        return self.fetch_value()
    # Is it an alias?
    if ch == '*':
        return self.fetch_alias()
    # Is it an anchor?
    if ch == '&':
        return self.fetch_anchor()
    # Is it a tag?
    if ch == '!':
        return self.fetch_tag()
    # Is it a literal scalar?
    if ch == '|' and not self.flow_level:
        return self.fetch_literal()
    # Is it a folded scalar?
    if ch == '>' and not self.flow_level:
        return self.fetch_folded()
    # Is it a single quoted scalar?
    if ch == '\'':
        return self.fetch_single()
    # Is it a double quoted scalar?
    if ch == '\"':
        return self.fetch_double()
    # It must be a plain scalar then.
    if self.check_plain():
        return self.fetch_plain()
    # No? It's an error. Let's produce a nice error message.
    raise ScannerError("while scanning for the next token", None,
            "found character %r that cannot start any token" % ch,
            self.get_mark())

def fetch_plain(self):
    # A plain scalar could be a simple key.
    self.save_possible_simple_key()
    # No simple keys after plain scalars. But note that `scan_plain` will
    # change this flag if the scan is finished at the beginning of the
    # line.
    self.allow_simple_key = False
    # Scan and add SCALAR. May change `allow_simple_key`.
    self.tokens.append(self.scan_plain())

def fetch_single(self):
    self.fetch_flow_scalar(style='\'')

def fetch_stream_end(self):
    # Set the current indentation to -1.
    self.unwind_indent(-1)
    # Reset simple keys.
    self.remove_possible_simple_key()
    self.allow_simple_key = False
    self.possible_simple_keys = {}
    # Read the token.
    mark = self.get_mark()
    
    # Add STREAM-END.
    self.tokens.append(StreamEndToken(mark, mark))
    # The steam is finished.
    self.done = True

def fetch_stream_start(self):
    # We always add STREAM-START as the first token and STREAM-END as the
    # last token.
    # Read the token.
    mark = self.get_mark()
    
    # Add STREAM-START.
    self.tokens.append(StreamStartToken(mark, mark,
        encoding=self.encoding))

def fetch_tag(self):
    # TAG could start a simple key.
    self.save_possible_simple_key()
    # No simple keys after TAG.
    self.allow_simple_key = False
    # Scan and add TAG.
    self.tokens.append(self.scan_tag())

def fetch_value(self):
    # Do we determine a simple key?
    if self.flow_level in self.possible_simple_keys:
        # Add KEY.
        key = self.possible_simple_keys[self.flow_level]
        del self.possible_simple_keys[self.flow_level]
        self.tokens.insert(key.token_number-self.tokens_taken,
                KeyToken(key.mark, key.mark))
        # If this key starts a new block mapping, we need to add
        # BLOCK-MAPPING-START.
        if not self.flow_level:
            if self.add_indent(key.column):
                self.tokens.insert(key.token_number-self.tokens_taken,
                        BlockMappingStartToken(key.mark, key.mark))
        # There cannot be two simple keys one after another.
        self.allow_simple_key = False
    # It must be a part of a complex key.
    else:
        
        # Block context needs additional checks.
        # (Do we really need them? They will be caught by the parser
        # anyway.)
        if not self.flow_level:
            # We are allowed to start a complex value if and only if
            # we can start a simple key.
            if not self.allow_simple_key:
                raise ScannerError(None, None,
                        "mapping values are not allowed here",
                        self.get_mark())
        # If this value starts a new block mapping, we need to add
        # BLOCK-MAPPING-START.  It will be detected as an error later by
        # the parser.
        if not self.flow_level:
            if self.add_indent(self.column):
                mark = self.get_mark()
                self.tokens.append(BlockMappingStartToken(mark, mark))
        # Simple keys are allowed after ':' in the block context.
        self.allow_simple_key = not self.flow_level
        # Reset possible simple key on the current level.
        self.remove_possible_simple_key()
    # Add VALUE.
    start_mark = self.get_mark()
    self.forward()
    end_mark = self.get_mark()
    self.tokens.append(ValueToken(start_mark, end_mark))

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 forward(self, length=1):
    if self.pointer+length+1 >= len(self.buffer):
        self.update(length+1)
    while length:
        ch = self.buffer[self.pointer]
        self.pointer += 1
        self.index += 1
        if ch in '\n\x85\u2028\u2029'  \
                or (ch == '\r' and self.buffer[self.pointer] != '\n'):
            self.line += 1
            self.column = 0
        elif ch != '\uFEFF':
            self.column += 1
        length -= 1

def get_data(self):
    # Construct and return the next document.
    if self.check_node():
        return self.construct_document(self.get_node())

def get_event(self):
    # Get the next event and proceed further.
    if self.current_event is None:
        if self.state:
            self.current_event = self.state()
    value = self.current_event
    self.current_event = None
    return value

def get_mark(self):
    if self.stream is None:
        return Mark(self.name, self.index, self.line, self.column,
                self.buffer, self.pointer)
    else:
        return Mark(self.name, self.index, self.line, self.column,
                None, None)

def get_node(self):
    # Get the root node of the next document.
    if not self.check_event(StreamEndEvent):
        return self.compose_document()

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 get_single_node(self):
    # Drop the STREAM-START event.
    self.get_event()
    # Compose a document if the stream is not empty.
    document = None
    if not self.check_event(StreamEndEvent):
        document = self.compose_document()
    # Ensure that the stream contains no more documents.
    if not self.check_event(StreamEndEvent):
        event = self.get_event()
        raise ComposerError("expected a single document in the stream",
                document.start_mark, "but found another document",
                event.start_mark)
    # Drop the STREAM-END event.
    self.get_event()
    return document

def get_token(self):
    # Return the next token.
    while self.need_more_tokens():
        self.fetch_more_tokens()
    if self.tokens:
        self.tokens_taken += 1
        return self.tokens.pop(0)

def include(self, node):
    file = self.construct_scalar(node)
    filename = self._get_filename(file)
    if filename is None and self._root is None:
        raise ValueError("'{}' cannot be included. If the YAML input is a string, '!include' only supports absolute paths.".format(file))
    with open(filename, 'r') as f:
        return yaml.load(f, self.__class__)

def include_merge_list(self, node):
    if self._root is None:
        warnings.warn("If the YAML input is a string, '!include_merge_list' only supports absolute paths.")
    files = self.construct_sequence(node)
    a = []
    for file in files:
        filename = self._get_filename(file)
        if filename is None:
            a.append(file)
        else:
            try:
                with open(filename, 'r') as f:
                    a += yaml.load(f, self.__class__)
            except OSError as e:
                if e.errno in [errno.ENOENT, errno.EINVAL, errno.EISDIR]:
                    # ENOENT: FileNotFoundError
                    # EINVAL: Invalid argument
                    # EISDIR: IsADirectoryError
                    a.append(file)
                else:
                    raise
    return a

def need_more_tokens(self):
    if self.done:
        return False
    if not self.tokens:
        return True
    # The current token may be a potential simple key, so we
    # need to look further.
    self.stale_possible_simple_keys()
    if self.next_possible_simple_key() == self.tokens_taken:
        return True

def next_possible_simple_key(self):
    # Return the number of the nearest possible simple key. Actually we
    # don't need to loop through the whole dictionary. We may replace it
    # with the following code:
    #   if not self.possible_simple_keys:
    #       return None
    #   return self.possible_simple_keys[
    #           min(self.possible_simple_keys.keys())].token_number
    min_token_number = None
    for level in self.possible_simple_keys:
        key = self.possible_simple_keys[level]
        if min_token_number is None or key.token_number < min_token_number:
            min_token_number = key.token_number
    return min_token_number

def parse_block_mapping_first_key(self):
    token = self.get_token()
    self.marks.append(token.start_mark)
    return self.parse_block_mapping_key()

def parse_block_mapping_key(self):
    if self.check_token(KeyToken):
        token = self.get_token()
        if not self.check_token(KeyToken, ValueToken, BlockEndToken):
            self.states.append(self.parse_block_mapping_value)
            return self.parse_block_node_or_indentless_sequence()
        else:
            self.state = self.parse_block_mapping_value
            return self.process_empty_scalar(token.end_mark)
    if not self.check_token(BlockEndToken):
        token = self.peek_token()
        raise ParserError("while parsing a block mapping", self.marks[-1],
                "expected <block end>, but found %r" % token.id, token.start_mark)
    token = self.get_token()
    event = MappingEndEvent(token.start_mark, token.end_mark)
    self.state = self.states.pop()
    self.marks.pop()
    return event

def parse_block_mapping_value(self):
    if self.check_token(ValueToken):
        token = self.get_token()
        if not self.check_token(KeyToken, ValueToken, BlockEndToken):
            self.states.append(self.parse_block_mapping_key)
            return self.parse_block_node_or_indentless_sequence()
        else:
            self.state = self.parse_block_mapping_key
            return self.process_empty_scalar(token.end_mark)
    else:
        self.state = self.parse_block_mapping_key
        token = self.peek_token()
        return self.process_empty_scalar(token.start_mark)

def parse_block_node(self):
    return self.parse_node(block=True)

def parse_block_node_or_indentless_sequence(self):
    return self.parse_node(block=True, indentless_sequence=True)

def parse_block_sequence_entry(self):
    if self.check_token(BlockEntryToken):
        token = self.get_token()
        if not self.check_token(BlockEntryToken, BlockEndToken):
            self.states.append(self.parse_block_sequence_entry)
            return self.parse_block_node()
        else:
            self.state = self.parse_block_sequence_entry
            return self.process_empty_scalar(token.end_mark)
    if not self.check_token(BlockEndToken):
        token = self.peek_token()
        raise ParserError("while parsing a block collection", self.marks[-1],
                "expected <block end>, but found %r" % token.id, token.start_mark)
    token = self.get_token()
    event = SequenceEndEvent(token.start_mark, token.end_mark)
    self.state = self.states.pop()
    self.marks.pop()
    return event

def parse_block_sequence_first_entry(self):
    token = self.get_token()
    self.marks.append(token.start_mark)
    return self.parse_block_sequence_entry()

def parse_document_content(self):
    if self.check_token(DirectiveToken,
            DocumentStartToken, DocumentEndToken, StreamEndToken):
        event = self.process_empty_scalar(self.peek_token().start_mark)
        self.state = self.states.pop()
        return event
    else:
        return self.parse_block_node()

def parse_document_end(self):
    # Parse the document end.
    token = self.peek_token()
    start_mark = end_mark = token.start_mark
    explicit = False
    if self.check_token(DocumentEndToken):
        token = self.get_token()
        end_mark = token.end_mark
        explicit = True
    event = DocumentEndEvent(start_mark, end_mark,
            explicit=explicit)
    # Prepare the next state.
    self.state = self.parse_document_start
    return event