"""The builtin bytes implementation""" from rpython.rlib import jit from rpython.rlib.objectmodel import ( compute_hash, compute_unique_id, import_from_mixin) from rpython.rlib.rstring import StringBuilder from pypy.interpreter.baseobjspace import W_Root from pypy.interpreter.buffer import SimpleView, StringBuffer from pypy.interpreter.error import OperationError, oefmt from pypy.interpreter.gateway import ( WrappedDefault, interp2app, interpindirect2app, unwrap_spec) from pypy.interpreter.typedef import TypeDef from pypy.objspace.std.stringmethods import StringMethods from pypy.objspace.std.util import IDTAG_SPECIAL, IDTAG_SHIFT from pypy.objspace.std.formatting import mod_format, FORMAT_BYTES class W_AbstractBytesObject(W_Root): __slots__ = () def is_w(self, space, w_other): if not isinstance(w_other, W_AbstractBytesObject): return False if self is w_other: return True if self.user_overridden_class or w_other.user_overridden_class: return False s1 = space.bytes_w(self) s2 = space.bytes_w(w_other) if len(s2) > 1: return s1 is s2 else: # strings of len <= 1 are unique-ified return s1 == s2 def immutable_unique_id(self, space): if self.user_overridden_class: return None s = space.bytes_w(self) if len(s) > 1: uid = compute_unique_id(s) else: # strings of len <= 1 are unique-ified if len(s) == 1: base = ord(s[0]) # base values 0-255 else: base = 256 # empty string: base value 256 uid = (base << IDTAG_SHIFT) | IDTAG_SPECIAL return space.newint(uid) def descr_add(self, space, w_other): """x.__add__(y) <==> x+y""" def descr_contains(self, space, w_sub): """x.__contains__(y) <==> y in x""" def descr_eq(self, space, w_other): """x.__eq__(y) <==> x==y""" def descr_ge(self, space, w_other): """x.__ge__(y) <==> x>=y""" def descr_getitem(self, space, w_index): """x.__getitem__(y) <==> x[y]""" def descr_getnewargs(self, space): "" def descr_gt(self, space, w_other): """x.__gt__(y) <==> x>y""" def descr_hash(self, space): """x.__hash__() <==> hash(x)""" def descr_iter(self, space): """x.__iter__() <==> iter(x)""" def descr_le(self, space, w_other): """x.__le__(y) <==> x<=y""" def descr_len(self, space): """x.__len__() <==> len(x)""" def descr_lt(self, space, w_other): """x.__lt__(y) <==> x x*n""" def descr_ne(self, space, w_other): """x.__ne__(y) <==> x!=y""" def descr_repr(self, space): """x.__repr__() <==> repr(x)""" def descr_rmod(self, space, w_values): """x.__rmod__(y) <==> y%x""" def descr_rmul(self, space, w_times): """x.__rmul__(n) <==> n*x""" def descr_str(self, space): """x.__str__() <==> str(x)""" def descr_capitalize(self, space): """B.capitalize() -> copy of B Return a capitalized version of B, i.e. make the first character have upper case and the rest lower case. """ @unwrap_spec(width=int, w_fillchar=WrappedDefault(' ')) def descr_center(self, space, width, w_fillchar): """B.center(width[, fillchar]) -> copy of B Return B centered in a string of length width. Padding is done using the specified fill character (default is a space). """ def descr_count(self, space, w_sub, w_start=None, w_end=None): """B.count(sub[, start[, end]]) -> int Return the number of non-overlapping occurrences of substring sub in string B[start:end]. Optional arguments start and end are interpreted as in slice notation. """ def descr_decode(self, space, w_encoding=None, w_errors=None): """B.decode(encoding=None, errors='strict') -> object Decode B using the codec registered for encoding. encoding defaults to the default encoding. errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors raise a UnicodeDecodeError. Other possible values are 'ignore' and 'replace' as well as any other name registered with codecs.register_error that is able to handle UnicodeDecodeErrors. """ def descr_endswith(self, space, w_suffix, w_start=None, w_end=None): """B.endswith(suffix[, start[, end]]) -> bool Return True if B ends with the specified suffix, False otherwise. With optional start, test B beginning at that position. With optional end, stop comparing B at that position. suffix can also be a tuple of bytes to try. """ @unwrap_spec(tabsize=int) def descr_expandtabs(self, space, tabsize=8): """B.expandtabs([tabsize]) -> copy of B Return a copy of B where all tab characters are expanded using spaces. If tabsize is not given, a tab size of 8 characters is assumed. """ def descr_find(self, space, w_sub, w_start=None, w_end=None): """B.find(sub[, start[, end]]) -> int Return the lowest index in B where substring sub is found, such that sub is contained within B[start:end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure. """ def descr_index(self, space, w_sub, w_start=None, w_end=None): """B.index(sub[, start[, end]]) -> int Like B.find() but raise ValueError when the substring is not found. """ def descr_isalnum(self, space): """B.isalnum() -> bool Return True if all characters in B are alphanumeric and there is at least one character in B, False otherwise. """ def descr_isalpha(self, space): """B.isalpha() -> bool Return True if all characters in B are alphabetic and there is at least one character in B, False otherwise. """ def descr_isdigit(self, space): """B.isdigit() -> bool Return True if all characters in B are digits and there is at least one character in B, False otherwise. """ def descr_islower(self, space): """B.islower() -> bool Return True if all cased characters in B are lowercase and there is at least one cased character in B, False otherwise. """ def descr_isspace(self, space): """B.isspace() -> bool Return True if all characters in B are whitespace and there is at least one character in B, False otherwise. """ def descr_istitle(self, space): """B.istitle() -> bool Return True if B is a titlecased string and there is at least one character in B, i.e. uppercase characters may only follow uncased characters and lowercase characters only cased ones. Return False otherwise. """ def descr_isupper(self, space): """B.isupper() -> bool Return True if all cased characters in B are uppercase and there is at least one cased character in B, False otherwise. """ def descr_join(self, space, w_list): """B.join(iterable) -> bytes Return a bytes object which is the concatenation of the bytes in the iterable. The separator between elements is B. """ @unwrap_spec(width=int, w_fillchar=WrappedDefault(' ')) def descr_ljust(self, space, width, w_fillchar): """B.ljust(width[, fillchar]) -> copy of B Return B left-justified in a string of length width. Padding is done using the specified fill character (default is a space). """ def descr_lower(self, space): """B.lower() -> copy of B Return a copy of the string B converted to lowercase. """ def descr_lstrip(self, space, w_chars=None): """B.lstrip([chars]) -> copy of B Return a copy of the string B with leading whitespace removed. If chars is given and not None, remove characters in chars instead. """ def descr_partition(self, space, w_sub): """B.partition(sep) -> (head, sep, tail) Search for the separator sep in B, and return the part before it, the separator itself, and the part after it. If the separator is not found, return B and two empty bytes objects. """ @unwrap_spec(count=int) def descr_replace(self, space, w_old, w_new, count=-1): """B.replace(old, new[, count]) -> copy of B Return a copy of string B with all occurrences of substring old replaced by new. If the optional argument count is given, only the first count occurrences are replaced. """ def descr_rfind(self, space, w_sub, w_start=None, w_end=None): """B.rfind(sub[, start[, end]]) -> int Return the highest index in B where substring sub is found, such that sub is contained within B[start:end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure. """ def descr_rindex(self, space, w_sub, w_start=None, w_end=None): """B.rindex(sub[, start[, end]]) -> int Like B.rfind() but raise ValueError when the substring is not found. """ @unwrap_spec(width=int, w_fillchar=WrappedDefault(' ')) def descr_rjust(self, space, width, w_fillchar): """B.rjust(width[, fillchar]) -> copy of B Return B right-justified in a string of length width. Padding is done using the specified fill character (default is a space). """ def descr_rpartition(self, space, w_sub): """B.rpartition(sep) -> (head, sep, tail) Search for the separator sep in B, starting at the end of B, and return the part before it, the separator itself, and the part after it. If the separator is not found, return two empty bytes objects and B. """ @unwrap_spec(maxsplit=int) def descr_rsplit(self, space, w_sep=None, maxsplit=-1): """B.rsplit(sep=None, maxsplit=-1) -> list of bytes objects Return a list of the words in the string B, using sep as the delimiter string, starting at the end of the string and working to the front. If maxsplit is given, at most maxsplit splits are done. If sep is not specified or is None, any whitespace string is a separator. """ def descr_rstrip(self, space, w_chars=None): """B.rstrip([chars]) -> copy of B Return a copy of the string B with trailing whitespace removed. If chars is given and not None, remove characters in chars instead. """ @unwrap_spec(maxsplit=int) def descr_split(self, space, w_sep=None, maxsplit=-1): """B.split(sep=None, maxsplit=-1) -> list of bytes objects Return a list of the words in the string B, using sep as the delimiter string. If maxsplit is given, at most maxsplit splits are done. If sep is not specified or is None, any whitespace string is a separator and empty strings are removed from the result. """ @unwrap_spec(keepends=bool) def descr_splitlines(self, space, keepends=False): """B.splitlines(keepends=False) -> list of bytes objects Return a list of the lines in B, breaking at line boundaries. Line breaks are not included in the resulting list unless keepends is given and true. """ def descr_startswith(self, space, w_prefix, w_start=None, w_end=None): """B.startswith(prefix[, start[, end]]) -> bool Return True if B starts with the specified prefix, False otherwise. With optional start, test B beginning at that position. With optional end, stop comparing B at that position. prefix can also be a tuple of bytes to try. """ def descr_strip(self, space, w_chars=None): """B.strip([chars]) -> copy of B Return a copy of the string B with leading and trailing whitespace removed. If chars is given and not None, remove characters in chars instead. """ def descr_swapcase(self, space): """B.swapcase() -> copy of B Return a copy of the string B with uppercase characters converted to lowercase and vice versa. """ def descr_title(self, space): """B.title() -> copy of B Return a titlecased version of B, i.e. words start with uppercase characters, all remaining cased characters have lowercase. """ @unwrap_spec(w_delete=WrappedDefault('')) def descr_translate(self, space, w_table, w_delete): """B.translate(table[, deletechars]) -> copy of B Return a copy of the string B, where all characters occurring in the optional argument deletechars are removed, and the remaining characters have been mapped through the given translation table, which must be a string of length 256 or None. If the table argument is None, no translation is applied and the operation simply removes the characters in deletechars. """ def descr_upper(self, space): """B.upper() -> copy of B Return a copy of the string B converted to uppercase. """ @unwrap_spec(width=int) def descr_zfill(self, space, width): """B.zfill(width) -> copy of B Pad a numeric string B with zeros on the left, to fill a field of the specified width. The string B is never truncated. """ def descr_mod(self, space, w_values): """B % values -> bytes Format bytes objects """ class W_BytesObject(W_AbstractBytesObject): import_from_mixin(StringMethods) _immutable_fields_ = ['_value'] _KIND1 = "byte" _KIND2 = "bytes" def __init__(self, str): assert str is not None self._value = str def __repr__(self): """representation for debugging purposes""" return "%s(%r)" % (self.__class__.__name__, self._value) def unwrap(self, space): return self._value def bytes_w(self, space): return self._value def buffer_w(self, space, flags): space.check_buf_flags(flags, True) return SimpleView(StringBuffer(self._value)) def descr_getbuffer(self, space, w_flags): #from pypy.objspace.std.bufferobject import W_Buffer #return W_Buffer(StringBuffer(self._value)) return self def listview_int(self): return _create_list_from_bytes(self._value) def ord(self, space): if len(self._value) != 1: raise oefmt(space.w_TypeError, "ord() expected a character, but bytes of length %d " "found", len(self._value)) return space.newint(ord(self._value[0])) def _new(self, value): return W_BytesObject(value) def _new_from_list(self, value): return W_BytesObject(''.join(value)) def _empty(self): return W_BytesObject.EMPTY def _len(self): return len(self._value) _val = bytes_w @staticmethod def _use_rstr_ops(space, w_other): return True @staticmethod def _op_val(space, w_other, allow_char=False): # Some functions (contains, find) allow a number to specify a # single char. if allow_char and space.isinstance_w(w_other, space.w_int): return StringMethods._single_char(space, w_other) try: return space.bytes_w(w_other) except OperationError as e: if not e.match(space, space.w_TypeError): raise return space.buffer_w(w_other, space.BUF_SIMPLE).as_str() def _chr(self, char): assert len(char) == 1 return str(char)[0] _builder = StringBuilder def _isupper(self, ch): return ch.isupper() def _islower(self, ch): return ch.islower() def _istitle(self, ch): return ch.isupper() def _isspace(self, ch): return ch.isspace() def _isalpha(self, ch): return ch.isalpha() def _isalnum(self, ch): return ch.isalnum() def _isdigit(self, ch): return ch.isdigit() _iscased = _isalpha def _islinebreak(self, ch): return (ch == '\n') or (ch == '\r') def _upper(self, ch): if ch.islower(): o = ord(ch) - 32 return chr(o) else: return ch def _lower(self, ch): if ch.isupper(): o = ord(ch) + 32 return chr(o) else: return ch _title = _upper def _newlist_unwrapped(self, space, lst): return space.newlist_bytes(lst) @staticmethod @unwrap_spec(encoding='text_or_none', errors='text_or_none') def descr_new(space, w_stringtype, w_source=None, encoding=None, errors=None): if (w_source and space.is_w(w_stringtype, space.w_bytes) and encoding is None and errors is None): # special-case 'bytes(byte_object)' w_srctype = space.type(w_source) if w_srctype is space.w_bytes: return w_source # special-case 'bytes([single_integer])' or 'bytes((single_int,))' # for JITted performance only, when we clearly see the # length of the list/tuple being constant and equal to 1 if w_srctype is space.w_list or w_srctype is space.w_tuple: length = space.len_w(w_source) if jit.isconstant(length) and length == 1: w_item = space.getitem(w_source, space.newint(0)) value = space.byte_w(w_item) return W_BytesObject(value) else: # special-case 'bytes(X)' if X has a __bytes__() method: # we must return the result unmodified even if it is a # subclass of bytes w_result = invoke_bytes_method(space, w_source) if w_result is not None: return w_result value = newbytesdata_w_tail(space, w_source) else: value = newbytesdata_w(space, w_source, encoding, errors) w_obj = space.allocate_instance(W_BytesObject, w_stringtype) W_BytesObject.__init__(w_obj, value) return w_obj @staticmethod def descr_fromhex(space, w_type, w_hexstring): r"""bytes.fromhex(string) -> bytes Create a bytes object from a string of hexadecimal numbers. Spaces between two numbers are accepted. Example: bytes.fromhex('B9 01EF') -> b'\xb9\x01\xef'. """ if not space.is_w(space.type(w_hexstring), space.w_unicode): raise oefmt(space.w_TypeError, "must be str, not %T", w_hexstring) from pypy.objspace.std.bytearrayobject import _hexstring_to_array hexstring = space.unicode_w(w_hexstring) bytes = ''.join(_hexstring_to_array(space, hexstring)) return W_BytesObject(bytes) def descr_repr(self, space): return space.newtext(string_escape_encode(self._value, True)) def descr_str(self, space): if space.sys.get_flag('bytes_warning'): space.warn(space.newtext("str() on a bytes instance"), space.w_BytesWarning) return self.descr_repr(space) def descr_hash(self, space): x = compute_hash(self._value) x -= (x == -1) # convert -1 to -2 without creating a bridge return space.newint(x) def descr_eq(self, space, w_other): if not isinstance(w_other, W_BytesObject): return space.w_NotImplemented return space.newbool(self._value == w_other._value) def descr_ne(self, space, w_other): if not isinstance(w_other, W_BytesObject): return space.w_NotImplemented return space.newbool(self._value != w_other._value) def descr_lt(self, space, w_other): if not isinstance(w_other, W_BytesObject): return space.w_NotImplemented return space.newbool(self._value < w_other._value) def descr_le(self, space, w_other): if not isinstance(w_other, W_BytesObject): return space.w_NotImplemented return space.newbool(self._value <= w_other._value) def descr_gt(self, space, w_other): if not isinstance(w_other, W_BytesObject): return space.w_NotImplemented return space.newbool(self._value > w_other._value) def descr_ge(self, space, w_other): if not isinstance(w_other, W_BytesObject): return space.w_NotImplemented return space.newbool(self._value >= w_other._value) # auto-conversion fun _StringMethods_descr_add = descr_add def descr_add(self, space, w_other): return self._StringMethods_descr_add(space, w_other) _StringMethods_descr_join = descr_join def descr_join(self, space, w_list): l = space.listview_bytes(w_list) if l is not None: if len(l) == 1: return space.newbytes(l[0]) return space.newbytes(self._val(space).join(l)) return self._StringMethods_descr_join(space, w_list) def _join_return_one(self, space, w_obj): return space.is_w(space.type(w_obj), space.w_bytes) def descr_lower(self, space): return W_BytesObject(self._value.lower()) def descr_upper(self, space): return W_BytesObject(self._value.upper()) def descr_hex(self, space): from pypy.objspace.std.bytearrayobject import _array_to_hexstring return _array_to_hexstring(space, StringBuffer(self._value), 0, 1, len(self._value)) def descr_mod(self, space, w_values): return mod_format(space, self, w_values, fmt_type=FORMAT_BYTES) def descr_rmod(self, space, w_values): if not isinstance(w_values, W_AbstractBytesObject): return space.w_NotImplemented return mod_format(space, w_values, self, fmt_type=FORMAT_BYTES) @staticmethod def _iter_getitem_result(self, space, index): assert isinstance(self, W_BytesObject) return self._getitem_result(space, index) def _create_list_from_bytes(value): # need this helper function to allow the jit to look inside and inline # listview_int return [ord(s) for s in value] W_BytesObject.EMPTY = W_BytesObject('') def invoke_bytes_method(space, w_source): w_bytes_method = space.lookup(w_source, "__bytes__") if w_bytes_method is not None: w_bytes = space.get_and_call_function(w_bytes_method, w_source) if not space.isinstance_w(w_bytes, space.w_bytes): raise oefmt(space.w_TypeError, "__bytes__ returned non-bytes (type '%T')", w_bytes) return w_bytes return None def newbytesdata_w(space, w_source, encoding, errors): # None value if w_source is None: if encoding is not None or errors is not None: raise oefmt(space.w_TypeError, "encoding or errors without sequence argument") else: return b"" # Unicode with encoding if encoding is not None: if not space.isinstance_w(w_source, space.w_unicode): raise oefmt(space.w_TypeError, "encoding without string argument (got '%T' instead)", w_source) from pypy.objspace.std.unicodeobject import encode_object w_source = encode_object(space, w_source, encoding, errors) # and continue with the encoded string elif errors is not None: if not space.isinstance_w(w_source, space.w_unicode): raise oefmt(space.w_TypeError, "errors without string argument (got '%T' instead)", w_source) else: raise oefmt(space.w_TypeError, "string argument without an encoding") # Fast-path for bytes if space.type(w_source) is space.w_bytes: return space.bytes_w(w_source) # Some other object with a __bytes__ special method (could be str subclass) w_result = invoke_bytes_method(space, w_source) if w_result is not None: return space.bytes_w(w_result) return newbytesdata_w_tail(space, w_source) def newbytesdata_w_tail(space, w_source): # converts rare case of bytes constructor arguments: we don't have # any encodings/errors, and the argument does not have __bytes__() if space.isinstance_w(w_source, space.w_unicode): raise oefmt(space.w_TypeError, "string argument without an encoding") # Is it an integer? # Note that we're calling space.getindex_w() instead of space.int_w(). try: count = space.getindex_w(w_source, space.w_OverflowError) except OperationError as e: if not e.match(space, space.w_TypeError): raise else: if count < 0: raise oefmt(space.w_ValueError, "negative count") return '\0' * count return _convert_from_buffer_or_iterable(space, w_source) def makebytesdata_w(space, w_source): w_bytes_method = space.lookup(w_source, "__bytes__") if w_bytes_method is not None: w_bytes = space.get_and_call_function(w_bytes_method, w_source) if not space.isinstance_w(w_bytes, space.w_bytes): raise oefmt(space.w_TypeError, "__bytes__ returned non-bytes (type '%T')", w_bytes) return space.bytes_w(w_bytes) return _convert_from_buffer_or_iterable(space, w_source) def _convert_from_buffer_or_iterable(space, w_source): # String-like argument try: buf = space.buffer_w(w_source, space.BUF_FULL_RO) except OperationError as e: if not e.match(space, space.w_TypeError): raise else: return buf.as_str() if space.isinstance_w(w_source, space.w_unicode): raise oefmt(space.w_TypeError, "cannot convert a (unicode) str object to bytes") return _from_byte_sequence(space, w_source) def _get_printable_location(w_type): return ('bytearray_from_byte_sequence [w_type=%s]' % w_type.getname(w_type.space).encode('utf-8')) _byteseq_jitdriver = jit.JitDriver( name='bytearray_from_byte_sequence', greens=['w_type'], reds=['w_iter', 'builder'], get_printable_location=_get_printable_location) def _from_byte_sequence(space, w_source): # Split off in a separate function for the JIT's benefit # and add a jitdriver with the type of w_iter as the green key w_iter = space.iter(w_source) length_hint = space.length_hint(w_source, 0) builder = StringBuilder(length_hint) # _from_byte_sequence_loop(space, w_iter, builder) # return builder.build() def _from_byte_sequence_loop(space, w_iter, builder): w_type = space.type(w_iter) while True: _byteseq_jitdriver.jit_merge_point(w_type=w_type, w_iter=w_iter, builder=builder) try: w_item = space.next(w_iter) except OperationError as e: if not e.match(space, space.w_StopIteration): raise break builder.append(space.byte_w(w_item)) W_BytesObject.typedef = TypeDef( "bytes", None, None, "read", __new__ = interp2app(W_BytesObject.descr_new), __doc__ = """bytes(iterable_of_ints) -> bytes bytes(string, encoding[, errors]) -> bytes bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer bytes(int) -> bytes object of size given by the parameter initialized with null bytes bytes() -> empty bytes object Construct an immutable array of bytes from: - an iterable yielding integers in range(256) - a text string encoded using the specified encoding - any object implementing the buffer API. - an integer """, __repr__ = interpindirect2app(W_AbstractBytesObject.descr_repr), __str__ = interpindirect2app(W_AbstractBytesObject.descr_str), __hash__ = interpindirect2app(W_AbstractBytesObject.descr_hash), __eq__ = interpindirect2app(W_AbstractBytesObject.descr_eq), __ne__ = interpindirect2app(W_AbstractBytesObject.descr_ne), __lt__ = interpindirect2app(W_AbstractBytesObject.descr_lt), __le__ = interpindirect2app(W_AbstractBytesObject.descr_le), __gt__ = interpindirect2app(W_AbstractBytesObject.descr_gt), __ge__ = interpindirect2app(W_AbstractBytesObject.descr_ge), __iter__ = interpindirect2app(W_AbstractBytesObject.descr_iter), __len__ = interpindirect2app(W_AbstractBytesObject.descr_len), __contains__ = interpindirect2app(W_AbstractBytesObject.descr_contains), __add__ = interpindirect2app(W_AbstractBytesObject.descr_add), __mul__ = interpindirect2app(W_AbstractBytesObject.descr_mul), __rmul__ = interpindirect2app(W_AbstractBytesObject.descr_rmul), __mod__ = interpindirect2app(W_AbstractBytesObject.descr_mod), __rmod__ = interpindirect2app(W_AbstractBytesObject.descr_rmod), __getitem__ = interpindirect2app(W_AbstractBytesObject.descr_getitem), capitalize = interpindirect2app(W_AbstractBytesObject.descr_capitalize), center = interpindirect2app(W_AbstractBytesObject.descr_center), count = interpindirect2app(W_AbstractBytesObject.descr_count), decode = interpindirect2app(W_AbstractBytesObject.descr_decode), expandtabs = interpindirect2app(W_AbstractBytesObject.descr_expandtabs), find = interpindirect2app(W_AbstractBytesObject.descr_find), rfind = interpindirect2app(W_AbstractBytesObject.descr_rfind), index = interpindirect2app(W_AbstractBytesObject.descr_index), rindex = interpindirect2app(W_AbstractBytesObject.descr_rindex), isalnum = interpindirect2app(W_AbstractBytesObject.descr_isalnum), isalpha = interpindirect2app(W_AbstractBytesObject.descr_isalpha), isdigit = interpindirect2app(W_AbstractBytesObject.descr_isdigit), islower = interpindirect2app(W_AbstractBytesObject.descr_islower), isspace = interpindirect2app(W_AbstractBytesObject.descr_isspace), istitle = interpindirect2app(W_AbstractBytesObject.descr_istitle), isupper = interpindirect2app(W_AbstractBytesObject.descr_isupper), join = interpindirect2app(W_AbstractBytesObject.descr_join), ljust = interpindirect2app(W_AbstractBytesObject.descr_ljust), rjust = interpindirect2app(W_AbstractBytesObject.descr_rjust), lower = interpindirect2app(W_AbstractBytesObject.descr_lower), partition = interpindirect2app(W_AbstractBytesObject.descr_partition), rpartition = interpindirect2app(W_AbstractBytesObject.descr_rpartition), replace = interpindirect2app(W_AbstractBytesObject.descr_replace), split = interpindirect2app(W_AbstractBytesObject.descr_split), rsplit = interpindirect2app(W_AbstractBytesObject.descr_rsplit), splitlines = interpindirect2app(W_AbstractBytesObject.descr_splitlines), startswith = interpindirect2app(W_AbstractBytesObject.descr_startswith), endswith = interpindirect2app(W_AbstractBytesObject.descr_endswith), strip = interpindirect2app(W_AbstractBytesObject.descr_strip), lstrip = interpindirect2app(W_AbstractBytesObject.descr_lstrip), rstrip = interpindirect2app(W_AbstractBytesObject.descr_rstrip), swapcase = interpindirect2app(W_AbstractBytesObject.descr_swapcase), title = interpindirect2app(W_AbstractBytesObject.descr_title), translate = interpindirect2app(W_AbstractBytesObject.descr_translate), upper = interpindirect2app(W_AbstractBytesObject.descr_upper), zfill = interpindirect2app(W_AbstractBytesObject.descr_zfill), __getnewargs__ = interpindirect2app( W_AbstractBytesObject.descr_getnewargs), fromhex = interp2app(W_BytesObject.descr_fromhex, as_classmethod=True), maketrans = interp2app(W_BytesObject.descr_maketrans, as_classmethod=True), hex = interp2app(W_BytesObject.descr_hex), ) W_BytesObject.typedef.flag_sequence_bug_compat = True @jit.elidable def string_escape_encode(s, quotes): buf = StringBuilder(len(s) + 2) quote = "'" if quotes: if quote in s and '"' not in s: quote = '"' buf.append('b"') else: buf.append("b'") startslice = 0 for i in range(len(s)): c = s[i] use_bs_char = False # character quoted by backspace if c == '\\' or c == quote: bs_char = c use_bs_char = True elif c == '\t': bs_char = 't' use_bs_char = True elif c == '\r': bs_char = 'r' use_bs_char = True elif c == '\n': bs_char = 'n' use_bs_char = True elif not '\x20' <= c < '\x7f': n = ord(c) if i != startslice: buf.append_slice(s, startslice, i) startslice = i + 1 buf.append('\\x') buf.append("0123456789abcdef"[n >> 4]) buf.append("0123456789abcdef"[n & 0xF]) if use_bs_char: if i != startslice: buf.append_slice(s, startslice, i) startslice = i + 1 buf.append('\\') buf.append(bs_char) if len(s) != startslice: buf.append_slice(s, startslice, len(s)) if quotes: buf.append(quote) return buf.build()