<h2>Edit File - _encoded_words.py</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/lib64/python3.8/email/_encoded_words.py">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&quot;&quot;&quot; Routines for manipulating RFC2047 encoded words.

This is currently a package-private API, but will be considered for promotion
to a public API if there is demand.

&quot;&quot;&quot;

# An ecoded word looks like this:
#
#        =?charset[*lang]?cte?encoded_string?=
#
# for more information about charset see the charset module.  Here it is one
# of the preferred MIME charset names (hopefully; you never know when parsing).
# cte (Content Transfer Encoding) is either &#039;q&#039; or &#039;b&#039; (ignoring case).  In
# theory other letters could be used for other encodings, but in practice this
# (almost?) never happens.  There could be a public API for adding entries
# to the CTE tables, but YAGNI for now.  &#039;q&#039; is Quoted Printable, &#039;b&#039; is
# Base64.  The meaning of encoded_string should be obvious.  &#039;lang&#039; is optional
# as indicated by the brackets (they are not part of the syntax) but is almost
# never encountered in practice.
#
# The general interface for a CTE decoder is that it takes the encoded_string
# as its argument, and returns a tuple (cte_decoded_string, defects).  The
# cte_decoded_string is the original binary that was encoded using the
# specified cte.  &#039;defects&#039; is a list of MessageDefect instances indicating any
# problems encountered during conversion.  &#039;charset&#039; and &#039;lang&#039; are the
# corresponding strings extracted from the EW, case preserved.
#
# The general interface for a CTE encoder is that it takes a binary sequence
# as input and returns the cte_encoded_string, which is an ascii-only string.
#
# Each decoder must also supply a length function that takes the binary
# sequence as its argument and returns the length of the resulting encoded
# string.
#
# The main API functions for the module are decode, which calls the decoder
# referenced by the cte specifier, and encode, which adds the appropriate
# RFC 2047 &quot;chrome&quot; to the encoded string, and can optionally automatically
# select the shortest possible encoding.  See their docstrings below for
# details.

import re
import base64
import binascii
import functools
from string import ascii_letters, digits
from email import errors

__all__ = [&#039;decode_q&#039;,
           &#039;encode_q&#039;,
           &#039;decode_b&#039;,
           &#039;encode_b&#039;,
           &#039;len_q&#039;,
           &#039;len_b&#039;,
           &#039;decode&#039;,
           &#039;encode&#039;,
           ]

#
# Quoted Printable
#

