"register",

"lookup",

"lookup_error",

"register_error",

"encode",

"decode",

"latin_1_encode",

"mbcs_decode",

"readbuffer_encode",

"escape_encode",

"utf_8_decode",

"raw_unicode_escape_decode",

"utf_7_decode",

"unicode_escape_encode",

"latin_1_decode",

"utf_16_decode",

"unicode_escape_decode",

"ascii_decode",

"charmap_encode",

"charmap_build",

"unicode_internal_encode",

"unicode_internal_decode",

"utf_16_ex_decode",

"escape_decode",

"charmap_decode",

"utf_7_encode",

"mbcs_encode",

"ascii_encode",

"utf_16_encode",

"raw_unicode_escape_encode",

"utf_8_encode",

"utf_16_le_encode",

"utf_16_be_encode",

"utf_16_le_decode",

"utf_16_be_decode",

"utf_32_ex_decode",

"""None"""

res = PyUnicode_EncodeLatin1(obj, len(obj), errors)

res = bytes(res)

"""None"""

if isinstance(obj, str):

res = obj.encode()

else:

res = bytes(obj)

"""None"""

if not isinstance(obj, bytes):

raise TypeError("must be bytes")

s = repr(obj).encode()

v = s[2:-1]

if s[1] == ord('"'):

v = v.replace(b"'", b"\\'").replace(b'\\"', b'"')

"""None"""

res, consumed = PyUnicode_DecodeRawUnicodeEscape(data, len(data), errors, final)

res = "".join(res)

"""None"""

res, consumed = PyUnicode_DecodeUTF7(data, len(data), errors, final)

res = "".join(res)

"""None"""

res = unicodeescape_string(obj, len(obj), 0)

res = b"".join(res)

"""None"""

res = PyUnicode_DecodeLatin1(data, len(data), errors)

res = "".join(res)

"""None"""

consumed = len(data)

if final:

consumed = 0

res, consumed, byteorder = PyUnicode_DecodeUTF16Stateful(

data, len(data), errors, "native", final

)

res = "".join(res)

"""None"""

res, consumed = PyUnicode_DecodeUnicodeEscape(data, len(data), errors, final)

res = "".join(res)

"""None"""

res = PyUnicode_DecodeASCII(data, len(data), errors)

res = "".join(res)

"""None"""

res = PyUnicode_EncodeCharmap(obj, len(obj), mapping, errors)

res = bytes(res)

"""None"""

if type(obj) == str:

p = bytearray()

t = [ord(x) for x in obj]

for i in t:

b = bytearray()

for j in range(unicode_bytes):

b.append(i % 256)

i >>= 8

if sys.byteorder == "big":

b.reverse()

p += b

res = bytes(p)

return res, len(res)

else:

res = "You can do better than this" # XXX make this right

"""None"""

if type(unistr) == str:

return unistr, len(unistr)

else:

p = []

i = 0

if sys.byteorder == "big":

start = unicode_bytes - 1

stop = -1

step = -1

else:

start = 0

stop = unicode_bytes

step = 1

while i < len(unistr) - unicode_bytes + 1:

t = 0

h = 0

for j in range(start, stop, step):

t += ord(unistr[i + j]) << (h * 8)

h += 1

i += unicode_bytes

p += chr(t)

res = "".join(p)

"""None"""

if byteorder == 0:

bm = "native"

elif byteorder == -1:

bm = "little"

else:

bm = "big"

consumed = len(data)

if final:

consumed = 0

res, consumed, byteorder = PyUnicode_DecodeUTF16Stateful(

data, len(data), errors, bm, final

)

res = "".join(res)

"""None"""

if byteorder == 0:

if len(data) < 4:

if final and len(data):

if sys.byteorder == "little":

bm = "little"

else:

bm = "big"

res, consumed, _ = PyUnicode_DecodeUTF32Stateful(

data, len(data), errors, bm, final

)

return "".join(res), consumed, 0

return "", 0, 0

if data[0:4] == b"\xff\xfe\x00\x00":

res, consumed, _ = PyUnicode_DecodeUTF32Stateful(

data[4:], len(data) - 4, errors, "little", final

)

return "".join(res), consumed + 4, -1

if data[0:4] == b"\x00\x00\xfe\xff":

