Author: Ronan Lamy <[email protected]>
Branch: py3k
Changeset: r85454:78b02e3ea03e
Date: 2016-06-29 17:29 +0100
http://bitbucket.org/pypy/pypy/changeset/78b02e3ea03e/
Log: Use space.newbytes() and space.newunicode()
diff too long, truncating to 2000 out of 2321 lines
diff --git a/pypy/interpreter/main.py b/pypy/interpreter/main.py
--- a/pypy/interpreter/main.py
+++ b/pypy/interpreter/main.py
@@ -19,7 +19,7 @@
def compilecode(space, source, filename, cmd='exec'):
w = space.wrap
w_code = space.builtin.call(
- 'compile', space.wrapbytes(source), space.wrap_fsdecoded(filename),
+ 'compile', space.newbytes(source), space.wrap_fsdecoded(filename),
w(cmd), w(0), w(0))
pycode = space.interp_w(eval.Code, w_code)
return pycode
diff --git a/pypy/interpreter/pycode.py b/pypy/interpreter/pycode.py
--- a/pypy/interpreter/pycode.py
+++ b/pypy/interpreter/pycode.py
@@ -420,14 +420,14 @@
w(self.co_nlocals),
w(self.co_stacksize),
w(self.co_flags),
- space.wrapbytes(self.co_code),
+ space.newbytes(self.co_code),
space.newtuple(self.co_consts_w),
space.newtuple(self.co_names_w),
space.newtuple([w(v) for v in self.co_varnames]),
w(self.co_filename),
w(self.co_name),
w(self.co_firstlineno),
- space.wrapbytes(self.co_lnotab),
+ space.newbytes(self.co_lnotab),
space.newtuple([w(v) for v in self.co_freevars]),
space.newtuple([w(v) for v in self.co_cellvars]),
w(self.magic),
@@ -448,7 +448,7 @@
space = self.space
# co_name should be an identifier
name = self.co_name.decode('utf-8')
- fn = space.fsdecode_w(space.wrapbytes(self.co_filename))
+ fn = space.fsdecode_w(space.newbytes(self.co_filename))
return space.wrap(u'<code object %s at 0x%s, file "%s", line %d>' % (
name, unicode(self.getaddrstring(space)), fn,
-1 if self.co_firstlineno == 0 else self.co_firstlineno))
diff --git a/pypy/interpreter/pyparser/error.py
b/pypy/interpreter/pyparser/error.py
--- a/pypy/interpreter/pyparser/error.py
+++ b/pypy/interpreter/pyparser/error.py
@@ -25,7 +25,7 @@
'replace')
w_text = space.wrap(text)
if self.filename is not None:
- w_filename = space.fsdecode(space.wrapbytes(self.filename))
+ w_filename = space.fsdecode(space.newbytes(self.filename))
return space.newtuple([space.wrap(self.msg),
space.newtuple([w_filename,
space.wrap(self.lineno),
diff --git a/pypy/interpreter/pyparser/parsestring.py
b/pypy/interpreter/pyparser/parsestring.py
--- a/pypy/interpreter/pyparser/parsestring.py
+++ b/pypy/interpreter/pyparser/parsestring.py
@@ -85,13 +85,13 @@
if rawmode or '\\' not in substr:
if not unicode_literal:
- return space.wrapbytes(substr)
+ return space.newbytes(substr)
else:
v = unicodehelper.decode_utf8(space, substr)
return space.wrap(v)
v = PyString_DecodeEscape(space, substr, 'strict', encoding)
- return space.wrapbytes(v)
+ return space.newbytes(v)
def decode_unicode_utf8(space, s, ps, q):
# ****The Python 2.7 version, producing UTF-32 escapes****
diff --git a/pypy/interpreter/pyparser/pyparse.py
b/pypy/interpreter/pyparser/pyparse.py
--- a/pypy/interpreter/pyparser/pyparse.py
+++ b/pypy/interpreter/pyparser/pyparse.py
@@ -7,7 +7,7 @@
def recode_to_utf8(space, bytes, encoding):
if encoding == 'utf-8':
return bytes
- w_text = space.call_method(space.wrapbytes(bytes), "decode",
+ w_text = space.call_method(space.newbytes(bytes), "decode",
space.wrap(encoding))
w_recoded = space.call_method(w_text, "encode", space.wrap("utf-8"))
return space.bytes_w(w_recoded)
diff --git a/pypy/interpreter/typedef.py b/pypy/interpreter/typedef.py
--- a/pypy/interpreter/typedef.py
+++ b/pypy/interpreter/typedef.py
@@ -345,13 +345,13 @@
def interp_attrproperty_bytes(name, cls, doc=None):
"NOT_RPYTHON: initialization-time only"
def fget(space, obj):
- return space.wrapbytes(getattr(obj, name))
+ return space.newbytes(getattr(obj, name))
return GetSetProperty(fget, cls=cls, doc=doc)
def interp_attrproperty_fsdecode(name, cls, doc=None):
"NOT_RPYTHON: initialization-time only"
def fget(space, obj):
- return space.fsdecode(space.wrapbytes(getattr(obj, name)))
+ return space.fsdecode(space.newbytes(getattr(obj, name)))
return GetSetProperty(fget, cls=cls, doc=doc)
def interp_attrproperty_w(name, cls, doc=None):
diff --git a/pypy/interpreter/unicodehelper.py
b/pypy/interpreter/unicodehelper.py
--- a/pypy/interpreter/unicodehelper.py
+++ b/pypy/interpreter/unicodehelper.py
@@ -18,7 +18,7 @@
startingpos, endingpos):
raise OperationError(space.w_UnicodeDecodeError,
space.newtuple([space.wrap(encoding),
- space.wrapbytes(s),
+ space.newbytes(s),
space.wrap(startingpos),
space.wrap(endingpos),
space.wrap(msg)]))
@@ -111,7 +111,7 @@
return space.call_method(w_uni, 'encode',
getfilesystemencoding(space),
space.wrap('surrogateescape'))
- return space.wrapbytes(bytes)
+ return space.newbytes(bytes)
def encode(space, w_data, encoding=None, errors='strict'):
from pypy.objspace.std.unicodeobject import encode_object
diff --git a/pypy/module/__pypy__/interp_builders.py
b/pypy/module/__pypy__/interp_builders.py
--- a/pypy/module/__pypy__/interp_builders.py
+++ b/pypy/module/__pypy__/interp_builders.py
@@ -40,7 +40,7 @@
s = self.builder.build()
self.builder = None
if strtype is str:
- return space.wrapbytes(s)
+ return space.newbytes(s)
else:
return space.wrap(s)
diff --git a/pypy/module/_cffi_backend/cbuffer.py
b/pypy/module/_cffi_backend/cbuffer.py
--- a/pypy/module/_cffi_backend/cbuffer.py
+++ b/pypy/module/_cffi_backend/cbuffer.py
@@ -55,9 +55,9 @@
start, stop, step, size = space.decode_index4(w_index,
self.buffer.getlength())
if step == 0:
- return space.wrapbytes(self.buffer.getitem(start))
+ return space.newbytes(self.buffer.getitem(start))
res = self.buffer.getslice(start, stop, step, size)
- return space.wrapbytes(res)
+ return space.newbytes(res)
def descr_setitem(self, space, w_index, w_newstring):
start, stop, step, size = space.decode_index4(w_index,
diff --git a/pypy/module/_cffi_backend/ctypeprim.py
b/pypy/module/_cffi_backend/ctypeprim.py
--- a/pypy/module/_cffi_backend/ctypeprim.py
+++ b/pypy/module/_cffi_backend/ctypeprim.py
@@ -84,7 +84,7 @@
if self.size == 1:
with cdataobj as ptr:
s = ptr[0]
- return self.space.wrapbytes(s)
+ return self.space.newbytes(s)
return W_CType.string(self, cdataobj, maxlen)
def unpack_ptr(self, w_ctypeptr, ptr, length):
@@ -126,7 +126,7 @@
return self.space.wrap(ord(cdata[0]))
def convert_to_object(self, cdata):
- return self.space.wrapbytes(cdata[0])
+ return self.space.newbytes(cdata[0])
def _convert_to_char(self, w_ob):
space = self.space
@@ -146,7 +146,7 @@
def unpack_ptr(self, w_ctypeptr, ptr, length):
s = rffi.charpsize2str(ptr, length)
- return self.space.wrapbytes(s)
+ return self.space.newbytes(s)
# XXX explicitly use an integer type instead of lltype.UniChar here,
diff --git a/pypy/module/_cffi_backend/ctypeptr.py
b/pypy/module/_cffi_backend/ctypeptr.py
--- a/pypy/module/_cffi_backend/ctypeptr.py
+++ b/pypy/module/_cffi_backend/ctypeptr.py
@@ -122,7 +122,7 @@
s = rffi.charp2str(ptr)
else:
s = rffi.charp2strn(ptr, length)
- return space.wrapbytes(s)
+ return space.newbytes(s)
#
# pointer to a wchar_t: builds and returns a unicode
if self.is_unichar_ptr_or_array():
@@ -131,7 +131,7 @@
u = rffi.wcharp2unicode(cdata)
else:
u = rffi.wcharp2unicoden(cdata, length)
- return space.wrap(u)
+ return space.newunicode(u)
#
return W_CType.string(self, cdataobj, maxlen)
diff --git a/pypy/module/_codecs/interp_codecs.py
b/pypy/module/_codecs/interp_codecs.py
--- a/pypy/module/_codecs/interp_codecs.py
+++ b/pypy/module/_codecs/interp_codecs.py
@@ -36,7 +36,7 @@
w_errorhandler = lookup_error(space, errors)
if decode:
w_cls = space.w_UnicodeDecodeError
- w_input = space.wrapbytes(input)
+ w_input = space.newbytes(input)
else:
w_cls = space.w_UnicodeEncodeError
w_input = space.wrap(input)
@@ -313,7 +313,7 @@
res += chr(0xe0 | (ch >> 12))
res += chr(0x80 | ((ch >> 6) & 0x3f))
res += chr(0x80 | (ch & 0x3f))
- return space.newtuple([space.wrapbytes(res), w_end])
+ return space.newtuple([space.newbytes(res), w_end])
elif space.isinstance_w(w_exc, space.w_UnicodeDecodeError):
start = space.int_w(space.getattr(w_exc, space.wrap('start')))
obj = space.bytes_w(space.getattr(w_exc, space.wrap('object')))
@@ -355,7 +355,7 @@
# Not a UTF-8b surrogate, fail with original exception
raise OperationError(space.type(w_exc), w_exc)
res += chr(ch - 0xdc00)
- return space.newtuple([space.wrapbytes(res), w_end])
+ return space.newtuple([space.newbytes(res), w_end])
elif space.isinstance_w(w_exc, space.w_UnicodeDecodeError):
consumed = 0
start = space.int_w(space.getattr(w_exc, space.wrap('start')))
@@ -426,7 +426,7 @@
@unwrap_spec(errors='str_or_None')
def readbuffer_encode(space, w_data, errors='strict'):
s = space.getarg_w('s#', w_data)
- return space.newtuple([space.wrapbytes(s), space.wrap(len(s))])
+ return space.newtuple([space.newbytes(s), space.wrap(len(s))])
@unwrap_spec(errors=str)
def decode(space, w_obj, w_encoding=None, errors='strict'):
@@ -484,7 +484,7 @@
state = space.fromcache(CodecState)
func = getattr(runicode, rname)
result = func(uni, len(uni), errors, state.encode_error_handler)
- return space.newtuple([space.wrapbytes(result), space.wrap(len(uni))])
+ return space.newtuple([space.newbytes(result), space.wrap(len(uni))])
wrap_encoder.func_name = rname
globals()[name] = wrap_encoder
@@ -544,7 +544,7 @@
result = runicode.unicode_encode_mbcs(
uni, len(uni), errors, state.encode_error_handler,
force_replace=False)
- return space.newtuple([space.wrapbytes(result), space.wrap(len(uni))])
+ return space.newtuple([space.newbytes(result), space.wrap(len(uni))])
@unwrap_spec(string='bufferstr', errors='str_or_None',
w_final=WrappedDefault(False))
@@ -569,7 +569,7 @@
result = runicode.unicode_encode_utf_8(
uni, len(uni), errors, state.encode_error_handler,
allow_surrogates=False)
- return space.newtuple([space.wrapbytes(result), space.wrap(len(uni))])
+ return space.newtuple([space.newbytes(result), space.wrap(len(uni))])
@unwrap_spec(string='bufferstr', errors='str_or_None',
w_final = WrappedDefault(False))
@@ -735,7 +735,7 @@
result = runicode.unicode_encode_charmap(
uni, len(uni), errors,
state.encode_error_handler, mapping)
- return space.newtuple([space.wrapbytes(result), space.wrap(len(uni))])
+ return space.newtuple([space.newbytes(result), space.wrap(len(uni))])
@unwrap_spec(chars=unicode)
@@ -833,11 +833,11 @@
state = space.fromcache(CodecState)
result = runicode.unicode_encode_unicode_internal(
uni, len(uni), errors, state.encode_error_handler)
- return space.newtuple([space.wrapbytes(result), space.wrap(len(uni))])
+ return space.newtuple([space.newbytes(result), space.wrap(len(uni))])
else:
# special case for this codec: bytes are returned as is
string = space.readbuf_w(w_uni).as_str()
- return space.newtuple([space.wrapbytes(string),
space.wrap(len(string))])
+ return space.newtuple([space.newbytes(string),
space.wrap(len(string))])
# ____________________________________________________________
# support for the "string escape" translation
@@ -848,11 +848,11 @@
data = space.bytes_w(w_data)
from pypy.objspace.std.bytesobject import string_escape_encode
result = string_escape_encode(data, False)
- return space.newtuple([space.wrapbytes(result), space.wrap(len(data))])
+ return space.newtuple([space.newbytes(result), space.wrap(len(data))])
@unwrap_spec(errors='str_or_None')
def escape_decode(space, w_data, errors='strict'):
data = space.getarg_w('s#', w_data)
from pypy.interpreter.pyparser.parsestring import PyString_DecodeEscape
result = PyString_DecodeEscape(space, data, errors, None)
- return space.newtuple([space.wrapbytes(result), space.wrap(len(data))])
+ return space.newtuple([space.newbytes(result), space.wrap(len(data))])
diff --git a/pypy/module/_hashlib/interp_hashlib.py
b/pypy/module/_hashlib/interp_hashlib.py
--- a/pypy/module/_hashlib/interp_hashlib.py
+++ b/pypy/module/_hashlib/interp_hashlib.py
@@ -111,7 +111,7 @@
def digest(self, space):
"Return the digest value as a string of binary data."
digest = self._digest(space)
- return space.wrapbytes(digest)
+ return space.newbytes(digest)
def hexdigest(self, space):
"Return the digest value as a string of hexadecimal digits."
diff --git a/pypy/module/_io/interp_bufferedio.py
b/pypy/module/_io/interp_bufferedio.py
--- a/pypy/module/_io/interp_bufferedio.py
+++ b/pypy/module/_io/interp_bufferedio.py
@@ -352,7 +352,7 @@
self._writer_reset_buf()
def _write(self, space, data):
- w_data = space.wrapbytes(data)
+ w_data = space.newbytes(data)
while True:
try:
w_written = space.call_method(self.w_raw, "write", w_data)
@@ -424,7 +424,7 @@
else:
raise oefmt(space.w_ValueError,
"read length must be positive or -1")
- return space.wrapbytes(res)
+ return space.newbytes(res)
@unwrap_spec(size=int)
def peek_w(self, space, size=0):
@@ -441,7 +441,7 @@
have = self._readahead()
if have > 0:
data = ''.join(self.buffer[self.pos:self.pos+have])
- return space.wrapbytes(data)
+ return space.newbytes(data)
# Fill the buffer from the raw stream, and copy it to the result
self._reader_reset_buf()
@@ -451,7 +451,7 @@
size = 0
self.pos = 0
data = ''.join(self.buffer[:size])
- return space.wrapbytes(data)
+ return space.newbytes(data)
@unwrap_spec(size=int)
def read1_w(self, space, size):
@@ -461,7 +461,7 @@
if size < 0:
raise oefmt(space.w_ValueError, "read length must be positive")
if size == 0:
- return space.wrapbytes("")
+ return space.newbytes("")
with self.lock:
# Return up to n bytes. If at least one byte is buffered, we only
@@ -489,7 +489,7 @@
endpos = self.pos + size
data = ''.join(self.buffer[self.pos:endpos])
self.pos = endpos
- return space.wrapbytes(data)
+ return space.newbytes(data)
def _read_all(self, space):
"Read all the file, don't update the cache"
@@ -522,7 +522,7 @@
current_size += size
if self.abs_pos != -1:
self.abs_pos += size
- return space.wrapbytes(builder.build())
+ return space.newbytes(builder.build())
def _raw_read(self, space, buffer, start, length):
length = intmask(length)
@@ -653,11 +653,11 @@
else:
pos = -1
if pos >= 0:
- w_res = space.wrapbytes(''.join(self.buffer[self.pos:pos+1]))
+ w_res = space.newbytes(''.join(self.buffer[self.pos:pos+1]))
self.pos = pos + 1
return w_res
if have == limit:
- w_res =
space.wrapbytes(''.join(self.buffer[self.pos:self.pos+have]))
+ w_res =
space.newbytes(''.join(self.buffer[self.pos:self.pos+have]))
self.pos += have
return w_res
@@ -699,7 +699,7 @@
written += have
if limit >= 0:
limit -= have
- return space.wrapbytes(''.join(chunks))
+ return space.newbytes(''.join(chunks))
# ____________________________________________________
# Write methods
@@ -943,7 +943,7 @@
w_writer = None
@unwrap_spec(buffer_size=int)
- def descr_init(self, space, w_reader, w_writer,
+ def descr_init(self, space, w_reader, w_writer,
buffer_size=DEFAULT_BUFFER_SIZE):
try:
self.w_reader = W_BufferedReader(space)
diff --git a/pypy/module/_io/interp_bytesio.py
b/pypy/module/_io/interp_bytesio.py
--- a/pypy/module/_io/interp_bytesio.py
+++ b/pypy/module/_io/interp_bytesio.py
@@ -76,12 +76,12 @@
def read_w(self, space, w_size=None):
self._check_closed(space)
size = convert_size(space, w_size)
- return space.wrapbytes(self.read(size))
+ return space.newbytes(self.read(size))
def readline_w(self, space, w_limit=None):
self._check_closed(space)
limit = convert_size(space, w_limit)
- return space.wrapbytes(self.readline(limit))
+ return space.newbytes(self.readline(limit))
def read1_w(self, space, w_size):
return self.read_w(space, w_size)
@@ -128,7 +128,7 @@
def getvalue_w(self, space):
self._check_closed(space)
- return space.wrapbytes(self.getvalue())
+ return space.newbytes(self.getvalue())
def tell_w(self, space):
self._check_closed(space)
@@ -175,7 +175,7 @@
def getstate_w(self, space):
self._check_closed(space)
return space.newtuple([
- space.wrapbytes(self.getvalue()),
+ space.newbytes(self.getvalue()),
space.wrap(self.tell()),
self.getdict(space)])
diff --git a/pypy/module/_io/interp_fileio.py b/pypy/module/_io/interp_fileio.py
--- a/pypy/module/_io/interp_fileio.py
+++ b/pypy/module/_io/interp_fileio.py
@@ -397,7 +397,7 @@
raise wrap_oserror(space, e,
exception_name='w_IOError')
- return space.wrapbytes(s)
+ return space.newbytes(s)
def readinto_w(self, space, w_buffer):
self._check_closed(space)
@@ -441,7 +441,7 @@
break
builder.append(chunk)
total += len(chunk)
- return space.wrapbytes(builder.build())
+ return space.newbytes(builder.build())
if sys.platform == "win32":
def _truncate(self, size):
diff --git a/pypy/module/_io/interp_iobase.py b/pypy/module/_io/interp_iobase.py
--- a/pypy/module/_io/interp_iobase.py
+++ b/pypy/module/_io/interp_iobase.py
@@ -246,7 +246,7 @@
if read[-1] == '\n':
break
- return space.wrapbytes(builder.build())
+ return space.newbytes(builder.build())
def readlines_w(self, space, w_hint=None):
hint = convert_size(space, w_hint)
@@ -361,7 +361,7 @@
if not data:
break
builder.append(data)
- return space.wrapbytes(builder.build())
+ return space.newbytes(builder.build())
W_RawIOBase.typedef = TypeDef(
'_io._RawIOBase', W_IOBase.typedef,
diff --git a/pypy/module/_io/interp_textio.py b/pypy/module/_io/interp_textio.py
--- a/pypy/module/_io/interp_textio.py
+++ b/pypy/module/_io/interp_textio.py
@@ -160,7 +160,7 @@
w_buffer, w_flag = space.unpackiterable(w_state, 2)
flag = space.r_longlong_w(w_flag)
else:
- w_buffer = space.wrapbytes("")
+ w_buffer = space.newbytes("")
flag = 0
flag <<= 1
if self.pendingcr:
@@ -832,7 +832,7 @@
while True:
try:
space.call_method(self.w_buffer, "write",
- space.wrapbytes(pending_bytes))
+ space.newbytes(pending_bytes))
except OperationError as e:
if trap_eintr(space, e):
continue
@@ -861,7 +861,7 @@
space.call_method(self.w_decoder, "reset")
else:
space.call_method(self.w_decoder, "setstate",
- space.newtuple([space.wrapbytes(""),
+ space.newtuple([space.newbytes(""),
space.wrap(cookie.dec_flags)]))
def _encoder_setstate(self, space, cookie):
@@ -1010,7 +1010,7 @@
i = 0
while i < len(input):
w_decoded = space.call_method(self.w_decoder, "decode",
- space.wrapbytes(input[i]))
+ space.newbytes(input[i]))
check_decoded(space, w_decoded)
chars_decoded += len(space.unicode_w(w_decoded))
diff --git a/pypy/module/_locale/interp_locale.py
b/pypy/module/_locale/interp_locale.py
--- a/pypy/module/_locale/interp_locale.py
+++ b/pypy/module/_locale/interp_locale.py
@@ -41,7 +41,7 @@
def charp2uni(space, s):
"Convert a char* pointer to unicode according to the current locale"
- w_bytes = space.wrapbytes(rffi.charp2str(s))
+ w_bytes = space.newbytes(rffi.charp2str(s))
# XXX use mbstowcs()
return space.call_method(w_bytes, "decode", space.wrap("utf-8"))
diff --git a/pypy/module/_md5/interp_md5.py b/pypy/module/_md5/interp_md5.py
--- a/pypy/module/_md5/interp_md5.py
+++ b/pypy/module/_md5/interp_md5.py
@@ -20,7 +20,7 @@
self.update(string)
def digest_w(self):
- return self.space.wrapbytes(self.digest())
+ return self.space.newbytes(self.digest())
def hexdigest_w(self):
return self.space.wrap(self.hexdigest())
diff --git a/pypy/module/_minimal_curses/interp_curses.py
b/pypy/module/_minimal_curses/interp_curses.py
--- a/pypy/module/_minimal_curses/interp_curses.py
+++ b/pypy/module/_minimal_curses/interp_curses.py
@@ -83,12 +83,12 @@
return space.w_None
except curses_error as e:
raise convert_error(space, e)
- return space.wrapbytes(result)
+ return space.newbytes(result)
@unwrap_spec(s='bufferstr')
def tparm(space, s, args_w):
args = [space.int_w(a) for a in args_w]
try:
- return space.wrapbytes(_curses_tparm(s, args))
+ return space.newbytes(_curses_tparm(s, args))
except curses_error as e:
raise convert_error(space, e)
diff --git a/pypy/module/_multibytecodec/interp_incremental.py
b/pypy/module/_multibytecodec/interp_incremental.py
--- a/pypy/module/_multibytecodec/interp_incremental.py
+++ b/pypy/module/_multibytecodec/interp_incremental.py
@@ -113,7 +113,7 @@
pos = c_codecs.pypy_cjk_enc_inbuf_consumed(self.encodebuf)
assert 0 <= pos <= len(object)
self.pending = object[pos:]
- return space.wrapbytes(output)
+ return space.newbytes(output)
@unwrap_spec(errors="str_or_None")
diff --git a/pypy/module/_multibytecodec/interp_multibytecodec.py
b/pypy/module/_multibytecodec/interp_multibytecodec.py
--- a/pypy/module/_multibytecodec/interp_multibytecodec.py
+++ b/pypy/module/_multibytecodec/interp_multibytecodec.py
@@ -40,7 +40,7 @@
raise wrap_unicodeencodeerror(space, e, input, self.name)
except RuntimeError:
raise wrap_runtimeerror(space)
- return space.newtuple([space.wrapbytes(output),
+ return space.newtuple([space.newbytes(output),
space.wrap(len(input))])
@@ -66,7 +66,7 @@
space.w_UnicodeDecodeError,
space.newtuple([
space.wrap(name),
- space.wrapbytes(input),
+ space.newbytes(input),
space.wrap(e.start),
space.wrap(e.end),
space.wrap(e.reason)]))
diff --git a/pypy/module/_multiprocessing/interp_connection.py
b/pypy/module/_multiprocessing/interp_connection.py
--- a/pypy/module/_multiprocessing/interp_connection.py
+++ b/pypy/module/_multiprocessing/interp_connection.py
@@ -123,9 +123,9 @@
space, self.BUFFER_SIZE, maxlength)
try:
if newbuf:
- return space.wrapbytes(rffi.charpsize2str(newbuf, res))
+ return space.newbytes(rffi.charpsize2str(newbuf, res))
else:
- return space.wrapbytes(rffi.charpsize2str(self.buffer, res))
+ return space.newbytes(rffi.charpsize2str(self.buffer, res))
finally:
if newbuf:
rffi.free_charp(newbuf)
@@ -139,7 +139,7 @@
space, length - offset, PY_SSIZE_T_MAX)
try:
if newbuf:
- raise BufferTooShort(space, space.wrapbytes(
+ raise BufferTooShort(space, space.newbytes(
rffi.charpsize2str(newbuf, res)))
rwbuffer.setslice(offset, rffi.charpsize2str(self.buffer, res))
finally:
@@ -167,9 +167,9 @@
space, self.BUFFER_SIZE, PY_SSIZE_T_MAX)
try:
if newbuf:
- w_received = space.wrapbytes(rffi.charpsize2str(newbuf, res))
+ w_received = space.newbytes(rffi.charpsize2str(newbuf, res))
else:
- w_received = space.wrapbytes(rffi.charpsize2str(self.buffer,
res))
+ w_received = space.newbytes(rffi.charpsize2str(self.buffer,
res))
finally:
if newbuf:
rffi.free_charp(newbuf)
diff --git a/pypy/module/_rawffi/alt/test/test_type_converter.py
b/pypy/module/_rawffi/alt/test/test_type_converter.py
--- a/pypy/module/_rawffi/alt/test/test_type_converter.py
+++ b/pypy/module/_rawffi/alt/test/test_type_converter.py
@@ -12,14 +12,14 @@
handle_signed = handle_all
handle_unsigned = handle_all
handle_pointer = handle_all
- handle_char = handle_all
+ handle_char = handle_all
handle_unichar = handle_all
handle_longlong = handle_all
handle_char_p = handle_all
handle_unichar_p = handle_all
handle_float = handle_all
handle_singlefloat = handle_all
-
+
def handle_struct(self, w_ffitype, w_structinstance):
self.lastval = w_structinstance
@@ -119,12 +119,12 @@
def test_strings(self):
# first, try automatic conversion from applevel
- self.check(app_types.char_p, self.space.wrapbytes('foo'), 'foo')
- self.check(app_types.unichar_p, self.space.wrap(u'foo\u1234'),
u'foo\u1234')
- self.check(app_types.unichar_p, self.space.wrap('foo'), u'foo')
+ self.check(app_types.char_p, self.space.newbytes('foo'), 'foo')
+ self.check(app_types.unichar_p, self.space.wrap(u'foo\u1234'),
u'foo\u1234')
+ self.check(app_types.unichar_p, self.space.wrap('foo'), u'foo')
# then, try to pass explicit pointers
self.check(app_types.char_p, self.space.wrap(42), 42)
- self.check(app_types.unichar_p, self.space.wrap(42), 42)
+ self.check(app_types.unichar_p, self.space.wrap(42), 42)
@@ -136,7 +136,7 @@
get_signed = get_all
get_unsigned = get_all
get_pointer = get_all
- get_char = get_all
+ get_char = get_all
get_unichar = get_all
get_longlong = get_all
get_char_p = get_all
@@ -144,7 +144,7 @@
get_float = get_all
get_singlefloat = get_all
get_unsigned_which_fits_into_a_signed = get_all
-
+
def convert(self, w_ffitype, val):
self.val = val
return self.do_and_wrap(w_ffitype)
diff --git a/pypy/module/_rawffi/array.py b/pypy/module/_rawffi/array.py
--- a/pypy/module/_rawffi/array.py
+++ b/pypy/module/_rawffi/array.py
@@ -181,7 +181,7 @@
start, stop = self.decodeslice(space, w_slice)
ll_buffer = self.ll_buffer
result = [ll_buffer[i] for i in range(start, stop)]
- return space.wrapbytes(''.join(result))
+ return space.newbytes(''.join(result))
def setslice(self, space, w_slice, w_value):
start, stop = self.decodeslice(space, w_slice)
diff --git a/pypy/module/_rawffi/interp_rawffi.py
b/pypy/module/_rawffi/interp_rawffi.py
--- a/pypy/module/_rawffi/interp_rawffi.py
+++ b/pypy/module/_rawffi/interp_rawffi.py
@@ -432,7 +432,7 @@
res = func(add_arg, argdesc, rffi.VOIDP)
return space.wrap(rffi.cast(lltype.Unsigned, res))
elif c == 'c':
- return space.wrapbytes(func(add_arg, argdesc, ll_type))
+ return space.newbytes(func(add_arg, argdesc, ll_type))
elif c == 'f' or c == 'd' or c == 'g':
return space.wrap(float(func(add_arg, argdesc, ll_type)))
else:
@@ -573,7 +573,7 @@
s = rffi.charp2str(charp_addr)
else:
s = rffi.charp2strn(charp_addr, maxlength)
- return space.wrapbytes(s)
+ return space.newbytes(s)
@unwrap_spec(address=r_uint, maxlength=int)
def wcharp2unicode(space, address, maxlength=-1):
@@ -591,7 +591,7 @@
if maxlength == -1:
return charp2string(space, address)
s = rffi.charpsize2str(rffi.cast(rffi.CCHARP, address), maxlength)
- return space.wrapbytes(s)
+ return space.newbytes(s)
@unwrap_spec(address=r_uint, maxlength=int)
def wcharp2rawunicode(space, address, maxlength=-1):
diff --git a/pypy/module/_socket/interp_func.py
b/pypy/module/_socket/interp_func.py
--- a/pypy/module/_socket/interp_func.py
+++ b/pypy/module/_socket/interp_func.py
@@ -19,7 +19,7 @@
res = rsocket.gethostname()
except SocketError as e:
raise converted_error(space, e)
- return space.fsdecode(space.wrapbytes(res))
+ return space.fsdecode(space.newbytes(res))
@unwrap_spec(host=str)
def gethostbyname(space, host):
@@ -224,7 +224,7 @@
buf = rsocket.inet_aton(ip)
except SocketError as e:
raise converted_error(space, e)
- return space.wrapbytes(buf)
+ return space.newbytes(buf)
@unwrap_spec(packed="bufferstr")
def inet_ntoa(space, packed):
@@ -249,7 +249,7 @@
buf = rsocket.inet_pton(family, ip)
except SocketError as e:
raise converted_error(space, e)
- return space.wrapbytes(buf)
+ return space.newbytes(buf)
@unwrap_spec(family=int, packed="bufferstr")
def inet_ntop(space, family, packed):
diff --git a/pypy/module/_socket/interp_socket.py
b/pypy/module/_socket/interp_socket.py
--- a/pypy/module/_socket/interp_socket.py
+++ b/pypy/module/_socket/interp_socket.py
@@ -37,7 +37,7 @@
path = addr.get_path()
if _c.linux and len(path) > 0 and path[0] == '\x00':
# Linux abstract namespace
- return space.wrapbytes(path)
+ return space.newbytes(path)
else:
return space.wrap_fsdecoded(path)
elif rsocket.HAS_AF_NETLINK and isinstance(addr, rsocket.NETLINKAddress):
@@ -345,7 +345,7 @@
except SocketError as e:
raise converted_error(space, e)
buflen = space.int_w(w_buflen)
- return space.wrapbytes(self.sock.getsockopt(level, optname, buflen))
+ return space.newbytes(self.sock.getsockopt(level, optname, buflen))
def gettimeout_w(self, space):
"""gettimeout() -> timeout
@@ -384,7 +384,7 @@
data = self.sock.recv(buffersize, flags)
except SocketError as e:
raise converted_error(space, e)
- return space.wrapbytes(data)
+ return space.newbytes(data)
@unwrap_spec(buffersize='nonnegint', flags=int)
def recvfrom_w(self, space, buffersize, flags=0):
@@ -398,7 +398,7 @@
w_addr = addr_as_object(addr, self.sock.fd, space)
else:
w_addr = space.w_None
- return space.newtuple([space.wrapbytes(data), w_addr])
+ return space.newtuple([space.newbytes(data), w_addr])
except SocketError as e:
raise converted_error(space, e)
diff --git a/pypy/module/_sre/interp_sre.py b/pypy/module/_sre/interp_sre.py
--- a/pypy/module/_sre/interp_sre.py
+++ b/pypy/module/_sre/interp_sre.py
@@ -36,12 +36,12 @@
def slice_w(space, ctx, start, end, w_default):
if 0 <= start <= end:
if isinstance(ctx, rsre_core.BufMatchContext):
- return space.wrapbytes(ctx._buffer.getslice(start, end, 1,
+ return space.newbytes(ctx._buffer.getslice(start, end, 1,
end-start))
if isinstance(ctx, rsre_core.StrMatchContext):
- return space.wrapbytes(ctx._string[start:end])
+ return space.newbytes(ctx._string[start:end])
elif isinstance(ctx, rsre_core.UnicodeMatchContext):
- return space.wrap(ctx._unicodestr[start:end])
+ return space.newunicode(ctx._unicodestr[start:end])
else:
# unreachable
raise SystemError
@@ -346,15 +346,15 @@
strbuilder, unicodebuilder, last_pos, ctx.end)
if use_builder:
if strbuilder is not None:
- return space.wrapbytes(strbuilder.build()), n
+ return space.newbytes(strbuilder.build()), n
else:
assert unicodebuilder is not None
- return space.wrap(unicodebuilder.build()), n
+ return space.newunicode(unicodebuilder.build()), n
else:
if space.isinstance_w(w_string, space.w_unicode):
- w_emptystr = space.wrap(u'')
+ w_emptystr = space.newunicode(u'')
else:
- w_emptystr = space.wrapbytes('')
+ w_emptystr = space.newbytes('')
w_item = space.call_method(w_emptystr, 'join',
space.newlist(sublist_w))
return w_item, n
@@ -584,11 +584,11 @@
def fget_string(self, space):
ctx = self.ctx
if isinstance(ctx, rsre_core.BufMatchContext):
- return space.wrapbytes(ctx._buffer.as_str())
+ return space.newbytes(ctx._buffer.as_str())
elif isinstance(ctx, rsre_core.StrMatchContext):
- return space.wrapbytes(ctx._string)
+ return space.newbytes(ctx._string)
elif isinstance(ctx, rsre_core.UnicodeMatchContext):
- return space.wrap(ctx._unicodestr)
+ return space.newunicode(ctx._unicodestr)
else:
raise SystemError
diff --git a/pypy/module/_ssl/interp_ssl.py b/pypy/module/_ssl/interp_ssl.py
--- a/pypy/module/_ssl/interp_ssl.py
+++ b/pypy/module/_ssl/interp_ssl.py
@@ -252,14 +252,14 @@
rffi.cast(rffi.UCHARP, buf.raw), n)
if ok == 0 or ok == 1:
return space.newtuple([
- space.wrapbytes(buf.str(n)),
+ space.newbytes(buf.str(n)),
space.wrap(ok == 1),
])
else:
ok = libssl_RAND_bytes(
rffi.cast(rffi.UCHARP, buf.raw), n)
if ok == 1:
- return space.wrapbytes(buf.str(n))
+ return space.newbytes(buf.str(n))
raise ssl_error(space, "", errcode=libssl_ERR_get_error())
@@ -404,7 +404,7 @@
elif sockstate == SOCKET_HAS_BEEN_CLOSED:
if libssl_SSL_get_shutdown(self.ssl) == SSL_RECEIVED_SHUTDOWN:
if space.is_none(w_buffer):
- return space.wrapbytes('')
+ return space.newbytes('')
else:
return space.wrap(0)
raise ssl_error(space,
@@ -430,7 +430,7 @@
elif (err == SSL_ERROR_ZERO_RETURN and
libssl_SSL_get_shutdown(self.ssl) ==
SSL_RECEIVED_SHUTDOWN):
if space.is_none(w_buffer):
- return space.wrapbytes('')
+ return space.newbytes('')
else:
return space.wrap(0)
else:
@@ -455,7 +455,7 @@
rwbuffer.setslice(0, result)
return space.wrap(count)
else:
- return space.wrapbytes(result)
+ return space.newbytes(result)
def _get_socket(self, space):
w_socket = self.w_socket()
@@ -677,7 +677,7 @@
length = libssl_SSL_get_peer_finished(self.ssl, buf, CB_MAXLEN)
if length > 0:
- return space.wrapbytes(rffi.charpsize2str(buf,
intmask(length)))
+ return space.newbytes(rffi.charpsize2str(buf, intmask(length)))
def descr_get_context(self, space):
return self.w_ctx
@@ -716,7 +716,7 @@
if length < 0:
raise _ssl_seterror(space, None, 0)
try:
- return space.wrapbytes(rffi.charpsize2str(buf_ptr[0], length))
+ return space.newbytes(rffi.charpsize2str(buf_ptr[0], length))
finally:
libssl_OPENSSL_free(buf_ptr[0])
@@ -935,7 +935,7 @@
if length < 0:
raise _ssl_seterror(space, None, 0)
try:
- w_value = space.wrapbytes(rffi.charpsize2str(buf_ptr[0], length))
+ w_value = space.newbytes(rffi.charpsize2str(buf_ptr[0], length))
w_value = space.call_method(w_value, "decode", space.wrap("utf-8"))
finally:
libssl_OPENSSL_free(buf_ptr[0])
@@ -1273,7 +1273,7 @@
w_ssl_socket, space.w_None, w_ctx)
else:
- w_servername = space.wrapbytes(rffi.charp2str(servername))
+ w_servername = space.newbytes(rffi.charp2str(servername))
try:
w_servername_idna = space.call_method(
w_servername, 'decode', space.wrap('idna'))
@@ -1326,7 +1326,7 @@
rgc.add_memory_pressure(10 * 1024 * 1024)
self.check_hostname = False
self.register_finalizer(space)
-
+
# Defaults
libssl_SSL_CTX_set_verify(self.ctx, SSL_VERIFY_NONE, None)
options = SSL_OP_ALL & ~SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
@@ -1849,7 +1849,7 @@
if not path:
return space.w_None
else:
- return fsdecode(space, space.wrapbytes(rffi.charp2str(path)))
+ return fsdecode(space, space.newbytes(rffi.charp2str(path)))
def get_default_verify_paths(space):
return space.newtuple([
diff --git a/pypy/module/_ssl/interp_win32.py b/pypy/module/_ssl/interp_win32.py
--- a/pypy/module/_ssl/interp_win32.py
+++ b/pypy/module/_ssl/interp_win32.py
@@ -74,7 +74,7 @@
def w_parseKeyUsage(space, pCertCtx, flags):
with lltype.scoped_alloc(rwin32.LPDWORD.TO, 1) as size_ptr:
- if not CertGetEnhancedKeyUsage(pCertCtx, flags,
+ if not CertGetEnhancedKeyUsage(pCertCtx, flags,
lltype.nullptr(CERT_ENHKEY_USAGE), size_ptr):
last_error = rwin32.lastSavedWindowsError()
if last_error.winerror == CRYPT_E_NOT_FOUND:
@@ -120,7 +120,7 @@
pCertCtx = CertEnumCertificatesInStore(hStore, pCertCtx)
if not pCertCtx:
break
- w_cert = space.wrapbytes(
+ w_cert = space.newbytes(
rffi.charpsize2str(pCertCtx.c_pbCertEncoded,
intmask(pCertCtx.c_cbCertEncoded)))
w_enc = w_certEncodingType(space, pCertCtx.c_dwCertEncodingType)
@@ -162,7 +162,7 @@
pCrlCtx = CertEnumCRLsInStore(hStore, pCrlCtx)
if not pCrlCtx:
break
- w_crl = space.wrapbytes(
+ w_crl = space.newbytes(
rffi.charpsize2str(pCrlCtx.c_pbCrlEncoded,
intmask(pCrlCtx.c_cbCrlEncoded)))
w_enc = w_certEncodingType(space, pCrlCtx.c_dwCertEncodingType)
diff --git a/pypy/module/_winreg/interp_winreg.py
b/pypy/module/_winreg/interp_winreg.py
--- a/pypy/module/_winreg/interp_winreg.py
+++ b/pypy/module/_winreg/interp_winreg.py
@@ -378,7 +378,7 @@
return space.newlist(l)
else: # REG_BINARY and all other types
- return space.wrapbytes(rffi.charpsize2str(buf, buflen))
+ return space.newbytes(rffi.charpsize2str(buf, buflen))
@unwrap_spec(value_name=str, typ=int)
def SetValueEx(space, w_hkey, value_name, w_reserved, typ, w_value):
diff --git a/pypy/module/_winreg/test/test_winreg.py
b/pypy/module/_winreg/test/test_winreg.py
--- a/pypy/module/_winreg/test/test_winreg.py
+++ b/pypy/module/_winreg/test/test_winreg.py
@@ -48,7 +48,7 @@
]
cls.w_test_data = w_test_data = space.wrap(test_data)
w_btest = space.newtuple([space.wrap("Raw data"),
- space.wrapbytes("binary\x00data"),
+ space.newbytes("binary\x00data"),
space.wrap(_winreg.REG_BINARY)])
w_test_data.append(w_btest)
diff --git a/pypy/module/array/interp_array.py
b/pypy/module/array/interp_array.py
--- a/pypy/module/array/interp_array.py
+++ b/pypy/module/array/interp_array.py
@@ -242,11 +242,11 @@
"""
size = self.len
if size == 0:
- return space.wrapbytes('')
+ return space.newbytes('')
cbuf = self._charbuf_start()
s = rffi.charpsize2str(cbuf, size * self.itemsize)
self._charbuf_stop()
- return self.space.wrapbytes(s)
+ return self.space.newbytes(s)
def descr_fromstring(self, space, w_s):
""" fromstring(string)
diff --git a/pypy/module/binascii/interp_base64.py
b/pypy/module/binascii/interp_base64.py
--- a/pypy/module/binascii/interp_base64.py
+++ b/pypy/module/binascii/interp_base64.py
@@ -25,7 +25,7 @@
-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
- -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
+ -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
]
def _transform(n):
if n == -1:
@@ -71,7 +71,7 @@
if leftbits != 0:
raise_Error(space, "Incorrect padding")
- return space.wrapbytes(res.build())
+ return space.newbytes(res.build())
# ____________________________________________________________
@@ -110,4 +110,4 @@
res.append(table_b2a_base64[(leftchar & 0xf) << 2])
res.append(PAD)
res.append('\n')
- return space.wrapbytes(res.build())
+ return space.newbytes(res.build())
diff --git a/pypy/module/binascii/interp_hexlify.py
b/pypy/module/binascii/interp_hexlify.py
--- a/pypy/module/binascii/interp_hexlify.py
+++ b/pypy/module/binascii/interp_hexlify.py
@@ -26,7 +26,7 @@
for c in data:
res.append(_value2char(ord(c) >> 4))
res.append(_value2char(ord(c) & 0xf))
- return space.wrapbytes(res.build())
+ return space.newbytes(res.build())
# ____________________________________________________________
@@ -55,4 +55,4 @@
a = _char2value(space, hexstr[i])
b = _char2value(space, hexstr[i+1])
res.append(chr((a << 4) | b))
- return space.wrapbytes(res.build())
+ return space.newbytes(res.build())
diff --git a/pypy/module/binascii/interp_hqx.py
b/pypy/module/binascii/interp_hqx.py
--- a/pypy/module/binascii/interp_hqx.py
+++ b/pypy/module/binascii/interp_hqx.py
@@ -12,37 +12,37 @@
FAIL = 0x7d
table_a2b_hqx = [
- #^@ ^A ^B ^C ^D ^E ^F ^G
+ #^@ ^A ^B ^C ^D ^E ^F ^G
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
- #\b \t \n ^K ^L \r ^N ^O
+ #\b \t \n ^K ^L \r ^N ^O
FAIL, FAIL, SKIP, FAIL, FAIL, SKIP, FAIL, FAIL,
- #^P ^Q ^R ^S ^T ^U ^V ^W
+ #^P ^Q ^R ^S ^T ^U ^V ^W
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
- #^X ^Y ^Z ^[ ^\ ^] ^^ ^_
+ #^X ^Y ^Z ^[ ^\ ^] ^^ ^_
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
- # ! " # $ % & '
+ # ! " # $ % & '
FAIL, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
- #( ) * + , - . /
+ #( ) * + , - . /
0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, FAIL, FAIL,
- #0 1 2 3 4 5 6 7
+ #0 1 2 3 4 5 6 7
0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, FAIL,
- #8 9 : ; < = > ?
+ #8 9 : ; < = > ?
0x14, 0x15, DONE, FAIL, FAIL, FAIL, FAIL, FAIL,
- #@ A B C D E F G
+ #@ A B C D E F G
0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,
- #H I J K L M N O
+ #H I J K L M N O
0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, FAIL,
- #P Q R S T U V W
+ #P Q R S T U V W
0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, FAIL,
- #X Y Z [ \ ] ^ _
+ #X Y Z [ \ ] ^ _
0x2C, 0x2D, 0x2E, 0x2F, FAIL, FAIL, FAIL, FAIL,
- #` a b c d e f g
+ #` a b c d e f g
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, FAIL,
- #h i j k l m n o
+ #h i j k l m n o
0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, FAIL, FAIL,
- #p q r s t u v w
+ #p q r s t u v w
0x3D, 0x3E, 0x3F, FAIL, FAIL, FAIL, FAIL, FAIL,
- #x y z { | } ~ ^?
+ #x y z { | } ~ ^?
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
@@ -98,7 +98,7 @@
else:
if pending_bits > 0:
raise_Incomplete(space, 'String has incomplete number of bytes')
- return space.newtuple([space.wrapbytes(res.build()), space.wrap(done)])
+ return space.newtuple([space.newbytes(res.build()), space.wrap(done)])
# ____________________________________________________________
@@ -129,7 +129,7 @@
if leftbits > 0:
leftchar <<= (6 - leftbits)
res.append(hqx_encoding[leftchar & 0x3f])
- return space.wrapbytes(res.build())
+ return space.newbytes(res.build())
# ____________________________________________________________
@@ -161,7 +161,7 @@
if lastpushed < 0:
raise_Error(space, 'String starts with the RLE code \\x90')
res.append_multiple_char(chr(lastpushed), count)
- return space.wrapbytes(res.build())
+ return space.newbytes(res.build())
# ____________________________________________________________
@@ -198,7 +198,7 @@
# string that rledecode_hqx() would expand back to 'data', there are
# some programs somewhere that would start failing obscurely in rare
# cases.
- return space.wrapbytes(res.build())
+ return space.newbytes(res.build())
# ____________________________________________________________
diff --git a/pypy/module/binascii/interp_qp.py
b/pypy/module/binascii/interp_qp.py
--- a/pypy/module/binascii/interp_qp.py
+++ b/pypy/module/binascii/interp_qp.py
@@ -57,7 +57,7 @@
if header and c == '_':
c = ' '
odata.append(c)
- return space.wrapbytes(odata.build())
+ return space.newbytes(odata.build())
# ____________________________________________________________
@@ -160,4 +160,4 @@
odata.append(c)
inp += 1
- return space.wrapbytes(odata.build())
+ return space.newbytes(odata.build())
diff --git a/pypy/module/binascii/interp_uu.py
b/pypy/module/binascii/interp_uu.py
--- a/pypy/module/binascii/interp_uu.py
+++ b/pypy/module/binascii/interp_uu.py
@@ -55,7 +55,7 @@
remaining = length - res.getlength()
if remaining > 0:
res.append_multiple_char('\x00', remaining)
- return space.wrapbytes(res.build())
+ return space.newbytes(res.build())
# ____________________________________________________________
@@ -87,4 +87,4 @@
res.append(chr(0x20 + (C & 0x3F)))
res.append('\n')
- return space.wrapbytes(res.build())
+ return space.newbytes(res.build())
diff --git a/pypy/module/bz2/interp_bz2.py b/pypy/module/bz2/interp_bz2.py
--- a/pypy/module/bz2/interp_bz2.py
+++ b/pypy/module/bz2/interp_bz2.py
@@ -295,7 +295,7 @@
datasize = len(data)
if datasize == 0:
- return self.space.wrapbytes("")
+ return self.space.newbytes("")
if not self.running:
raise oefmt(self.space.w_ValueError,
@@ -320,7 +320,7 @@
out.prepare_next_chunk()
res = out.make_result_string()
- return self.space.wrapbytes(res)
+ return self.space.newbytes(res)
def flush(self):
if not self.running:
@@ -340,7 +340,7 @@
out.prepare_next_chunk()
res = out.make_result_string()
- return self.space.wrapbytes(res)
+ return self.space.newbytes(res)
W_BZ2Compressor.typedef = TypeDef("_bz2.BZ2Compressor",
__doc__ = W_BZ2Compressor.__doc__,
@@ -417,7 +417,7 @@
raise oefmt(self.space.w_EOFError,
"end of stream was already found")
if data == '':
- return self.space.wrapbytes('')
+ return self.space.newbytes('')
in_bufsize = len(data)
@@ -446,7 +446,7 @@
out.prepare_next_chunk()
res = out.make_result_string()
- return self.space.wrapbytes(res)
+ return self.space.newbytes(res)
W_BZ2Decompressor.typedef = TypeDef("_bz2.BZ2Decompressor",
diff --git a/pypy/module/bz2/test/test_bz2_compdecomp.py
b/pypy/module/bz2/test/test_bz2_compdecomp.py
--- a/pypy/module/bz2/test/test_bz2_compdecomp.py
+++ b/pypy/module/bz2/test/test_bz2_compdecomp.py
@@ -44,13 +44,13 @@
spaceconfig = dict(usemodules=('bz2', 'time', 'struct'))
def setup_class(cls):
- cls.w_TEXT = cls.space.wrapbytes(TEXT)
+ cls.w_TEXT = cls.space.newbytes(TEXT)
if cls.runappdirect:
cls.w_decompress = decompress
else:
@gateway.unwrap_spec(data=bytes)
def decompress_w(space, data):
- return space.wrapbytes(decompress(cls, data))
+ return space.newbytes(decompress(cls, data))
cls.w_decompress = cls.space.wrap(gateway.interp2app(decompress_w))
cls.w_HUGE_OK = cls.space.wrap(HUGE_OK)
@@ -120,9 +120,9 @@
spaceconfig = dict(usemodules=('bz2', 'time', 'struct'))
def setup_class(cls):
- cls.w_TEXT = cls.space.wrapbytes(TEXT)
- cls.w_DATA = cls.space.wrapbytes(DATA)
- cls.w_BUGGY_DATA = cls.space.wrapbytes(BUGGY_DATA)
+ cls.w_TEXT = cls.space.newbytes(TEXT)
+ cls.w_DATA = cls.space.newbytes(DATA)
+ cls.w_BUGGY_DATA = cls.space.newbytes(BUGGY_DATA)
cls.space.appexec([], """(): import warnings""") # Work around a
recursion limit
@@ -205,14 +205,14 @@
spaceconfig = dict(usemodules=('bz2', 'time'))
def setup_class(cls):
- cls.w_TEXT = cls.space.wrapbytes(TEXT)
- cls.w_DATA = cls.space.wrapbytes(DATA)
+ cls.w_TEXT = cls.space.newbytes(TEXT)
+ cls.w_DATA = cls.space.newbytes(DATA)
if cls.runappdirect:
cls.w_decompress = decompress
else:
@gateway.unwrap_spec(data=bytes)
def decompress_w(space, data):
- return space.wrapbytes(decompress(cls, data))
+ return space.newbytes(decompress(cls, data))
cls.w_decompress = cls.space.wrap(gateway.interp2app(decompress_w))
cls.w_HUGE_OK = cls.space.wrap(HUGE_OK)
diff --git a/pypy/module/bz2/test/test_bz2_file.py
b/pypy/module/bz2/test/test_bz2_file.py
--- a/pypy/module/bz2/test/test_bz2_file.py
+++ b/pypy/module/bz2/test/test_bz2_file.py
@@ -42,7 +42,7 @@
mod.TEXT =
'root:x:0:0:root:/root:/bin/bash\nbin:x:1:1:bin:/bin:\ndaemon:x:2:2:daemon:/sbin:\nadm:x:3:4:adm:/var/adm:\nlp:x:4:7:lp:/var/spool/lpd:\nsync:x:5:0:sync:/sbin:/bin/sync\nshutdown:x:6:0:shutdown:/sbin:/sbin/shutdown\nhalt:x:7:0:halt:/sbin:/sbin/halt\nmail:x:8:12:mail:/var/spool/mail:\nnews:x:9:13:news:/var/spool/news:\nuucp:x:10:14:uucp:/var/spool/uucp:\noperator:x:11:0:operator:/root:\ngames:x:12:100:games:/usr/games:\ngopher:x:13:30:gopher:/usr/lib/gopher-data:\nftp:x:14:50:FTP
User:/var/ftp:/bin/bash\nnobody:x:65534:65534:Nobody:/home:\npostfix:x:100:101:postfix:/var/spool/postfix:\nniemeyer:x:500:500::/home/niemeyer:/bin/bash\npostgres:x:101:102:PostgreSQL
Server:/var/lib/pgsql:/bin/bash\nmysql:x:102:103:MySQL
server:/var/lib/mysql:/bin/bash\nwww:x:103:104::/var/www:/bin/false\n'
mod.DATA = DATA
- mod.DATA_CRLF = DATA_CRLF
+ mod.DATA_CRLF = DATA_CRLF
mod.create_temp_file = create_temp_file
mod.decompress = decompress
mod.create_broken_temp_file = create_broken_temp_file
@@ -58,11 +58,11 @@
}
def setup_class(cls):
- cls.w_TEXT = cls.space.wrapbytes(TEXT)
+ cls.w_TEXT = cls.space.newbytes(TEXT)
cls.DATA = DATA
- cls.w_DATA = cls.space.wrapbytes(DATA)
+ cls.w_DATA = cls.space.newbytes(DATA)
cls.DATA_CRLF = DATA_CRLF
- cls.w_DATA_CRLF = cls.space.wrapbytes(DATA_CRLF)
+ cls.w_DATA_CRLF = cls.space.newbytes(DATA_CRLF)
cls.temppath = str(py.test.ensuretemp("bz2").join("foo"))
cls.w_temppath = cls.space.wrap(cls.temppath)
if cls.runappdirect:
@@ -78,14 +78,14 @@
@gateway.unwrap_spec(data=bytes)
def decompress_w(space, data):
- return space.wrapbytes(decompress(cls, data))
+ return space.newbytes(decompress(cls, data))
cls.w_decompress = cls.space.wrap(gateway.interp2app(decompress_w))
def create_broken_temp_file_w():
create_broken_temp_file(cls)
cls.w_create_broken_temp_file = cls.space.wrap(
gateway.interp2app(create_broken_temp_file_w))
- cls.w_random_data = cls.space.wrapbytes(RANDOM_DATA)
+ cls.w_random_data = cls.space.newbytes(RANDOM_DATA)
cls.space.appexec([], """(): import warnings""") # Work around a
recursion limit
@@ -407,7 +407,7 @@
# has_cmdline_bunzip2 = sys.platform not in ("win32", "os2emx", "riscos")
-#
+#
# if has_cmdline_bunzip2:
# def decompress(self, data):
# pop = popen2.Popen3("bunzip2", capturestderr=1)
@@ -418,7 +418,7 @@
# if pop.wait() != 0:
# ret = bz2.decompress(data)
# return ret
-#
+#
# else:
# # popen2.Popen3 doesn't exist on Windows, and even if it did, bunzip2
# # isn't available to run.
diff --git a/pypy/module/bz2/test/test_large.py
b/pypy/module/bz2/test/test_large.py
--- a/pypy/module/bz2/test/test_large.py
+++ b/pypy/module/bz2/test/test_large.py
@@ -8,7 +8,7 @@
if not cls.runappdirect:
py.test.skip("skipping this very slow test; try 'pypy-c -A'")
largetest_bz2 = py.path.local(__file__).dirpath().join("largetest.bz2")
- cls.w_compressed_data = cls.space.wrapbytes(largetest_bz2.read('rb'))
+ cls.w_compressed_data = cls.space.newbytes(largetest_bz2.read('rb'))
def test_decompress(self):
from bz2 import decompress
diff --git a/pypy/module/cpyext/bytearrayobject.py
b/pypy/module/cpyext/bytearrayobject.py
--- a/pypy/module/cpyext/bytearrayobject.py
+++ b/pypy/module/cpyext/bytearrayobject.py
@@ -46,7 +46,7 @@
"""Create a new bytearray object from string and its length, len. On
failure, NULL is returned."""
if char_p:
- w_s = space.wrapbytes(rffi.charpsize2str(char_p, length))
+ w_s = space.newbytes(rffi.charpsize2str(char_p, length))
else:
w_s = space.newint(length)
w_buffer = space.call_function(space.w_bytearray, w_s)
@@ -80,7 +80,7 @@
if space.isinstance_w(w_obj, space.w_bytearray):
oldlen = space.len_w(w_obj)
if newlen > oldlen:
- space.call_method(w_obj, 'extend', space.wrapbytes('\x00' *
(newlen - oldlen)))
+ space.call_method(w_obj, 'extend', space.newbytes('\x00' * (newlen
- oldlen)))
elif oldlen > newlen:
assert newlen >= 0
space.delslice(w_obj, space.wrap(newlen), space.wrap(oldlen))
diff --git a/pypy/module/cpyext/eval.py b/pypy/module/cpyext/eval.py
--- a/pypy/module/cpyext/eval.py
+++ b/pypy/module/cpyext/eval.py
@@ -13,7 +13,7 @@
"PyCompilerFlags", (("cf_flags", rffi.INT),))
PyCompilerFlagsPtr = lltype.Ptr(PyCompilerFlags)
-PyCF_MASK = (consts.CO_FUTURE_DIVISION |
+PyCF_MASK = (consts.CO_FUTURE_DIVISION |
consts.CO_FUTURE_ABSOLUTE_IMPORT |
consts.CO_FUTURE_WITH_STATEMENT |
consts.CO_FUTURE_PRINT_FUNCTION |
@@ -94,7 +94,7 @@
Py_eval_input = 258
def compile_string(space, source, filename, start, flags=0):
- w_source = space.wrapbytes(source)
+ w_source = space.newbytes(source)
start = rffi.cast(lltype.Signed, start)
if start == Py_file_input:
mode = 'exec'
@@ -227,4 +227,4 @@
cf.c_cf_flags = rffi.cast(rffi.INT, flags)
return result
-
+
diff --git a/pypy/module/cpyext/pyfile.py b/pypy/module/cpyext/pyfile.py
--- a/pypy/module/cpyext/pyfile.py
+++ b/pypy/module/cpyext/pyfile.py
@@ -19,7 +19,7 @@
try:
w_readline = space.getattr(w_obj, space.wrap('readline'))
except OperationError:
- raise oefmt(space.w_TypeError,
+ raise oefmt(space.w_TypeError,
"argument must be a file, or have a readline() method.")
n = rffi.cast(lltype.Signed, n)
@@ -37,7 +37,7 @@
On success, return a new file object that is opened on the file given by
filename, with a file mode given by mode, where mode has the same
semantics as the standard C routine fopen(). On failure, return NULL."""
- w_filename = space.wrapbytes(rffi.charp2str(filename))
+ w_filename = space.newbytes(rffi.charp2str(filename))
w_mode = space.wrap(rffi.charp2str(mode))
return space.call_method(space.builtin, 'open', w_filename, w_mode)
diff --git a/pypy/module/cpyext/test/test_memoryobject.py
b/pypy/module/cpyext/test/test_memoryobject.py
--- a/pypy/module/cpyext/test/test_memoryobject.py
+++ b/pypy/module/cpyext/test/test_memoryobject.py
@@ -8,7 +8,7 @@
space.wrap((2, 7)))):
py.test.skip("unsupported before Python 2.7")
- w_hello = space.wrapbytes("hello")
+ w_hello = space.newbytes("hello")
w_view = api.PyMemoryView_FromObject(w_hello)
w_bytes = space.call_method(w_view, "tobytes")
assert space.unwrap(w_bytes) == "hello"
diff --git a/pypy/module/cpyext/test/test_pyfile.py
b/pypy/module/cpyext/test/test_pyfile.py
--- a/pypy/module/cpyext/test/test_pyfile.py
+++ b/pypy/module/cpyext/test/test_pyfile.py
@@ -13,7 +13,7 @@
rffi.free_charp(filename)
rffi.free_charp(mode)
- space.call_method(w_file, "write", space.wrapbytes("text"))
+ space.call_method(w_file, "write", space.newbytes("text"))
space.call_method(w_file, "close")
assert (udir / "_test_file").read() == "text"
diff --git a/pypy/module/cpyext/unicodeobject.py
b/pypy/module/cpyext/unicodeobject.py
--- a/pypy/module/cpyext/unicodeobject.py
+++ b/pypy/module/cpyext/unicodeobject.py
@@ -373,10 +373,10 @@
if not encoding:
# This tracks CPython 2.7, in CPython 3.4 'utf-8' is hardcoded instead
encoding = PyUnicode_GetDefaultEncoding(space)
- w_str = space.wrapbytes(rffi.charpsize2str(s, size))
+ w_str = space.newbytes(rffi.charpsize2str(s, size))
w_encoding = space.wrap(rffi.charp2str(encoding))
if errors:
- w_errors = space.wrapbytes(rffi.charp2str(errors))
+ w_errors = space.newbytes(rffi.charp2str(errors))
else:
w_errors = None
return space.call_method(w_str, 'decode', w_encoding, w_errors)
@@ -481,7 +481,7 @@
locale encoding.
Use 'strict' error handler on Windows."""
- w_bytes = space.wrapbytes(rffi.charpsize2str(s, size))
+ w_bytes = space.newbytes(rffi.charpsize2str(s, size))
return space.fsdecode(w_bytes)
@@ -496,7 +496,7 @@
Use PyUnicode_DecodeFSDefaultAndSize() if you know the string length.
Use 'strict' error handler on Windows."""
- w_bytes = space.wrapbytes(rffi.charp2str(s))
+ w_bytes = space.newbytes(rffi.charp2str(s))
return space.fsdecode(w_bytes)
@@ -516,7 +516,7 @@
@cpython_api([CONST_STRING], PyObject)
def PyUnicode_FromString(space, s):
"""Create a Unicode object from an UTF-8 encoded null-terminated char
buffer"""
- w_str = space.wrapbytes(rffi.charp2str(s))
+ w_str = space.newbytes(rffi.charp2str(s))
return space.call_method(w_str, 'decode', space.wrap("utf-8"))
@cpython_api([CONST_STRING], PyObject)
@@ -594,7 +594,7 @@
encoded string s. Return NULL if an exception was raised by
the codec.
"""
- w_s = space.wrapbytes(rffi.charpsize2str(s, size))
+ w_s = space.newbytes(rffi.charpsize2str(s, size))
if errors:
w_errors = space.wrap(rffi.charp2str(errors))
else:
diff --git a/pypy/module/exceptions/interp_exceptions.py
b/pypy/module/exceptions/interp_exceptions.py
--- a/pypy/module/exceptions/interp_exceptions.py
+++ b/pypy/module/exceptions/interp_exceptions.py
@@ -844,7 +844,7 @@
def descr_init(self, space, w_encoding, w_object, w_start, w_end,
w_reason):
# typechecking
if space.isinstance_w(w_object, space.w_bytearray):
- w_bytes = space.wrapbytes(space.bufferstr_w(w_object))
+ w_bytes = space.newbytes(space.bufferstr_w(w_object))
else:
w_bytes = w_object
space.str_w(w_encoding)
diff --git a/pypy/module/fcntl/interp_fcntl.py
b/pypy/module/fcntl/interp_fcntl.py
--- a/pypy/module/fcntl/interp_fcntl.py
+++ b/pypy/module/fcntl/interp_fcntl.py
@@ -111,7 +111,7 @@
if rv < 0:
raise _get_error(space, "fcntl")
arg = rffi.charpsize2str(ll_arg, len(arg))
- return space.wrapbytes(arg)
+ return space.newbytes(arg)
finally:
lltype.free(ll_arg, flavor='raw')
@@ -225,7 +225,7 @@
if mutate_flag != 0:
rwbuffer.setslice(0, arg)
return space.wrap(rv)
- return space.wrapbytes(arg)
+ return space.newbytes(arg)
finally:
lltype.free(ll_arg, flavor='raw')
@@ -246,7 +246,7 @@
if rv < 0:
raise _get_error(space, "ioctl")
arg = rffi.charpsize2str(ll_arg, len(arg))
- return space.wrapbytes(arg)
+ return space.newbytes(arg)
finally:
lltype.free(ll_arg, flavor='raw')
diff --git a/pypy/module/imp/interp_imp.py b/pypy/module/imp/interp_imp.py
--- a/pypy/module/imp/interp_imp.py
+++ b/pypy/module/imp/interp_imp.py
@@ -27,7 +27,7 @@
c = x & 0xff
x >>= 8
d = x & 0xff
- return space.wrapbytes(chr(a) + chr(b) + chr(c) + chr(d))
+ return space.newbytes(chr(a) + chr(b) + chr(c) + chr(d))
def get_tag(space):
"""get_tag() -> string
diff --git a/pypy/module/marshal/interp_marshal.py
b/pypy/module/marshal/interp_marshal.py
--- a/pypy/module/marshal/interp_marshal.py
+++ b/pypy/module/marshal/interp_marshal.py
@@ -29,7 +29,7 @@
by dump(data, file)."""
m = StringMarshaller(space, space.int_w(w_version))
m.dump_w_obj(w_data)
- return space.wrapbytes(m.get_value())
+ return space.newbytes(m.get_value())
def load(space, w_f):
"""Read one value from the file 'f' and return it."""
@@ -82,7 +82,7 @@
def write(self, data):
space = self.space
- space.call_function(self.func, space.wrapbytes(data))
+ space.call_function(self.func, space.newbytes(data))
class FileReader(AbstractReaderWriter):
diff --git a/pypy/module/marshal/test/test_marshalimpl.py
b/pypy/module/marshal/test/test_marshalimpl.py
--- a/pypy/module/marshal/test/test_marshalimpl.py
+++ b/pypy/module/marshal/test/test_marshalimpl.py
@@ -78,7 +78,7 @@
interp_marshal.marshal(space, w_obj, m)
assert ''.join(m.seen) == expected
#
- u = interp_marshal.StringUnmarshaller(space, space.wrapbytes(expected))
+ u = interp_marshal.StringUnmarshaller(space, space.newbytes(expected))
w_long = u.load_w_obj()
assert space.eq_w(w_long, w_obj)
diff --git a/pypy/module/mmap/interp_mmap.py b/pypy/module/mmap/interp_mmap.py
--- a/pypy/module/mmap/interp_mmap.py
+++ b/pypy/module/mmap/interp_mmap.py
@@ -39,7 +39,7 @@
def readline(self):
self.check_valid()
- return self.space.wrapbytes(self.mmap.readline())
+ return self.space.newbytes(self.mmap.readline())
@unwrap_spec(w_num=WrappedDefault(None))
def read(self, w_num):
@@ -48,7 +48,7 @@
num = -1
else:
num = self.space.int_w(w_num)
- return self.space.wrapbytes(self.mmap.read(num))
+ return self.space.newbytes(self.mmap.read(num))
def find(self, w_tofind, w_start=None, w_end=None):
self.check_valid()
@@ -185,13 +185,13 @@
return space.wrap(ord(self.mmap.getitem(start)))
elif step == 1:
if stop - start < 0:
- return space.wrapbytes("")
- return space.wrapbytes(self.mmap.getslice(start, length))
+ return space.newbytes("")
+ return space.newbytes(self.mmap.getslice(start, length))
else:
b = StringBuilder(length)
for i in range(start, stop, step):
b.append(self.mmap.getitem(i))
- return space.wrapbytes(b.build())
+ return space.newbytes(b.build())
def descr_setitem(self, w_index, w_value):
space = self.space
diff --git a/pypy/module/pyexpat/interp_pyexpat.py
b/pypy/module/pyexpat/interp_pyexpat.py
--- a/pypy/module/pyexpat/interp_pyexpat.py
+++ b/pypy/module/pyexpat/interp_pyexpat.py
@@ -589,7 +589,7 @@
# Yes, supports only 8bit encodings
translationmap = space.unicode_w(
space.call_method(
- space.wrapbytes(self.all_chars), "decode",
+ space.newbytes(self.all_chars), "decode",
space.wrap(name), space.wrap("replace")))
if len(translationmap) != 256:
diff --git a/pypy/module/struct/formatiterator.py
b/pypy/module/struct/formatiterator.py
--- a/pypy/module/struct/formatiterator.py
+++ b/pypy/module/struct/formatiterator.py
@@ -140,7 +140,7 @@
@specialize.argtype(1)
def appendobj(self, value):
if isinstance(value, str):
- self.result_w.append(self.space.wrapbytes(value))
+ self.result_w.append(self.space.newbytes(value))
else:
self.result_w.append(self.space.wrap(value))
diff --git a/pypy/module/struct/interp_struct.py
b/pypy/module/struct/interp_struct.py
--- a/pypy/module/struct/interp_struct.py
+++ b/pypy/module/struct/interp_struct.py
@@ -55,7 +55,7 @@
@unwrap_spec(format=str)
def pack(space, format, args_w):
- return space.wrapbytes(_pack(space, format, args_w))
+ return space.newbytes(_pack(space, format, args_w))
# XXX inefficient
diff --git a/pypy/module/termios/interp_termios.py
b/pypy/module/termios/interp_termios.py
--- a/pypy/module/termios/interp_termios.py
+++ b/pypy/module/termios/interp_termios.py
@@ -46,7 +46,7 @@
iflag, oflag, cflag, lflag, ispeed, ospeed, cc = tup
l_w = [space.wrap(i) for i in [iflag, oflag, cflag, lflag, ispeed, ospeed]]
# last one need to be chosen carefully
- cc_w = [space.wrapbytes(i) for i in cc]
+ cc_w = [space.newbytes(i) for i in cc]
if lflag & rtermios.ICANON:
cc_w[rtermios.VMIN] = space.wrap(ord(cc[rtermios.VMIN][0]))
cc_w[rtermios.VTIME] = space.wrap(ord(cc[rtermios.VTIME][0]))
diff --git a/pypy/module/zipimport/interp_zipimport.py
b/pypy/module/zipimport/interp_zipimport.py
--- a/pypy/module/zipimport/interp_zipimport.py
+++ b/pypy/module/zipimport/interp_zipimport.py
@@ -287,7 +287,7 @@
filename = self._find_relative_path(filename)
try:
data = self.zip_file.read(filename)
- return space.wrapbytes(data)
+ return space.newbytes(data)
except (KeyError, OSError, BadZipfile):
raise oefmt(space.w_IOError, "Error reading file")
except RZlibError as e:
diff --git a/pypy/module/zlib/interp_zlib.py b/pypy/module/zlib/interp_zlib.py
--- a/pypy/module/zlib/interp_zlib.py
+++ b/pypy/module/zlib/interp_zlib.py
@@ -62,7 +62,7 @@
rzlib.deflateEnd(stream)
except rzlib.RZlibError as e:
raise zlib_error(space, e.msg)
- return space.wrapbytes(result)
+ return space.newbytes(result)
@unwrap_spec(string='bufferstr', wbits="c_int", bufsize=int)
@@ -84,7 +84,7 @@
rzlib.inflateEnd(stream)
except rzlib.RZlibError as e:
raise zlib_error(space, e.msg)
- return space.wrapbytes(result)
+ return space.newbytes(result)
class ZLibObject(W_Root):
@@ -158,7 +158,7 @@
self.unlock()
except rzlib.RZlibError as e:
raise zlib_error(space, e.msg)
- return space.wrapbytes(result)
+ return space.newbytes(result)
@unwrap_spec(mode="c_int")
def flush(self, space, mode=rzlib.Z_FINISH):
@@ -187,7 +187,7 @@
self.unlock()
except rzlib.RZlibError as e:
raise zlib_error(space, e.msg)
- return space.wrapbytes(result)
+ return space.newbytes(result)
@unwrap_spec(level=int, method=int, wbits=int, memLevel=int, strategy=int)
@@ -294,7 +294,7 @@
string, finished, unused_len = result
self.eof = finished
self._save_unconsumed_input(data, finished, unused_len)
- return space.wrapbytes(string)
+ return space.newbytes(string)
def flush(self, space, w_length=None):
"""
@@ -320,7 +320,7 @@
else:
string, finished, unused_len = result
self._save_unconsumed_input(data, finished, unused_len)
- return space.wrapbytes(string)
+ return space.newbytes(string)
@unwrap_spec(wbits=int)
diff --git a/pypy/module/zlib/test/test_zlib.py
b/pypy/module/zlib/test/test_zlib.py
--- a/pypy/module/zlib/test/test_zlib.py
+++ b/pypy/module/zlib/test/test_zlib.py
@@ -23,9 +23,9 @@
"""
cls.w_zlib = cls.space.getbuiltinmodule('zlib')
expanded = b'some bytes which will be compressed'
- cls.w_expanded = cls.space.wrapbytes(expanded)
- cls.w_compressed = cls.space.wrapbytes(zlib.compress(expanded))
- cls.w_LICENSE = cls.space.wrapbytes(
+ cls.w_expanded = cls.space.newbytes(expanded)
+ cls.w_compressed = cls.space.newbytes(zlib.compress(expanded))
+ cls.w_LICENSE = cls.space.newbytes(
py.path.local(pypy.__file__).dirpath().dirpath()
.join('LICENSE').read())
diff --git a/pypy/objspace/fake/objspace.py b/pypy/objspace/fake/objspace.py
--- a/pypy/objspace/fake/objspace.py
+++ b/pypy/objspace/fake/objspace.py
@@ -202,7 +202,7 @@
"NOT_RPYTHON"
raise NotImplementedError
- def wrapbytes(self, x):
+ def newbytes(self, x):
return w_some_obj()
def wrap(self, x):
@@ -224,9 +224,6 @@
"NOT_RPYTHON"
raise NotImplementedError
- def wrapbytes(self, x):
- return w_some_obj()
-
def _see_interp2app(self, interp2app):
"NOT_RPYTHON"
activation = interp2app._code.activation
diff --git a/pypy/objspace/std/bytesobject.py b/pypy/objspace/std/bytesobject.py
--- a/pypy/objspace/std/bytesobject.py
+++ b/pypy/objspace/std/bytesobject.py
@@ -626,8 +626,8 @@
l = space.listview_bytes(w_list)
if l is not None:
if len(l) == 1:
- return space.wrapbytes(l[0])
- return space.wrapbytes(self._val(space).join(l))
+ 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):
diff --git a/pypy/objspace/std/dictmultiobject.py
b/pypy/objspace/std/dictmultiobject.py
--- a/pypy/objspace/std/dictmultiobject.py
+++ b/pypy/objspace/std/dictmultiobject.py
@@ -1016,7 +1016,7 @@
unerase = staticmethod(unerase)
def wrap(self, unwrapped):
- return self.space.wrapbytes(unwrapped)
+ return self.space.newbytes(unwrapped)
def unwrap(self, wrapped):
return self.space.bytes_w(wrapped)
@@ -1056,7 +1056,7 @@
return self.space.newlist_bytes(self.listview_bytes(w_dict))
def wrapkey(space, key):
- return space.wrapbytes(key)
+ return space.newbytes(key)
##@jit.look_inside_iff(lambda self, w_dict:
## w_dict_unrolling_heuristic(w_dict))
diff --git a/pypy/objspace/std/formatting.py b/pypy/objspace/std/formatting.py
--- a/pypy/objspace/std/formatting.py
+++ b/pypy/objspace/std/formatting.py
@@ -324,7 +324,7 @@
def unknown_fmtchar(self):
space = self.space
c = self.fmt[self.fmtpos - 1]
- w_s = space.wrap(c) if do_unicode else space.wrapbytes(c)
+ w_s = space.newunicode(c) if do_unicode else space.newbytes(c)
raise oefmt(space.w_ValueError,
"unsupported format character %R (%s) at index %d",
w_s, hex(ord(c)), self.fmtpos - 1)
diff --git a/pypy/objspace/std/intobject.py b/pypy/objspace/std/intobject.py
--- a/pypy/objspace/std/intobject.py
+++ b/pypy/objspace/std/intobject.py
@@ -133,7 +133,7 @@
"can't convert negative int to unsigned")
except OverflowError:
raise oefmt(space.w_OverflowError, "int too big to convert")
- return space.wrapbytes(byte_string)
+ return space.newbytes(byte_string)
def descr_round(self, space, w_ndigits=None):
"""Rounding an Integral returns itself.
diff --git a/pypy/objspace/std/listobject.py b/pypy/objspace/std/listobject.py
--- a/pypy/objspace/std/listobject.py
+++ b/pypy/objspace/std/listobject.py
@@ -1948,7 +1948,7 @@
_none_value = None
def wrap(self, stringval):
- return self.space.wrapbytes(stringval)
+ return self.space.newbytes(stringval)
def unwrap(self, w_string):
return self.space.bytes_w(w_string)
diff --git a/pypy/objspace/std/marshal_impl.py
b/pypy/objspace/std/marshal_impl.py
--- a/pypy/objspace/std/marshal_impl.py
+++ b/pypy/objspace/std/marshal_impl.py
@@ -250,7 +250,7 @@
@unmarshaller(TYPE_STRING)
def unmarshal_bytes(space, u, tc):
- return space.wrapbytes(u.get_str())
+ return space.newbytes(u.get_str())
@unmarshaller(TYPE_STRINGREF)
def unmarshal_stringref(space, u, tc):
diff --git a/pypy/objspace/std/memoryobject.py
b/pypy/objspace/std/memoryobject.py
--- a/pypy/objspace/std/memoryobject.py
+++ b/pypy/objspace/std/memoryobject.py
@@ -70,7 +70,7 @@
def descr_tobytes(self, space):
self._check_released(space)
- return space.wrapbytes(self.as_str())
+ return space.newbytes(self.as_str())
def descr_tolist(self, space):
self._check_released(space)
diff --git a/pypy/objspace/std/objspace.py b/pypy/objspace/std/objspace.py
--- a/pypy/objspace/std/objspace.py
+++ b/pypy/objspace/std/objspace.py
@@ -340,7 +340,6 @@
def newbytes(self, s):
return W_BytesObject(s)
- wrapbytes = newbytes
def newunicode(self, uni):
return W_UnicodeObject(uni)
diff --git a/pypy/objspace/std/setobject.py b/pypy/objspace/std/setobject.py
--- a/pypy/objspace/std/setobject.py
+++ b/pypy/objspace/std/setobject.py
@@ -581,7 +581,7 @@
return space.wrap(uid)
def _newobj(self, space, w_iterable):
- """Make a new frozenset by taking ownership of 'w_iterable'."""
+ """Make a new frozenset by taking ownership of 'w_iterable'."""
return W_FrozensetObject(space, w_iterable)
@staticmethod
@@ -1232,7 +1232,7 @@
return self.space.bytes_w(w_item)
def wrap(self, item):
- return self.space.wrapbytes(item)
+ return self.space.newbytes(item)
def iter(self, w_set):
return BytesIteratorImplementation(self.space, self, w_set)
@@ -1462,7 +1462,7 @@
def next_entry(self):
for key in self.iterator:
- return self.space.wrapbytes(key)
+ return self.space.newbytes(key)
else:
return None
diff --git a/pypy/objspace/std/test/test_bytesobject.py
b/pypy/objspace/std/test/test_bytesobject.py
--- a/pypy/objspace/std/test/test_bytesobject.py
+++ b/pypy/objspace/std/test/test_bytesobject.py
@@ -4,30 +4,30 @@
pass
def test_bytes_w(self):
- assert self.space.bytes_w(self.space.wrapbytes("foo")) == "foo"
+ assert self.space.bytes_w(self.space.newbytes("foo")) == "foo"
def test_equality(self):
- w = self.space.wrapbytes
+ w = self.space.newbytes
assert self.space.eq_w(w('abc'), w('abc'))
assert not self.space.eq_w(w('abc'), w('def'))
def test_order_cmp(self):
space = self.space
- w = space.wrapbytes
+ w = space.newbytes
assert self.space.is_true(space.lt(w('a'), w('b')))
assert self.space.is_true(space.lt(w('a'), w('ab')))
assert self.space.is_true(space.le(w('a'), w('a')))
assert self.space.is_true(space.gt(w('a'), w('')))
def test_truth(self):
- w = self.space.wrapbytes
+ w = self.space.newbytes
assert self.space.is_true(w('non-empty'))
assert not self.space.is_true(w(''))
def test_getitem(self):
space = self.space
w = space.wrap
- w_str = space.wrapbytes('abc')
+ w_str = space.newbytes('abc')
assert space.eq_w(space.getitem(w_str, w(0)), w(ord('a')))
assert space.eq_w(space.getitem(w_str, w(-1)), w(ord('c')))
self.space.raises_w(space.w_IndexError,
@@ -38,7 +38,7 @@
def test_slice(self):
space = self.space
w = space.wrap
- wb = space.wrapbytes
+ wb = space.newbytes
w_str = wb('abc')
w_slice = space.newslice(w(0), w(0), space.w_None)
@@ -67,7 +67,7 @@
return
w_None = space.w_None
w = space.wrap
- wb = space.wrapbytes
+ wb = space.newbytes
w_str = wb('hello')
w_slice = space.newslice(w_None, w_None, w(1))
@@ -83,7 +83,7 @@
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