# regex based decoder.
_q_byte_subber = functools.partial(re.compile(br&#039;=([a-fA-F0-9]{2})&#039;).sub,
        lambda m: bytes.fromhex(m.group(1).decode()))

def decode_q(encoded):
    encoded = encoded.replace(b&#039;_&#039;, b&#039; &#039;)
    return _q_byte_subber(encoded), []


# dict mapping bytes to their encoded form
class _QByteMap(dict):

    safe = b&#039;-!*+/&#039; + ascii_letters.encode(&#039;ascii&#039;) + digits.encode(&#039;ascii&#039;)

    def __missing__(self, key):
        if key in self.safe:
            self[key] = chr(key)
        else:
            self[key] = &quot;={:02X}&quot;.format(key)
        return self[key]

_q_byte_map = _QByteMap()

# In headers spaces are mapped to &#039;_&#039;.
_q_byte_map[ord(&#039; &#039;)] = &#039;_&#039;

def encode_q(bstring):
    return &#039;&#039;.join(_q_byte_map[x] for x in bstring)

def len_q(bstring):
    return sum(len(_q_byte_map[x]) for x in bstring)


#
# Base64
#

def decode_b(encoded):
    # First try encoding with validate=True, fixing the padding if needed.
    # This will succeed only if encoded includes no invalid characters.
    pad_err = len(encoded) % 4
    missing_padding = b&#039;===&#039;[:4-pad_err] if pad_err else b&#039;&#039;
    try:
        return (
            base64.b64decode(encoded + missing_padding, validate=True),
            [errors.InvalidBase64PaddingDefect()] if pad_err else [],
        )
    except binascii.Error:
        # Since we had correct padding, this is likely an invalid char error.
        #
        # The non-alphabet characters are ignored as far as padding
        # goes, but we don&#039;t know how many there are.  So try without adding
        # padding to see if it works.
        try:
            return (
                base64.b64decode(encoded, validate=False),
                [errors.InvalidBase64CharactersDefect()],
            )
        except binascii.Error:
            # Add as much padding as could possibly be necessary (extra padding
            # is ignored).
            try:
                return (
                    base64.b64decode(encoded + b&#039;==&#039;, validate=False),
                    [errors.InvalidBase64CharactersDefect(),
                     errors.InvalidBase64PaddingDefect()],
                )
            except binascii.Error:
                # This only happens when the encoded string&#039;s length is 1 more
                # than a multiple of 4, which is invalid.
                #
                # bpo-27397: Just return the encoded string since there&#039;s no
                # way to decode.
                return encoded, [errors.InvalidBase64LengthDefect()]

def encode_b(bstring):
    return base64.b64encode(bstring).decode(&#039;ascii&#039;)

def len_b(bstring):
    groups_of_3, leftover = divmod(len(bstring), 3)
    # 4 bytes out for each 3 bytes (or nonzero fraction thereof) in.
    return groups_of_3 * 4 + (4 if leftover else 0)


_cte_decoders = {
    &#039;q&#039;: decode_q,
    &#039;b&#039;: decode_b,
    }

def decode(ew):
    &quot;&quot;&quot;Decode encoded word and return (string, charset, lang, defects) tuple.

    An RFC 2047/2243 encoded word has the form:

        =?charset*lang?cte?encoded_string?=

    where &#039;*lang&#039; may be omitted but the other parts may not be.

    This function expects exactly such a string (that is, it does not check the
    syntax and may raise errors if the string is not well formed), and returns
    the encoded_string decoded first from its Content Transfer Encoding and
    then from the resulting bytes into unicode using the specified charset.  If
    the cte-decoded string does not successfully decode using the specified
    character set, a defect is added to the defects list and the unknown octets
    are replaced by the unicode &#039;unknown&#039; character \\uFDFF.

    The specified charset and language are returned.  The default for language,
    which is rarely if ever encountered, is the empty string.

    &quot;&quot;&quot;
    _, charset, cte, cte_string, _ = ew.split(&#039;?&#039;)
    charset, _, lang = charset.partition(&#039;*&#039;)
    cte = cte.lower()
    # Recover the original bytes and do CTE decoding.
    bstring = cte_string.encode(&#039;ascii&#039;, &#039;surrogateescape&#039;)
    bstring, defects = _cte_decoders[cte](bstring)
    # Turn the CTE decoded bytes into unicode.
    try:
        string = bstring.decode(charset)
    except UnicodeError:
        defects.append(errors.UndecodableBytesDefect(&quot;Encoded word &quot;
            &quot;contains bytes not decodable using {} charset&quot;.format(charset)))
        string = bstring.decode(charset, &#039;surrogateescape&#039;)
    except LookupError:
        string = bstring.decode(&#039;ascii&#039;, &#039;surrogateescape&#039;)
        if charset.lower() != &#039;unknown-8bit&#039;:
            defects.append(errors.CharsetError(&quot;Unknown charset {} &quot;
                &quot;in encoded word; decoded as unknown bytes&quot;.format(charset)))
    return string, charset, lang, defects


_cte_encoders = {
    &#039;q&#039;: encode_q,
    &#039;b&#039;: encode_b,
    }

_cte_encode_length = {
    &#039;q&#039;: len_q,
    &#039;b&#039;: len_b,
    }

def encode(string, charset=&#039;utf-8&#039;, encoding=None, lang=&#039;&#039;):
    &quot;&quot;&quot;Encode string using the CTE encoding that produces the shorter result.

    Produces an RFC 2047/2243 encoded word of the form:

        =?charset*lang?cte?encoded_string?=

    where &#039;*lang&#039; is omitted unless the &#039;lang&#039; parameter is given a value.
    Optional argument charset (defaults to utf-8) specifies the charset to use
    to encode the string to binary before CTE encoding it.  Optional argument
    &#039;encoding&#039; is the cte specifier for the encoding that should be used (&#039;q&#039;
    or &#039;b&#039;); if it is None (the default) the encoding which produces the
    shortest encoded sequence is used, except that &#039;q&#039; is preferred if it is up
    to five characters longer.  Optional argument &#039;lang&#039; (default &#039;&#039;) gives the
    RFC 2243 language string to specify in the encoded word.

    &quot;&quot;&quot;
    if charset == &#039;unknown-8bit&#039;:
        bstring = string.encode(&#039;ascii&#039;, &#039;surrogateescape&#039;)
    else:
        bstring = string.encode(charset)
    if encoding is None:
        qlen = _cte_encode_length[&#039;q&#039;](bstring)
        blen = _cte_encode_length[&#039;b&#039;](bstring)
        # Bias toward q.  5 is arbitrary.
        encoding = &#039;q&#039; if qlen - blen &lt; 5 else &#039;b&#039;
    encoded = _cte_encoders[encoding](bstring)
    if lang:
        lang = &#039;*&#039; + lang
    return &quot;=?{}{}?{}?{}?=&quot;.format(charset, lang, encoding, encoded)
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>