res, consumed, _ = PyUnicode_DecodeUTF32Stateful(

data[4:], len(data) - 4, errors, "big", final

)

return "".join(res), consumed + 4, 1

if sys.byteorder == "little":

bm = "little"

else:

bm = "big"

res, consumed, _ = PyUnicode_DecodeUTF32Stateful(

data, len(data), errors, bm, final

)

return "".join(res), consumed, 0

if byteorder == -1:

res, consumed, _ = PyUnicode_DecodeUTF32Stateful(

data, len(data), errors, "little", final

)

return "".join(res), consumed, -1

res, consumed, _ = PyUnicode_DecodeUTF32Stateful(

data, len(data), errors, "big", final

)

return (

0x30 <= b <= 0x39 # 0-9

or 0x41 <= b <= 0x46 # A-F

or 0x61 <= b <= 0x66

if isinstance(data, str):

data = data.encode("latin-1")

l = len(data)

i = 0

res = bytearray()

while i < l:

if data[i] == 0x5C: # '\\'

i += 1

if i >= l:

raise ValueError("Trailing \\ in string")

ch = data[i]

if ch == 0x5C:

res.append(0x5C) # \\

elif ch == 0x27:

res.append(0x27) # \'

elif ch == 0x22:

res.append(0x22) # \"

elif ch == 0x61:

res.append(0x07) # \a

elif ch == 0x62:

res.append(0x08) # \b

elif ch == 0x66:

res.append(0x0C) # \f

elif ch == 0x6E:

res.append(0x0A) # \n

elif ch == 0x72:

res.append(0x0D) # \r

elif ch == 0x74:

res.append(0x09) # \t

elif ch == 0x76:

res.append(0x0B) # \v

elif ch == 0x0A:

pass # \<newline> continuation

elif 0x30 <= ch <= 0x37: # \0-\7 octal

val = ch - 0x30

if i + 1 < l and 0x30 <= data[i + 1] <= 0x37:

i += 1

val = (val << 3) | (data[i] - 0x30)

if i + 1 < l and 0x30 <= data[i + 1] <= 0x37:

i += 1

val = (val << 3) | (data[i] - 0x30)

res.append(val & 0xFF)

elif ch == 0x78: # \x hex

hex_count = 0

for j in range(1, 3):

if i + j < l and _is_hex_digit(data[i + j]):

hex_count += 1

else:

break

if hex_count < 2:

if errors == "strict":

raise ValueError("invalid \\x escape at position %d" % (i - 1))

elif errors == "replace":

res.append(0x3F) # '?'

i += hex_count

else:

res.append(int(bytes(data[i + 1 : i + 3]), 16))

i += 2

else:

import warnings

warnings.warn(

'"\\%c" is an invalid escape sequence' % ch

if 0x20 <= ch < 0x7F

else '"\\x%02x" is an invalid escape sequence' % ch,

DeprecationWarning,

stacklevel=2,

)

res.append(0x5C)

res.append(ch)

else:

res.append(data[i])

i += 1

"""None"""

res = PyUnicode_DecodeCharmap(data, len(data), mapping, errors)

res = "".join(res)

"""None"""

res = PyUnicode_EncodeUTF7(obj, len(obj), 0, 0, errors)

res = b"".join(res)

"""None"""

res = PyUnicode_EncodeASCII(obj, len(obj), errors)

res = bytes(res)

"""None"""

res = PyUnicode_EncodeUTF16(obj, len(obj), errors, "native")

res = bytes(res)

"""None"""

res = PyUnicode_EncodeRawUnicodeEscape(obj, len(obj))

res = bytes(res)

"""None"""

res = PyUnicode_EncodeUTF16(obj, len(obj), errors, "little")

res = bytes(res)

"""None"""

res = PyUnicode_EncodeUTF16(obj, len(obj), errors, "big")

res = bytes(res)

res, consumed, byteorder = PyUnicode_DecodeUTF16Stateful(

data, len(data), errors, "little", final

)

res = "".join(res)

res, consumed, byteorder = PyUnicode_DecodeUTF16Stateful(

data, len(data), errors, "big", final

)

res = "".join(res)

"""Store a 32-bit character as 4 bytes in the specified byte order."""

b0 = ch & 0xFF

b1 = (ch >> 8) & 0xFF

b2 = (ch >> 16) & 0xFF

b3 = (ch >> 24) & 0xFF

if byteorder == "little":

return [b0, b1, b2, b3]

else: # big-endian

"""The bytes an error handler's replacement adds to the output.

if isinstance(replacement, bytes):

if len(replacement) % unit_bytes:

raise UnicodeEncodeError(

encoding, s, pos, pos + 1, "surrogates not allowed"

)

return list(replacement)

encoded = []

for c in replacement:

encoded += store(ord(c))

"""Encode a Unicode string to UTF-32."""

p = []

bom = sys.byteorder

if byteorder == "native":

bom = sys.byteorder

# Add BOM for native encoding

p += STORECHAR32(0xFEFF, bom)

if byteorder == "little":

bom = "little"

elif byteorder == "big":

bom = "big"

# Only the mode that writes a BOM leaves the order out of its name.

encoding = "utf-32" if byteorder == "native" else "utf-32-" + bom[0] + "e"

def store(cp):

return STORECHAR32(cp, bom)

pos = 0

while pos < len(s):

ch = ord(s[pos])

if 0xD800 <= ch <= 0xDFFF and errors != "surrogatepass":

start = pos

res, pos = unicode_call_errorhandler(

errors, encoding, "surrogates not allowed", s, pos, pos + 1, False

)

p += _encoded_replacement(res, store, 4, encoding, s, start)

else:

p += store(ch)

pos += 1

"""UTF-32 big-endian encoding without BOM."""

res = PyUnicode_EncodeUTF32(obj, len(obj), errors, "big")

res = bytes(res)

"""Decode UTF-32 encoded bytes to Unicode string."""

if size == 0:

return [], 0, 0

result = []

pos = 0

aligned_size = (size // 4) * 4

encoding = "utf-32-le" if byteorder == "little" else "utf-32-be"

while pos + 3 < aligned_size:

if byteorder == "little":

ch = (

data[pos]

| (data[pos + 1] << 8)

| (data[pos + 2] << 16)

| (data[pos + 3] << 24)

)

else: # big-endian

ch = (

(data[pos] << 24)

| (data[pos + 1] << 16)

| (data[pos + 2] << 8)

| data[pos + 3]

)

# Validate code point

if ch > 0x10FFFF:

res, pos = unicode_call_errorhandler(

errors,

encoding,

"code point not in range(0x110000)",

data,

pos,

pos + 4,

True,

)

result.append(res)

elif 0xD800 <= ch <= 0xDFFF:

if errors == "surrogatepass":

result.append(chr(ch))

pos += 4

else:

msg = "code point in surrogate code point range(0xd800, 0xe000)"

res, pos = unicode_call_errorhandler(

errors, encoding, msg, data, pos, pos + 4, True

)

result.append(res)

else:

result.append(chr(ch))

pos += 4

# Handle trailing incomplete bytes

if pos < size:

if final:

res, pos = unicode_call_errorhandler(

errors, encoding, "truncated data", data, pos, size, True

)

if res:

result.append(res)

"""UTF-32 decoding with BOM detection."""

if len(data) >= 4:

# Check for BOM

if data[0:4] == b"\xff\xfe\x00\x00":

# UTF-32 LE BOM

res, consumed, _ = PyUnicode_DecodeUTF32Stateful(

data[4:], len(data) - 4, errors, "little", final

)

res = "".join(res)

return res, consumed + 4

elif data[0:4] == b"\x00\x00\xfe\xff":

# UTF-32 BE BOM

res, consumed, _ = PyUnicode_DecodeUTF32Stateful(

data[4:], len(data) - 4, errors, "big", final

)

res = "".join(res)

return res, consumed + 4

# Default to little-endian if no BOM

byteorder = "little" if sys.byteorder == "little" else "big"

res, consumed, _ = PyUnicode_DecodeUTF32Stateful(

data, len(data), errors, byteorder, final

)

res = "".join(res)

"""UTF-32 little-endian decoding without BOM."""

res, consumed, _ = PyUnicode_DecodeUTF32Stateful(

data, len(data), errors, "little", final

)

res = "".join(res)

"""UTF-32 big-endian decoding without BOM."""

res, consumed, _ = PyUnicode_DecodeUTF32Stateful(

data, len(data), errors, "big", final

)

res = "".join(res)

1,

1,

1,

1,

1,

1,

1,

1,

1,

2,

2,

1,

1,

2,

1,

1,

1,

1,

1,

1,

1,

1,

1,

1,

1,

1,

1,

1,

1,

1,

1,

1,

2,

3,

3,

3,

3,

3,

3,

0,

0,

0,

3,

1,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

3,

3,

3,

3,

0,

3,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

3,

1,

3,

3,

3,

3,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

3,

3,

3,

1,

1,

c = ord(c)

return (

(c > 127 or utf7_special[c] == 1)

or (encodeWS and (utf7_special[(c)] == 2))

or (encodeO and (utf7_special[(c)] == 3))

return bytes(

[

b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[

(n) & 0x3F

]

]

if (c) == b"+":

return 62

elif (c) == b"/":

return 63

elif (c) >= b"a":

return ord(c) - 71

elif (c) >= b"A":

return ord(c) - 65

else:

out = []

while bits >= 6:

out += B64(ch >> (bits - 6))

bits -= 6

return (

(ord("A") <= ch <= ord("Z"))

or (ord("a") <= ch <= ord("z"))

or (ord("0") <= ch <= ord("9"))

or ch == ord("+")

or ch == ord("/")

if ch == ord("+"):

return 62

if ch == ord("/"):

return 63

if ch >= ord("a"):

return ch - 71

if ch >= ord("A"):

return ch - 65

if ch >= ord("0"):

return ch - ord("0") + 52

if size == 0:

return [], 0

p = []

inShift = False

base64bits = 0

base64buffer = 0

surrogate = 0

startinpos = 0

shiftOutStart = 0

i = 0

while i < size:

ch = s[i]

if inShift:

if _IS_BASE64(ch):

base64buffer = (base64buffer << 6) | _FROM_BASE64(ch)

base64bits += 6

i += 1

if base64bits >= 16:

outCh = (base64buffer >> (base64bits - 16)) & 0xFFFF

base64bits -= 16

base64buffer &= (1 << base64bits) - 1

if surrogate:

if 0xDC00 <= outCh <= 0xDFFF:

ch2 = (

0x10000

+ ((surrogate - 0xD800) << 10)

+ (outCh - 0xDC00)

)

p.append(chr(ch2))

surrogate = 0

continue

else:

p.append(chr(surrogate))

surrogate = 0

if 0xD800 <= outCh <= 0xDBFF:

surrogate = outCh

else:

p.append(chr(outCh))

else:

inShift = False

if base64bits > 0:

if base64bits >= 6:

i += 1

errmsg = "partial character in shift sequence"

out, i = unicode_call_errorhandler(

errors, "utf7", errmsg, s, startinpos, i

)

p.append(out)

continue

else:

if base64buffer != 0:

i += 1

errmsg = "non-zero padding bits in shift sequence"

out, i = unicode_call_errorhandler(

errors, "utf7", errmsg, s, startinpos, i

)

p.append(out)

continue

if surrogate and _DECODE_DIRECT(ch):

p.append(chr(surrogate))

surrogate = 0

if ch == ord("-"):

i += 1

elif ch == ord("+"):

startinpos = i

i += 1

if i < size and s[i] == ord("-"):

i += 1

p.append("+")

elif i < size and not _IS_BASE64(s[i]):

i += 1

errmsg = "ill-formed sequence"

out, i = unicode_call_errorhandler(

errors, "utf7", errmsg, s, startinpos, i

)

p.append(out)

else:

inShift = True

surrogate = 0

shiftOutStart = len(p)

base64bits = 0

base64buffer = 0

elif _DECODE_DIRECT(ch):

i += 1

p.append(chr(ch))

else:

startinpos = i

i += 1

errmsg = "unexpected special character"

out, i = unicode_call_errorhandler(

errors, "utf7", errmsg, s, startinpos, i

)

p.append(out)

if inShift and not final:

return p[:shiftOutStart], startinpos

if inShift and final:

if surrogate or base64bits >= 6 or (base64bits > 0 and base64buffer != 0):

errmsg = "unterminated shift sequence"

out, i = unicode_call_errorhandler(

errors, "utf7", errmsg, s, startinpos, size

)

p.append(out)