

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: emitter.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>
# Emitter expects events obeying the following grammar:
# stream ::= STREAM-START document* STREAM-END
# document ::= DOCUMENT-START node DOCUMENT-END
# node ::= SCALAR | sequence | mapping
# sequence ::= SEQUENCE-START node* SEQUENCE-END
# mapping ::= MAPPING-START (node node)* MAPPING-END

__all__ = [&#039;Emitter&#039;, &#039;EmitterError&#039;]

from .error import YAMLError
from .events import *

class EmitterError(YAMLError):
    pass

class ScalarAnalysis:
    def __init__(self, scalar, empty, multiline,
            allow_flow_plain, allow_block_plain,
            allow_single_quoted, allow_double_quoted,
            allow_block):
        self.scalar = scalar
        self.empty = empty
        self.multiline = multiline
        self.allow_flow_plain = allow_flow_plain
        self.allow_block_plain = allow_block_plain
        self.allow_single_quoted = allow_single_quoted
        self.allow_double_quoted = allow_double_quoted
        self.allow_block = allow_block

class Emitter:

    DEFAULT_TAG_PREFIXES = {
        &#039;!&#039; : &#039;!&#039;,
        &#039;tag:yaml.org,2002:&#039; : &#039;!!&#039;,
    }

    def __init__(self, stream, canonical=None, indent=None, width=None,
            allow_unicode=None, line_break=None):

        # The stream should have the methods `write` and possibly `flush`.
        self.stream = stream

        # Encoding can be overriden by STREAM-START.
        self.encoding = None

        # Emitter is a state machine with a stack of states to handle nested
        # structures.
        self.states = []
        self.state = self.expect_stream_start

        # Current event and the event queue.
        self.events = []
        self.event = None

        # The current indentation level and the stack of previous indents.
        self.indents = []
        self.indent = None

        # Flow level.
        self.flow_level = 0

        # Contexts.
        self.root_context = False
        self.sequence_context = False
        self.mapping_context = False
        self.simple_key_context = False

        # Characteristics of the last emitted character:
        #  - current position.
        #  - is it a whitespace?
        #  - is it an indention character
        #    (indentation space, &#039;-&#039;, &#039;?&#039;, or &#039;:&#039;)?
        self.line = 0
        self.column = 0
        self.whitespace = True
        self.indention = True

        # Whether the document requires an explicit document indicator
        self.open_ended = False

        # Formatting details.
        self.canonical = canonical
        self.allow_unicode = allow_unicode
        self.best_indent = 2
        if indent and 1 &lt; indent &lt; 10:
            self.best_indent = indent
        self.best_width = 80
        if width and width &gt; self.best_indent*2:
            self.best_width = width
        self.best_line_break = &#039;\n&#039;
        if line_break in [&#039;\r&#039;, &#039;\n&#039;, &#039;\r\n&#039;]:
            self.best_line_break = line_break

        # Tag prefixes.
        self.tag_prefixes = None

        # Prepared anchor and tag.
        self.prepared_anchor = None
        self.prepared_tag = None

        # Scalar analysis and style.
        self.analysis = None
        self.style = None

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

    def emit(self, event):
        self.events.append(event)
        while not self.need_more_events():
            self.event = self.events.pop(0)
            self.state()
            self.event = None

    # In some cases, we wait for a few next events before emitting.

    def need_more_events(self):
        if not self.events:
            return True
        event = self.events[0]
        if isinstance(event, DocumentStartEvent):
            return self.need_events(1)
        elif isinstance(event, SequenceStartEvent):
            return self.need_events(2)
        elif isinstance(event, MappingStartEvent):
            return self.need_events(3)
        else:
            return False

    def need_events(self, count):
        level = 0
        for event in self.events[1:]:
            if isinstance(event, (DocumentStartEvent, CollectionStartEvent)):
                level += 1
            elif isinstance(event, (DocumentEndEvent, CollectionEndEvent)):
                level -= 1
            elif isinstance(event, StreamEndEvent):
                level = -1
            if level &lt; 0:
                return False
        return (len(self.events) &lt; count+1)

    def increase_indent(self, flow=False, indentless=False):
        self.indents.append(self.indent)
        if self.indent is None:
            if flow:
                self.indent = self.best_indent
            else:
                self.indent = 0
        elif not indentless:
            self.indent += self.best_indent

    # States.

    # Stream handlers.

    def expect_stream_start(self):
        if isinstance(self.event, StreamStartEvent):
            if self.event.encoding and not hasattr(self.stream, &#039;encoding&#039;):
                self.encoding = self.event.encoding
            self.write_stream_start()
            self.state = self.expect_first_document_start
        else:
            raise EmitterError(&quot;expected StreamStartEvent, but got %s&quot;
                    % self.event)

    def expect_nothing(self):
        raise EmitterError(&quot;expected nothing, but got %s&quot; % self.event)

    # Document handlers.

    def expect_first_document_start(self):
        return self.expect_document_start(first=True)

    def expect_document_start(self, first=False):
        if isinstance(self.event, DocumentStartEvent):
            if (self.event.version or self.event.tags) and self.open_ended:
                self.write_indicator(&#039;...&#039;, True)
                self.write_indent()
            if self.event.version:
                version_text = self.prepare_version(self.event.version)
                self.write_version_directive(version_text)
            self.tag_prefixes = self.DEFAULT_TAG_PREFIXES.copy()
            if self.event.tags:
                handles = sorted(self.event.tags.keys())
                for handle in handles:
                    prefix = self.event.tags[handle]
                    self.tag_prefixes[prefix] = handle
                    handle_text = self.prepare_tag_handle(handle)
                    prefix_text = self.prepare_tag_prefix(prefix)
                    self.write_tag_directive(handle_text, prefix_text)
            implicit = (first and not self.event.explicit and not self.canonical
                    and not self.event.version and not self.event.tags
                    and not self.check_empty_document())
            if not implicit:
                self.write_indent()
                self.write_indicator(&#039;---&#039;, True)
                if self.canonical:
                    self.write_indent()
            self.state = self.expect_document_root
        elif isinstance(self.event, StreamEndEvent):
            if self.open_ended:
                self.write_indicator(&#039;...&#039;, True)
                self.write_indent()
            self.write_stream_end()
            self.state = self.expect_nothing
        else:
            raise EmitterError(&quot;expected DocumentStartEvent, but got %s&quot;
                    % self.event)

    def expect_document_end(self):
        if isinstance(self.event, DocumentEndEvent):
            self.write_indent()
            if self.event.explicit:
                self.write_indicator(&#039;...&#039;, True)
                self.write_indent()
            self.flush_stream()
            self.state = self.expect_document_start
        else:
            raise EmitterError(&quot;expected DocumentEndEvent, but got %s&quot;
                    % self.event)

    def expect_document_root(self):
        self.states.append(self.expect_document_end)
        self.expect_node(root=True)

    # Node handlers.

    def expect_node(self, root=False, sequence=False, mapping=False,
            simple_key=False):
        self.root_context = root
        self.sequence_context = sequence
        self.mapping_context = mapping
        self.simple_key_context = simple_key
        if isinstance(self.event, AliasEvent):
            self.expect_alias()
        elif isinstance(self.event, (ScalarEvent, CollectionStartEvent)):
            self.process_anchor(&#039;&amp;&#039;)
            self.process_tag()
            if isinstance(self.event, ScalarEvent):
                self.expect_scalar()
            elif isinstance(self.event, SequenceStartEvent):
                if self.flow_level or self.canonical or self.event.flow_style   \
                        or self.check_empty_sequence():
                    self.expect_flow_sequence()
                else:
                    self.expect_block_sequence()
            elif isinstance(self.event, MappingStartEvent):
                if self.flow_level or self.canonical or self.event.flow_style   \
                        or self.check_empty_mapping():
                    self.expect_flow_mapping()
                else:
                    self.expect_block_mapping()
        else:
            raise EmitterError(&quot;expected NodeEvent, but got %s&quot; % self.event)

    def expect_alias(self):
        if self.event.anchor is None:
            raise EmitterError(&quot;anchor is not specified for alias&quot;)
        self.process_anchor(&#039;*&#039;)
        self.state = self.states.pop()

    def expect_scalar(self):
        self.increase_indent(flow=True)
        self.process_scalar()
        self.indent = self.indents.pop()
        self.state = self.states.pop()

    # Flow sequence handlers.

    def expect_flow_sequence(self):
        self.write_indicator(&#039;[&#039;, True, whitespace=True)
        self.flow_level += 1
        self.increase_indent(flow=True)
        self.state = self.expect_first_flow_sequence_item

    def expect_first_flow_sequence_item(self):
        if isinstance(self.event, SequenceEndEvent):
            self.indent = self.indents.pop()
            self.flow_level -= 1
            self.write_indicator(&#039;]&#039;, False)
            self.state = self.states.pop()
        else:
            if self.canonical or self.column &gt; self.best_width:
                self.write_indent()
            self.states.append(self.expect_flow_sequence_item)
            self.expect_node(sequence=True)

    def expect_flow_sequence_item(self):
        if isinstance(self.event, SequenceEndEvent):
            self.indent = self.indents.pop()
            self.flow_level -= 1
            if self.canonical:
                self.write_indicator(&#039;,&#039;, False)
                self.write_indent()
            self.write_indicator(&#039;]&#039;, False)
            self.state = self.states.pop()
        else:
            self.write_indicator(&#039;,&#039;, False)
            if self.canonical or self.column &gt; self.best_width:
                self.write_indent()
            self.states.append(self.expect_flow_sequence_item)
            self.expect_node(sequence=True)

    # Flow mapping handlers.

    def expect_flow_mapping(self):
        self.write_indicator(&#039;{&#039;, True, whitespace=True)
        self.flow_level += 1
        self.increase_indent(flow=True)
        self.state = self.expect_first_flow_mapping_key

    def expect_first_flow_mapping_key(self):
        if isinstance(self.event, MappingEndEvent):
            self.indent = self.indents.pop()
            self.flow_level -= 1
            self.write_indicator(&#039;}&#039;, False)
            self.state = self.states.pop()
        else:
            if self.canonical or self.column &gt; self.best_width:
                self.write_indent()
            if not self.canonical and self.check_simple_key():
                self.states.append(self.expect_flow_mapping_simple_value)
                self.expect_node(mapping=True, simple_key=True)
            else:
                self.write_indicator(&#039;?&#039;, True)
                self.states.append(self.expect_flow_mapping_value)
                self.expect_node(mapping=True)

    def expect_flow_mapping_key(self):
        if isinstance(self.event, MappingEndEvent):
            self.indent = self.indents.pop()
            self.flow_level -= 1
            if self.canonical:
                self.write_indicator(&#039;,&#039;, False)
                self.write_indent()
            self.write_indicator(&#039;}&#039;, False)
            self.state = self.states.pop()
        else:
            self.write_indicator(&#039;,&#039;, False)
            if self.canonical or self.column &gt; self.best_width:
                self.write_indent()
            if not self.canonical and self.check_simple_key():
                self.states.append(self.expect_flow_mapping_simple_value)
                self.expect_node(mapping=True, simple_key=True)
            else:
                self.write_indicator(&#039;?&#039;, True)
                self.states.append(self.expect_flow_mapping_value)
                self.expect_node(mapping=True)

    def expect_flow_mapping_simple_value(self):
        self.write_indicator(&#039;:&#039;, False)
        self.states.append(self.expect_flow_mapping_key)
        self.expect_node(mapping=True)

    def expect_flow_mapping_value(self):
        if self.canonical or self.column &gt; self.best_width:
            self.write_indent()
        self.write_indicator(&#039;:&#039;, True)
        self.states.append(self.expect_flow_mapping_key)
        self.expect_node(mapping=True)

    # Block sequence handlers.

    def expect_block_sequence(self):
        indentless = (self.mapping_context and not self.indention)
        self.increase_indent(flow=False, indentless=indentless)
        self.state = self.expect_first_block_sequence_item

    def expect_first_block_sequence_item(self):
        return self.expect_block_sequence_item(first=True)

    def expect_block_sequence_item(self, first=False):
        if not first and isinstance(self.event, SequenceEndEvent):
            self.indent = self.indents.pop()
            self.state = self.states.pop()
        else:
            self.write_indent()
            self.write_indicator(&#039;-&#039;, True, indention=True)
            self.states.append(self.expect_block_sequence_item)
            self.expect_node(sequence=True)

    # Block mapping handlers.

    def expect_block_mapping(self):
        self.increase_indent(flow=False)
        self.state = self.expect_first_block_mapping_key

    def expect_first_block_mapping_key(self):
        return self.expect_block_mapping_key(first=True)

    def expect_block_mapping_key(self, first=False):
        if not first and isinstance(self.event, MappingEndEvent):
            self.indent = self.indents.pop()
            self.state = self.states.pop()
        else:
            self.write_indent()
            if self.check_simple_key():
                self.states.append(self.expect_block_mapping_simple_value)
                self.expect_node(mapping=True, simple_key=True)
            else:
                self.write_indicator(&#039;?&#039;, True, indention=True)
                self.states.append(self.expect_block_mapping_value)
                self.expect_node(mapping=True)

    def expect_block_mapping_simple_value(self):
        self.write_indicator(&#039;:&#039;, False)
        self.states.append(self.expect_block_mapping_key)
        self.expect_node(mapping=True)

    def expect_block_mapping_value(self):
        self.write_indent()
        self.write_indicator(&#039;:&#039;, True, indention=True)
        self.states.append(self.expect_block_mapping_key)
        self.expect_node(mapping=True)

    # Checkers.

    def check_empty_sequence(self):
        return (isinstance(self.event, SequenceStartEvent) and self.events
                and isinstance(self.events[0], SequenceEndEvent))

    def check_empty_mapping(self):
        return (isinstance(self.event, MappingStartEvent) and self.events
                and isinstance(self.events[0], MappingEndEvent))

    def check_empty_document(self):
        if not isinstance(self.event, DocumentStartEvent) or not self.events:
            return False
        event = self.events[0]
        return (isinstance(event, ScalarEvent) and event.anchor is None
                and event.tag is None and event.implicit and event.value == &#039;&#039;)

    def check_simple_key(self):
        length = 0
        if isinstance(self.event, NodeEvent) and self.event.anchor is not None:
            if self.prepared_anchor is None:
                self.prepared_anchor = self.prepare_anchor(self.event.anchor)
            length += len(self.prepared_anchor)
        if isinstance(self.event, (ScalarEvent, CollectionStartEvent))  \
                and self.event.tag is not None:
            if self.prepared_tag is None:
                self.prepared_tag = self.prepare_tag(self.event.tag)
            length += len(self.prepared_tag)
        if isinstance(self.event, ScalarEvent):
            if self.analysis is None:
                self.analysis = self.analyze_scalar(self.event.value)
            length += len(self.analysis.scalar)
        return (length &lt; 128 and (isinstance(self.event, AliasEvent)
            or (isinstance(self.event, ScalarEvent)
                    and not self.analysis.empty and not self.analysis.multiline)
            or self.check_empty_sequence() or self.check_empty_mapping()))

    # Anchor, Tag, and Scalar processors.

    def process_anchor(self, indicator):
        if self.event.anchor is None:
            self.prepared_anchor = None
            return
        if self.prepared_anchor is None:
            self.prepared_anchor = self.prepare_anchor(self.event.anchor)
        if self.prepared_anchor:
            self.write_indicator(indicator+self.prepared_anchor, True)
        self.prepared_anchor = None

    def process_tag(self):
        tag = self.event.tag
        if isinstance(self.event, ScalarEvent):
            if self.style is None:
                self.style = self.choose_scalar_style()
            if ((not self.canonical or tag is None) and
                ((self.style == &#039;&#039; and self.event.implicit[0])
                        or (self.style != &#039;&#039; and self.event.implicit[1]))):
                self.prepared_tag = None
                return
            if self.event.implicit[0] and tag is None:
                tag = &#039;!&#039;
                self.prepared_tag = None
        else:
            if (not self.canonical or tag is None) and self.event.implicit:
                self.prepared_tag = None
                return
        if tag is None:
            raise EmitterError(&quot;tag is not specified&quot;)
        if self.prepared_tag is None:
            self.prepared_tag = self.prepare_tag(tag)
        if self.prepared_tag:
            self.write_indicator(self.prepared_tag, True)
        self.prepared_tag = None

    def choose_scalar_style(self):
        if self.analysis is None:
            self.analysis = self.analyze_scalar(self.event.value)
        if self.event.style == &#039;&quot;&#039; or self.canonical:
            return &#039;&quot;&#039;
        if not self.event.style and self.event.implicit[0]:
            if (not (self.simple_key_context and
                    (self.analysis.empty or self.analysis.multiline))
                and (self.flow_level and self.analysis.allow_flow_plain
                    or (not self.flow_level and self.analysis.allow_block_plain))):
                return &#039;&#039;
        if self.event.style and self.event.style in &#039;|&gt;&#039;:
            if (not self.flow_level and not self.simple_key_context
                    and self.analysis.allow_block):
                return self.event.style
        if not self.event.style or self.event.style == &#039;\&#039;&#039;:
            if (self.analysis.allow_single_quoted and
                    not (self.simple_key_context and self.analysis.multiline)):
                return &#039;\&#039;&#039;
        return &#039;&quot;&#039;

    def process_scalar(self):
        if self.analysis is None:
            self.analysis = self.analyze_scalar(self.event.value)
        if self.style is None:
            self.style = self.choose_scalar_style()
        split = (not self.simple_key_context)
        #if self.analysis.multiline and split    \
        #        and (not self.style or self.style in &#039;\&#039;\&quot;&#039;):
        #    self.write_indent()
        if self.style == &#039;&quot;&#039;:
            self.write_double_quoted(self.analysis.scalar, split)
        elif self.style == &#039;\&#039;&#039;:
            self.write_single_quoted(self.analysis.scalar, split)
        elif self.style == &#039;&gt;&#039;:
            self.write_folded(self.analysis.scalar)
        elif self.style == &#039;|&#039;:
            self.write_literal(self.analysis.scalar)
        else:
            self.write_plain(self.analysis.scalar, split)
        self.analysis = None
        self.style = None

    # Analyzers.

    def prepare_version(self, version):
        major, minor = version
        if major != 1:
            raise EmitterError(&quot;unsupported YAML version: %d.%d&quot; % (major, minor))
        return &#039;%d.%d&#039; % (major, minor)

    def prepare_tag_handle(self, handle):
        if not handle:
            raise EmitterError(&quot;tag handle must not be empty&quot;)
        if handle[0] != &#039;!&#039; or handle[-1] != &#039;!&#039;:
            raise EmitterError(&quot;tag handle must start and end with &#039;!&#039;: %r&quot; % handle)
        for ch in handle[1:-1]:
            if not (&#039;0&#039; &lt;= ch &lt;= &#039;9&#039; or &#039;A&#039; &lt;= ch &lt;= &#039;Z&#039; or &#039;a&#039; &lt;= ch &lt;= &#039;z&#039;    \
                    or ch in &#039;-_&#039;):
                raise EmitterError(&quot;invalid character %r in the tag handle: %r&quot;
                        % (ch, handle))
        return handle

    def prepare_tag_prefix(self, prefix):
        if not prefix:
            raise EmitterError(&quot;tag prefix must not be empty&quot;)
        chunks = []
        start = end = 0
        if prefix[0] == &#039;!&#039;:
            end = 1
        while end &lt; len(prefix):
            ch = prefix[end]
            if &#039;0&#039; &lt;= ch &lt;= &#039;9&#039; or &#039;A&#039; &lt;= ch &lt;= &#039;Z&#039; or &#039;a&#039; &lt;= ch &lt;= &#039;z&#039; \
                    or ch in &#039;-;/?!:@&amp;=+$,_.~*\&#039;()[]&#039;:
                end += 1
            else:
                if start &lt; end:
                    chunks.append(prefix[start:end])
                start = end = end+1
                data = ch.encode(&#039;utf-8&#039;)
                for ch in data:
                    chunks.append(&#039;%%%02X&#039; % ord(ch))
        if start &lt; end:
            chunks.append(prefix[start:end])
        return &#039;&#039;.join(chunks)

    def prepare_tag(self, tag):
        if not tag:
            raise EmitterError(&quot;tag must not be empty&quot;)
        if tag == &#039;!&#039;:
            return tag
        handle = None
        suffix = tag
        prefixes = sorted(self.tag_prefixes.keys())
        for prefix in prefixes:
            if tag.startswith(prefix)   \
                    and (prefix == &#039;!&#039; or len(prefix) &lt; len(tag)):
                handle = self.tag_prefixes[prefix]
                suffix = tag[len(prefix):]
        chunks = []
        start = end = 0
        while end &lt; len(suffix):
            ch = suffix[end]
            if &#039;0&#039; &lt;= ch &lt;= &#039;9&#039; or &#039;A&#039; &lt;= ch &lt;= &#039;Z&#039; or &#039;a&#039; &lt;= ch &lt;= &#039;z&#039; \
                    or ch in &#039;-;/?:@&amp;=+$,_.~*\&#039;()[]&#039;   \
                    or (ch == &#039;!&#039; and handle != &#039;!&#039;):
                end += 1
            else:
                if start &lt; end:
                    chunks.append(suffix[start:end])
                start = end = end+1
                data = ch.encode(&#039;utf-8&#039;)
                for ch in data:
                    chunks.append(&#039;%%%02X&#039; % ord(ch))
        if start &lt; end:
            chunks.append(suffix[start:end])
        suffix_text = &#039;&#039;.join(chunks)
        if handle:
            return &#039;%s%s&#039; % (handle, suffix_text)
        else:
            return &#039;!&lt;%s&gt;&#039; % suffix_text

    def prepare_anchor(self, anchor):
        if not anchor:
            raise EmitterError(&quot;anchor must not be empty&quot;)
        for ch in anchor:
            if not (&#039;0&#039; &lt;= ch &lt;= &#039;9&#039; or &#039;A&#039; &lt;= ch &lt;= &#039;Z&#039; or &#039;a&#039; &lt;= ch &lt;= &#039;z&#039;    \
                    or ch in &#039;-_&#039;):
                raise EmitterError(&quot;invalid character %r in the anchor: %r&quot;
                        % (ch, anchor))
        return anchor

    def analyze_scalar(self, scalar):

        # Empty scalar is a special case.
        if not scalar:
            return ScalarAnalysis(scalar=scalar, empty=True, multiline=False,
                    allow_flow_plain=False, allow_block_plain=True,
                    allow_single_quoted=True, allow_double_quoted=True,
                    allow_block=False)

        # Indicators and special characters.
        block_indicators = False
        flow_indicators = False
        line_breaks = False
        special_characters = False

        # Important whitespace combinations.
        leading_space = False
        leading_break = False
        trailing_space = False
        trailing_break = False
        break_space = False
        space_break = False

        # Check document indicators.
        if scalar.startswith(&#039;---&#039;) or scalar.startswith(&#039;...&#039;):
            block_indicators = True
            flow_indicators = True

        # First character or preceded by a whitespace.
        preceeded_by_whitespace = True

        # Last character or followed by a whitespace.
        followed_by_whitespace = (len(scalar) == 1 or
                scalar[1] in &#039;\0 \t\r\n\x85\u2028\u2029&#039;)

        # The previous character is a space.
        previous_space = False

        # The previous character is a break.
        previous_break = False

        index = 0
        while index &lt; len(scalar):
            ch = scalar[index]

            # Check for indicators.
            if index == 0:
                # Leading indicators are special characters.
                if ch in &#039;#,[]{}&amp;*!|&gt;\&#039;\&quot;%@`&#039;: 
                    flow_indicators = True
                    block_indicators = True
                if ch in &#039;?:&#039;:
                    flow_indicators = True
                    if followed_by_whitespace:
                        block_indicators = True
                if ch == &#039;-&#039; and followed_by_whitespace:
                    flow_indicators = True
                    block_indicators = True
            else:
                # Some indicators cannot appear within a scalar as well.
                if ch in &#039;,?[]{}&#039;:
                    flow_indicators = True
                if ch == &#039;:&#039;:
                    flow_indicators = True
                    if followed_by_whitespace:
                        block_indicators = True
                if ch == &#039;#&#039; and preceeded_by_whitespace:
                    flow_indicators = True
                    block_indicators = True

            # Check for line breaks, special, and unicode characters.
            if ch in &#039;\n\x85\u2028\u2029&#039;:
                line_breaks = True
            if not (ch == &#039;\n&#039; or &#039;\x20&#039; &lt;= ch &lt;= &#039;\x7E&#039;):
                if (ch == &#039;\x85&#039; or &#039;\xA0&#039; &lt;= ch &lt;= &#039;\uD7FF&#039;
                        or &#039;\uE000&#039; &lt;= ch &lt;= &#039;\uFFFD&#039;) and ch != &#039;\uFEFF&#039;:
                    unicode_characters = True
                    if not self.allow_unicode:
                        special_characters = True
                else:
                    special_characters = True

            # Detect important whitespace combinations.
            if ch == &#039; &#039;:
                if index == 0:
                    leading_space = True
                if index == len(scalar)-1:
                    trailing_space = True
                if previous_break:
                    break_space = True
                previous_space = True
                previous_break = False
            elif ch in &#039;\n\x85\u2028\u2029&#039;:
                if index == 0:
                    leading_break = True
                if index == len(scalar)-1:
                    trailing_break = True
                if previous_space:
                    space_break = True
                previous_space = False
                previous_break = True
            else:
                previous_space = False
                previous_break = False

            # Prepare for the next character.
            index += 1
            preceeded_by_whitespace = (ch in &#039;\0 \t\r\n\x85\u2028\u2029&#039;)
            followed_by_whitespace = (index+1 &gt;= len(scalar) or
                    scalar[index+1] in &#039;\0 \t\r\n\x85\u2028\u2029&#039;)

        # Let&#039;s decide what styles are allowed.
        allow_flow_plain = True
        allow_block_plain = True
        allow_single_quoted = True
        allow_double_quoted = True
        allow_block = True

        # Leading and trailing whitespaces are bad for plain scalars.
        if (leading_space or leading_break
                or trailing_space or trailing_break):
            allow_flow_plain = allow_block_plain = False

        # We do not permit trailing spaces for block scalars.
        if trailing_space:
            allow_block = False

        # Spaces at the beginning of a new line are only acceptable for block
        # scalars.
        if break_space:
            allow_flow_plain = allow_block_plain = allow_single_quoted = False

        # Spaces followed by breaks, as well as special character are only
        # allowed for double quoted scalars.
        if space_break or special_characters:
            allow_flow_plain = allow_block_plain =  \
            allow_single_quoted = allow_block = False

        # Although the plain scalar writer supports breaks, we never emit
        # multiline plain scalars.
        if line_breaks:
            allow_flow_plain = allow_block_plain = False

        # Flow indicators are forbidden for flow plain scalars.
        if flow_indicators:
            allow_flow_plain = False

        # Block indicators are forbidden for block plain scalars.
        if block_indicators:
            allow_block_plain = False

        return ScalarAnalysis(scalar=scalar,
                empty=False, multiline=line_breaks,
                allow_flow_plain=allow_flow_plain,
                allow_block_plain=allow_block_plain,
                allow_single_quoted=allow_single_quoted,
                allow_double_quoted=allow_double_quoted,
                allow_block=allow_block)

    # Writers.

    def flush_stream(self):
        if hasattr(self.stream, &#039;flush&#039;):
            self.stream.flush()

    def write_stream_start(self):
        # Write BOM if needed.
        if self.encoding and self.encoding.startswith(&#039;utf-16&#039;):
            self.stream.write(&#039;\uFEFF&#039;.encode(self.encoding))

    def write_stream_end(self):
        self.flush_stream()

    def write_indicator(self, indicator, need_whitespace,
            whitespace=False, indention=False):
        if self.whitespace or not need_whitespace:
            data = indicator
        else:
            data = &#039; &#039;+indicator
        self.whitespace = whitespace
        self.indention = self.indention and indention
        self.column += len(data)
        self.open_ended = False
        if self.encoding:
            data = data.encode(self.encoding)
        self.stream.write(data)

    def write_indent(self):
        indent = self.indent or 0
        if not self.indention or self.column &gt; indent   \
                or (self.column == indent and not self.whitespace):
            self.write_line_break()
        if self.column &lt; indent:
            self.whitespace = True
            data = &#039; &#039;*(indent-self.column)
            self.column = indent
            if self.encoding:
                data = data.encode(self.encoding)
            self.stream.write(data)

    def write_line_break(self, data=None):
        if data is None:
            data = self.best_line_break
        self.whitespace = True
        self.indention = True
        self.line += 1
        self.column = 0
        if self.encoding:
            data = data.encode(self.encoding)
        self.stream.write(data)

    def write_version_directive(self, version_text):
        data = &#039;%%YAML %s&#039; % version_text
        if self.encoding:
            data = data.encode(self.encoding)
        self.stream.write(data)
        self.write_line_break()

    def write_tag_directive(self, handle_text, prefix_text):
        data = &#039;%%TAG %s %s&#039; % (handle_text, prefix_text)
        if self.encoding:
            data = data.encode(self.encoding)
        self.stream.write(data)
        self.write_line_break()

    # Scalar streams.

    def write_single_quoted(self, text, split=True):
        self.write_indicator(&#039;\&#039;&#039;, True)
        spaces = False
        breaks = False
        start = end = 0
        while end &lt;= len(text):
            ch = None
            if end &lt; len(text):
                ch = text[end]
            if spaces:
                if ch is None or ch != &#039; &#039;:
                    if start+1 == end and self.column &gt; self.best_width and split   \
                            and start != 0 and end != len(text):
                        self.write_indent()
                    else:
                        data = text[start:end]
                        self.column += len(data)
                        if self.encoding:
                            data = data.encode(self.encoding)
                        self.stream.write(data)
                    start = end
            elif breaks:
                if ch is None or ch not in &#039;\n\x85\u2028\u2029&#039;:
                    if text[start] == &#039;\n&#039;:
                        self.write_line_break()
                    for br in text[start:end]:
                        if br == &#039;\n&#039;:
                            self.write_line_break()
                        else:
                            self.write_line_break(br)
                    self.write_indent()
                    start = end
            else:
                if ch is None or ch in &#039; \n\x85\u2028\u2029&#039; or ch == &#039;\&#039;&#039;:
                    if start &lt; end:
                        data = text[start:end]
                        self.column += len(data)
                        if self.encoding:
                            data = data.encode(self.encoding)
                        self.stream.write(data)
                        start = end
            if ch == &#039;\&#039;&#039;:
                data = &#039;\&#039;\&#039;&#039;
                self.column += 2
                if self.encoding:
                    data = data.encode(self.encoding)
                self.stream.write(data)
                start = end + 1
            if ch is not None:
                spaces = (ch == &#039; &#039;)
                breaks = (ch in &#039;\n\x85\u2028\u2029&#039;)
            end += 1
        self.write_indicator(&#039;\&#039;&#039;, False)

    ESCAPE_REPLACEMENTS = {
        &#039;\0&#039;:       &#039;0&#039;,
        &#039;\x07&#039;:     &#039;a&#039;,
        &#039;\x08&#039;:     &#039;b&#039;,
        &#039;\x09&#039;:     &#039;t&#039;,
        &#039;\x0A&#039;:     &#039;n&#039;,
        &#039;\x0B&#039;:     &#039;v&#039;,
        &#039;\x0C&#039;:     &#039;f&#039;,
        &#039;\x0D&#039;:     &#039;r&#039;,
        &#039;\x1B&#039;:     &#039;e&#039;,
        &#039;\&quot;&#039;:       &#039;\&quot;&#039;,
        &#039;\\&#039;:       &#039;\\&#039;,
        &#039;\x85&#039;:     &#039;N&#039;,
        &#039;\xA0&#039;:     &#039;_&#039;,
        &#039;\u2028&#039;:   &#039;L&#039;,
        &#039;\u2029&#039;:   &#039;P&#039;,
    }

    def write_double_quoted(self, text, split=True):
        self.write_indicator(&#039;&quot;&#039;, True)
        start = end = 0
        while end &lt;= len(text):
            ch = None
            if end &lt; len(text):
                ch = text[end]
            if ch is None or ch in &#039;&quot;\\\x85\u2028\u2029\uFEFF&#039; \
                    or not (&#039;\x20&#039; &lt;= ch &lt;= &#039;\x7E&#039;
                        or (self.allow_unicode
                            and (&#039;\xA0&#039; &lt;= ch &lt;= &#039;\uD7FF&#039;
                                or &#039;\uE000&#039; &lt;= ch &lt;= &#039;\uFFFD&#039;))):
                if start &lt; end:
                    data = text[start:end]
                    self.column += len(data)
                    if self.encoding:
                        data = data.encode(self.encoding)
                    self.stream.write(data)
                    start = end
                if ch is not None:
                    if ch in self.ESCAPE_REPLACEMENTS:
                        data = &#039;\\&#039;+self.ESCAPE_REPLACEMENTS[ch]
                    elif ch &lt;= &#039;\xFF&#039;:
                        data = &#039;\\x%02X&#039; % ord(ch)
                    elif ch &lt;= &#039;\uFFFF&#039;:
                        data = &#039;\\u%04X&#039; % ord(ch)
                    else:
                        data = &#039;\\U%08X&#039; % ord(ch)
                    self.column += len(data)
                    if self.encoding:
                        data = data.encode(self.encoding)
                    self.stream.write(data)
                    start = end+1
            if 0 &lt; end &lt; len(text)-1 and (ch == &#039; &#039; or start &gt;= end)    \
                    and self.column+(end-start) &gt; self.best_width and split:
                data = text[start:end]+&#039;\\&#039;
                if start &lt; end:
                    start = end
                self.column += len(data)
                if self.encoding:
                    data = data.encode(self.encoding)
                self.stream.write(data)
                self.write_indent()
                self.whitespace = False
                self.indention = False
                if text[start] == &#039; &#039;:
                    data = &#039;\\&#039;
                    self.column += len(data)
                    if self.encoding:
                        data = data.encode(self.encoding)
                    self.stream.write(data)
            end += 1
        self.write_indicator(&#039;&quot;&#039;, False)

    def determine_block_hints(self, text):
        hints = &#039;&#039;
        if text:
            if text[0] in &#039; \n\x85\u2028\u2029&#039;:
                hints += str(self.best_indent)
            if text[-1] not in &#039;\n\x85\u2028\u2029&#039;:
                hints += &#039;-&#039;
            elif len(text) == 1 or text[-2] in &#039;\n\x85\u2028\u2029&#039;:
                hints += &#039;+&#039;
        return hints

    def write_folded(self, text):
        hints = self.determine_block_hints(text)
        self.write_indicator(&#039;&gt;&#039;+hints, True)
        if hints[-1:] == &#039;+&#039;:
            self.open_ended = True
        self.write_line_break()
        leading_space = True
        spaces = False
        breaks = True
        start = end = 0
        while end &lt;= len(text):
            ch = None
            if end &lt; len(text):
                ch = text[end]
            if breaks:
                if ch is None or ch not in &#039;\n\x85\u2028\u2029&#039;:
                    if not leading_space and ch is not None and ch != &#039; &#039;   \
                            and text[start] == &#039;\n&#039;:
                        self.write_line_break()
                    leading_space = (ch == &#039; &#039;)
                    for br in text[start:end]:
                        if br == &#039;\n&#039;:
                            self.write_line_break()
                        else:
                            self.write_line_break(br)
                    if ch is not None:
                        self.write_indent()
                    start = end
            elif spaces:
                if ch != &#039; &#039;:
                    if start+1 == end and self.column &gt; self.best_width:
                        self.write_indent()
                    else:
                        data = text[start:end]
                        self.column += len(data)
                        if self.encoding:
                            data = data.encode(self.encoding)
                        self.stream.write(data)
                    start = end
            else:
                if ch is None or ch in &#039; \n\x85\u2028\u2029&#039;:
                    data = text[start:end]
                    self.column += len(data)
                    if self.encoding:
                        data = data.encode(self.encoding)
                    self.stream.write(data)
                    if ch is None:
                        self.write_line_break()
                    start = end
            if ch is not None:
                breaks = (ch in &#039;\n\x85\u2028\u2029&#039;)
                spaces = (ch == &#039; &#039;)
            end += 1

    def write_literal(self, text):
        hints = self.determine_block_hints(text)
        self.write_indicator(&#039;|&#039;+hints, True)
        if hints[-1:] == &#039;+&#039;:
            self.open_ended = True
        self.write_line_break()
        breaks = True
        start = end = 0
        while end &lt;= len(text):
            ch = None
            if end &lt; len(text):
                ch = text[end]
            if breaks:
                if ch is None or ch not in &#039;\n\x85\u2028\u2029&#039;:
                    for br in text[start:end]:
                        if br == &#039;\n&#039;:
                            self.write_line_break()
                        else:
                            self.write_line_break(br)
                    if ch is not None:
                        self.write_indent()
                    start = end
            else:
                if ch is None or ch in &#039;\n\x85\u2028\u2029&#039;:
                    data = text[start:end]
                    if self.encoding:
                        data = data.encode(self.encoding)
                    self.stream.write(data)
                    if ch is None:
                        self.write_line_break()
                    start = end
            if ch is not None:
                breaks = (ch in &#039;\n\x85\u2028\u2029&#039;)
            end += 1

    def write_plain(self, text, split=True):
        if self.root_context:
            self.open_ended = True
        if not text:
            return
        if not self.whitespace:
            data = &#039; &#039;
            self.column += len(data)
            if self.encoding:
                data = data.encode(self.encoding)
            self.stream.write(data)
        self.whitespace = False
        self.indention = False
        spaces = False
        breaks = False
        start = end = 0
        while end &lt;= len(text):
            ch = None
            if end &lt; len(text):
                ch = text[end]
            if spaces:
                if ch != &#039; &#039;:
                    if start+1 == end and self.column &gt; self.best_width and split:
                        self.write_indent()
                        self.whitespace = False
                        self.indention = False
                    else:
                        data = text[start:end]
                        self.column += len(data)
                        if self.encoding:
                            data = data.encode(self.encoding)
                        self.stream.write(data)
                    start = end
            elif breaks:
                if ch not in &#039;\n\x85\u2028\u2029&#039;:
                    if text[start] == &#039;\n&#039;:
                        self.write_line_break()
                    for br in text[start:end]:
                        if br == &#039;\n&#039;:
                            self.write_line_break()
                        else:
                            self.write_line_break(br)
                    self.write_indent()
                    self.whitespace = False
                    self.indention = False
                    start = end
            else:
                if ch is None or ch in &#039; \n\x85\u2028\u2029&#039;:
                    data = text[start:end]
                    self.column += len(data)
                    if self.encoding:
                        data = data.encode(self.encoding)
                    self.stream.write(data)
                    start = end
            if ch is not None:
                spaces = (ch == &#039; &#039;)
                breaks = (ch in &#039;\n\x85\u2028\u2029&#039;)
            end += 1

</textarea><br><br><input type='hidden' name='archivo_editar' value='/lib64/python3.6/site-packages/yaml/emitter.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Flib64%2Fpython3.6%2Fsite-packages%2Fyaml' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>