Author: Carl Friedrich Bolz <cfb...@gmx.de>
Branch: space-newtext
Changeset: r88259:613414c4df6c
Date: 2016-11-08 12:52 +0100
http://bitbucket.org/pypy/pypy/changeset/613414c4df6c/
Log: micronumpy
diff --git a/pypy/module/micronumpy/arrayops.py
b/pypy/module/micronumpy/arrayops.py
--- a/pypy/module/micronumpy/arrayops.py
+++ b/pypy/module/micronumpy/arrayops.py
@@ -105,13 +105,13 @@
raise oefmt(space.w_ValueError, "need at least one array to
concatenate")
args_w = [convert_to_array(space, w_arg) for w_arg in args_w]
if w_axis is None:
- w_axis = space.wrap(0)
+ w_axis = space.newint(0)
if space.is_none(w_axis):
args_w = [w_arg.reshape(space,
space.newlist([w_arg.descr_get_size(space)]),
w_arg.get_order())
for w_arg in args_w]
- w_axis = space.wrap(0)
+ w_axis = space.newint(0)
dtype = args_w[0].get_dtype()
shape = args_w[0].get_shape()[:]
ndim = len(shape)
@@ -184,7 +184,7 @@
def count_nonzero(space, w_obj):
- return space.wrap(loop.count_all_true(convert_to_array(space, w_obj)))
+ return space.newint(loop.count_all_true(convert_to_array(space, w_obj)))
def choose(space, w_arr, w_choices, w_out, w_mode):
diff --git a/pypy/module/micronumpy/base.py b/pypy/module/micronumpy/base.py
--- a/pypy/module/micronumpy/base.py
+++ b/pypy/module/micronumpy/base.py
@@ -136,7 +136,7 @@
if w_val is not None:
w_val = dtype.coerce(space, w_val)
else:
- w_val = dtype.coerce(space, space.wrap(0))
+ w_val = dtype.coerce(space, space.newint(0))
return convert_to_array(space, w_val)
@staticmethod
diff --git a/pypy/module/micronumpy/boxes.py b/pypy/module/micronumpy/boxes.py
--- a/pypy/module/micronumpy/boxes.py
+++ b/pypy/module/micronumpy/boxes.py
@@ -196,11 +196,11 @@
def descr_str(self, space):
tp = self.get_dtype(space).itemtype
- return space.wrap(tp.str_format(self, add_quotes=False))
+ return space.newtext(tp.str_format(self, add_quotes=False))
def descr_repr(self, space):
tp = self.get_dtype(space).itemtype
- return space.wrap(tp.str_format(self, add_quotes=True))
+ return space.newtext(tp.str_format(self, add_quotes=True))
def descr_format(self, space, w_spec):
return space.format(self.item(space), w_spec)
@@ -209,7 +209,7 @@
return space.hash(self.item(space))
def descr___array_priority__(self, space):
- return space.wrap(0.0)
+ return space.newfloat(0.0)
def descr_index(self, space):
return space.index(self.item(space))
@@ -242,7 +242,7 @@
return space.hex(self.descr_int(space))
def descr_nonzero(self, space):
- return space.wrap(self.get_dtype(space).itemtype.bool(self))
+ return space.newbool(self.get_dtype(space).itemtype.bool(self))
# TODO: support all kwargs in ufuncs like numpy ufunc_object.c
sig = None
@@ -385,16 +385,16 @@
return self.get_dtype(space)
def descr_get_size(self, space):
- return space.wrap(1)
+ return space.newint(1)
def descr_get_itemsize(self, space):
- return space.wrap(self.get_dtype(space).elsize)
+ return space.newint(self.get_dtype(space).elsize)
def descr_get_shape(self, space):
return space.newtuple([])
def descr_get_ndim(self, space):
- return space.wrap(0)
+ return space.newint(0)
def descr_copy(self, space):
return self.convert_to(space, self.get_dtype(space))
@@ -412,18 +412,18 @@
return self.get_dtype(space).itemtype.byteswap(self)
def descr_tostring(self, space, __args__):
- w_meth = space.getattr(self.descr_ravel(space), space.wrap('tostring'))
+ w_meth = space.getattr(self.descr_ravel(space),
space.newtext('tostring'))
return space.call_args(w_meth, __args__)
def descr_reshape(self, space, __args__):
- w_meth = space.getattr(self.descr_ravel(space), space.wrap('reshape'))
+ w_meth = space.getattr(self.descr_ravel(space),
space.newtext('reshape'))
w_res = space.call_args(w_meth, __args__)
if isinstance(w_res, W_NDimArray) and len(w_res.get_shape()) == 0:
return w_res.get_scalar_value()
return w_res
def descr_nd_nonzero(self, space, __args__):
- w_meth = space.getattr(self.descr_ravel(space), space.wrap('nonzero'))
+ w_meth = space.getattr(self.descr_ravel(space),
space.newtext('nonzero'))
return space.call_args(w_meth, __args__)
def descr_get_real(self, space):
@@ -579,7 +579,7 @@
read_val = dtype.read(self.arr, self.ofs, ofs)
if isinstance (read_val, W_StringBox):
# StringType returns a str
- return space.wrap(dtype.itemtype.to_str(read_val))
+ return space.newbytes(dtype.itemtype.to_str(read_val))
return read_val
def descr_iter(self, space):
@@ -635,7 +635,7 @@
if dtype.is_unicode():
return self
elif dtype.is_object():
- return W_ObjectBox(space.wrap(self._value))
+ return W_ObjectBox(space.newunicode(self._value))
else:
raise oefmt(space.w_NotImplementedError,
"Conversion from unicode not implemented yet")
diff --git a/pypy/module/micronumpy/broadcast.py
b/pypy/module/micronumpy/broadcast.py
--- a/pypy/module/micronumpy/broadcast.py
+++ b/pypy/module/micronumpy/broadcast.py
@@ -67,19 +67,19 @@
self.op_flags[i], self)
def descr_iter(self, space):
- return space.wrap(self)
+ return self
def descr_get_shape(self, space):
- return space.newtuple([space.wrap(i) for i in self.shape])
+ return space.newtuple([space.newint(i) for i in self.shape])
def descr_get_size(self, space):
- return space.wrap(self.size)
+ return space.newint(self.size)
def descr_get_index(self, space):
- return space.wrap(self.index)
+ return space.newint(self.index)
def descr_get_numiter(self, space):
- return space.wrap(len(self.iters))
+ return space.newint(len(self.iters))
@jit.unroll_safe
def descr_next(self, space):
diff --git a/pypy/module/micronumpy/casting.py
b/pypy/module/micronumpy/casting.py
--- a/pypy/module/micronumpy/casting.py
+++ b/pypy/module/micronumpy/casting.py
@@ -127,18 +127,18 @@
raise oefmt(space.w_TypeError,
"did not understand one of the types; 'None' not accepted")
if isinstance(w_from, W_NDimArray):
- return space.wrap(can_cast_array(space, w_from, target, casting))
+ return space.newbool(can_cast_array(space, w_from, target, casting))
elif is_scalar_w(space, w_from):
w_scalar = as_scalar(space, w_from)
w_arr = W_NDimArray.from_scalar(space, w_scalar)
- return space.wrap(can_cast_array(space, w_arr, target, casting))
+ return space.newbool(can_cast_array(space, w_arr, target, casting))
try:
origin = as_dtype(space, w_from, allow_None=False)
except TypeError:
raise oefmt(space.w_TypeError,
"did not understand one of the types; 'None' not accepted")
- return space.wrap(can_cast_type(space, origin, target, casting))
+ return space.newbool(can_cast_type(space, origin, target, casting))
kind_ordering = {
Bool.kind: 0, ULong.kind: 1, Long.kind: 2,
@@ -328,7 +328,7 @@
space.int_w(w_obj)
except OperationError as e:
if e.match(space, space.w_OverflowError):
- if space.is_true(space.le(w_obj, space.wrap(0))):
+ if space.is_true(space.le(w_obj, space.newint(0))):
return int64_dtype
return uint64_dtype
raise
diff --git a/pypy/module/micronumpy/compile.py
b/pypy/module/micronumpy/compile.py
--- a/pypy/module/micronumpy/compile.py
+++ b/pypy/module/micronumpy/compile.py
@@ -190,6 +190,10 @@
return StringObject(obj)
raise NotImplementedError
+ def newtext(self, obj):
+ return StringObject(obj)
+ newbytes = newtext
+
def newlist(self, items):
return ListObject(items)
@@ -197,7 +201,7 @@
return ComplexObject(r, i)
def newfloat(self, f):
- return self.float(f)
+ return FloatObject(f)
def newslice(self, start, stop, step):
return SliceObject(self.int_w(start), self.int_w(stop),
@@ -293,6 +297,7 @@
if isinstance(w_obj, StringObject):
return w_obj.v
raise NotImplementedError
+ text_w = str_w
def unicode_w(self, w_obj):
# XXX
diff --git a/pypy/module/micronumpy/concrete.py
b/pypy/module/micronumpy/concrete.py
--- a/pypy/module/micronumpy/concrete.py
+++ b/pypy/module/micronumpy/concrete.py
@@ -233,7 +233,7 @@
elif shape_len > 1:
raise IndexError
idx = support.index_w(space, w_idx)
- return self._lookup_by_index(space, [space.wrap(idx)])
+ return self._lookup_by_index(space, [space.newint(idx)])
@jit.unroll_safe
def _prepare_slice_args(self, space, w_idx):
@@ -366,7 +366,7 @@
w_res = W_NDimArray.from_shape(space, [s, nd], index_type)
loop.nonzero(w_res, self, box)
w_res = w_res.implementation.swapaxes(space, w_res, 0, 1)
- l_w = [w_res.descr_getitem(space, space.wrap(d)) for d in range(nd)]
+ l_w = [w_res.descr_getitem(space, space.newint(d)) for d in range(nd)]
return space.newtuple(l_w)
##def get_storage(self):
diff --git a/pypy/module/micronumpy/ctors.py b/pypy/module/micronumpy/ctors.py
--- a/pypy/module/micronumpy/ctors.py
+++ b/pypy/module/micronumpy/ctors.py
@@ -45,10 +45,10 @@
def try_interface_method(space, w_object, copy):
try:
- w_interface = space.getattr(w_object,
space.wrap("__array_interface__"))
+ w_interface = space.getattr(w_object,
space.newtext("__array_interface__"))
if w_interface is None:
return None, False
- version_w = space.finditem(w_interface, space.wrap("version"))
+ version_w = space.finditem(w_interface, space.newtext("version"))
if version_w is None:
raise oefmt(space.w_ValueError, "__array_interface__ found without"
" 'version' key")
@@ -60,11 +60,11 @@
raise oefmt(space.w_ValueError,
"__array_interface__ version %d not supported", version)
# make a view into the data
- w_shape = space.finditem(w_interface, space.wrap('shape'))
- w_dtype = space.finditem(w_interface, space.wrap('typestr'))
- w_descr = space.finditem(w_interface, space.wrap('descr'))
- w_data = space.finditem(w_interface, space.wrap('data'))
- w_strides = space.finditem(w_interface, space.wrap('strides'))
+ w_shape = space.finditem(w_interface, space.newtext('shape'))
+ w_dtype = space.finditem(w_interface, space.newtext('typestr'))
+ w_descr = space.finditem(w_interface, space.newtext('descr'))
+ w_data = space.finditem(w_interface, space.newtext('data'))
+ w_strides = space.finditem(w_interface, space.newtext('strides'))
if w_shape is None or w_dtype is None:
raise oefmt(space.w_ValueError,
"__array_interface__ missing one or more required keys:
shape, typestr"
@@ -96,7 +96,7 @@
start=offset), read_only
if w_data is None:
w_data = w_object
- w_offset = space.finditem(w_interface, space.wrap('offset'))
+ w_offset = space.finditem(w_interface, space.newtext('offset'))
if w_offset is None:
offset = 0
else:
@@ -115,11 +115,11 @@
raise
def _descriptor_from_pep3118_format(space, c_format):
- descr = descriptor.decode_w_dtype(space, space.wrap(c_format))
+ descr = descriptor.decode_w_dtype(space, space.newtext(c_format))
if descr:
return descr
msg = "invalid PEP 3118 format string: '%s'" % c_format
- space.warn(space.wrap(msg), space.w_RuntimeWarning)
+ space.warn(space.newtext(msg), space.w_RuntimeWarning)
return None
def _array_from_buffer_3118(space, w_object, dtype):
@@ -142,7 +142,7 @@
if descr.elsize != space.int_w(space.getattr(w_buf,
space.newbytes('itemsize'))):
msg = ("Item size computed from the PEP 3118 buffer format "
"string does not match the actual item size.")
- space.warn(space.wrap(msg), space.w_RuntimeWarning)
+ space.warn(space.newtext(msg), space.w_RuntimeWarning)
return w_object
dtype = descr
elif not dtype:
@@ -170,7 +170,7 @@
elif nd > 1:
msg = ("ndim computed from the PEP 3118 buffer format "
"is greater than 1, but shape is NULL.")
- space.warn(space.wrap(msg), space.w_RuntimeWarning)
+ space.warn(space.newtext(msg), space.w_RuntimeWarning)
return w_object
try:
w_data = rffi.cast(RAW_STORAGE_PTR,
space.int_w(space.call_method(w_buf, '_pypy_raw_address')))
@@ -238,7 +238,7 @@
must_copy |= (npy_order == NPY.CORDER and not flags &
NPY.ARRAY_C_CONTIGUOUS)
must_copy |= (npy_order == NPY.FORTRANORDER and not flags &
NPY.ARRAY_F_CONTIGUOUS)
if must_copy:
- return w_object.descr_copy(space, space.wrap(npy_order))
+ return w_object.descr_copy(space, space.newint(npy_order))
else:
return w_object
if subok and not type(w_object) is W_NDimArray:
@@ -338,9 +338,9 @@
from pypy.objspace.std.bufferobject import W_Buffer
shape = [space.len_w(w_iterable)]
if space.isinstance_w(w_iterable, space.w_buffer):
- batch = [space.wrap(0)] * shape[0]
+ batch = [space.newint(0)] * shape[0]
for i in range(shape[0]):
- batch[i] = space.ord(space.getitem(w_iterable, space.wrap(i)))
+ batch[i] = space.ord(space.getitem(w_iterable, space.newint(i)))
else:
batch = space.listview(w_iterable)
while True:
@@ -498,7 +498,7 @@
ai.setitem(state, val)
state = ai.next(state)
- return space.wrap(a)
+ return a
def _fromstring_bin(space, s, count, length, dtype):
@@ -516,7 +516,7 @@
a = W_NDimArray.from_shape(space, [count], dtype=dtype)
loop.fromstring_loop(space, a, dtype, itemsize, s)
- return space.wrap(a)
+ return a
@unwrap_spec(s=str, count=int, sep=str, w_dtype=WrappedDefault(None))
diff --git a/pypy/module/micronumpy/descriptor.py
b/pypy/module/micronumpy/descriptor.py
--- a/pypy/module/micronumpy/descriptor.py
+++ b/pypy/module/micronumpy/descriptor.py
@@ -222,8 +222,8 @@
else:
name = self.get_name()
if self.is_flexible() and self.elsize != 0:
- return space.wrap(name + str(self.elsize * 8))
- return space.wrap(name)
+ return space.newtext(name + str(self.elsize * 8))
+ return space.newtext(name)
def descr_get_str(self, space, ignore='|', simple=True):
if not simple and self.fields and len(self.fields) > 0:
@@ -233,10 +233,10 @@
total += s
if not simple and total > 0:
return space.newtuple(
- [space.wrap(self.subdtype.get_str(ignore='')),
- space.newtuple([space.wrap(s) for s in self.shape]),
+ [space.newtext(self.subdtype.get_str(ignore='')),
+ space.newtuple([space.newint(s) for s in self.shape]),
])
- return space.wrap(self.get_str(ignore=ignore))
+ return space.newtext(self.get_str(ignore=ignore))
def get_str(self, ignore='|'):
basic = self.kind
@@ -257,7 +257,7 @@
if style == 'descr':
simple = True
if not self.is_record():
- return space.newlist([space.newtuple([space.wrap(""),
+ return space.newlist([space.newtuple([space.newtext(""),
self.descr_get_str(space,
simple=simple)])])
elif (self.alignment > 1 and not style.startswith('descr')) or
force_dict:
# we need to force a sorting order for the keys,
@@ -324,7 +324,7 @@
s_as_list += titles + [', ']
s_as_list += ["'itemsize':", str(self.elsize), suffix]
- return space.wrap(''.join(s_as_list))
+ return space.newtext(''.join(s_as_list))
else:
descr = []
total = 0
@@ -337,10 +337,10 @@
total += subdtype.elsize
ignore = '|'
if title:
- subdescr = [space.newtuple([space.wrap(title),
space.wrap(name)])]
+ subdescr = [space.newtuple([space.newtext(title),
space.newtext(name)])]
ignore = ''
else:
- subdescr = [space.wrap(name)]
+ subdescr = [space.newtext(name)]
if subdtype.is_record():
subdescr.append(subdtype.descr_get_descr(space, style))
elif subdtype.subdtype is not None:
@@ -351,19 +351,19 @@
subdescr.append(subdtype.descr_get_shape(space))
descr.append(space.newtuple(subdescr[:]))
if self.alignment >= 0 and not style.endswith('subdtype'):
- return
space.wrap(space.str_w(space.repr(space.newlist(descr))) + ', align=True')
+ return
space.newtext(space.str_w(space.repr(space.newlist(descr))) + ', align=True')
return space.newlist(descr)
def descr_get_hasobject(self, space):
- return space.wrap(self.is_object())
+ return space.newbool(self.is_object())
def descr_get_isbuiltin(self, space):
if self.fields is None:
- return space.wrap(1)
- return space.wrap(0)
+ return space.newint(1)
+ return space.newint(0)
def descr_get_isnative(self, space):
- return space.wrap(self.is_native())
+ return space.newbool(self.is_native())
def descr_get_base(self, space):
return space.wrap(self.base)
@@ -375,10 +375,10 @@
self.descr_get_shape(space)])
def descr_get_shape(self, space):
- return space.newtuple([space.wrap(dim) for dim in self.shape])
+ return space.newtuple([space.newint(dim) for dim in self.shape])
def descr_get_flags(self, space):
- return space.wrap(self.flags)
+ return space.newint(self.flags)
def descr_get_fields(self, space):
if not self.fields:
@@ -387,18 +387,18 @@
for name, title in self.names:
offset, subdtype = self.fields[name]
if title is not None:
- w_nt = space.newtuple([space.wrap(name), space.wrap(title)])
+ w_nt = space.newtuple([space.newtext(name),
space.newtext(title)])
space.setitem(w_fields, w_nt,
- space.newtuple([subdtype, space.wrap(offset)]))
+ space.newtuple([subdtype, space.newint(offset)]))
else:
- space.setitem(w_fields, space.wrap(name),
- space.newtuple([subdtype, space.wrap(offset)]))
+ space.setitem(w_fields, space.newtext(name),
+ space.newtuple([subdtype, space.newint(offset)]))
return w_fields
def descr_get_names(self, space):
if not self.fields:
return space.w_None
- return space.newtuple([space.wrap(name[0]) for name in self.names])
+ return space.newtuple([space.newtext(name[0]) for name in self.names])
def descr_set_names(self, space, w_names):
if not self.fields:
@@ -462,30 +462,30 @@
return False
def descr_eq(self, space, w_other):
- return space.wrap(self.eq(space, w_other))
+ return space.newbool(self.eq(space, w_other))
def descr_ne(self, space, w_other):
- return space.wrap(not self.eq(space, w_other))
+ return space.newbool(not self.eq(space, w_other))
def descr_le(self, space, w_other):
from .casting import can_cast_to
w_other = as_dtype(space, w_other)
- return space.wrap(can_cast_to(self, w_other))
+ return space.newbool(can_cast_to(self, w_other))
def descr_ge(self, space, w_other):
from .casting import can_cast_to
w_other = as_dtype(space, w_other)
- return space.wrap(can_cast_to(w_other, self))
+ return space.newbool(can_cast_to(w_other, self))
def descr_lt(self, space, w_other):
from .casting import can_cast_to
w_other = as_dtype(space, w_other)
- return space.wrap(can_cast_to(self, w_other) and not self.eq(space,
w_other))
+ return space.newbool(can_cast_to(self, w_other) and not self.eq(space,
w_other))
def descr_gt(self, space, w_other):
from .casting import can_cast_to
w_other = as_dtype(space, w_other)
- return space.wrap(can_cast_to(w_other, self) and not self.eq(space,
w_other))
+ return space.newbool(can_cast_to(w_other, self) and not self.eq(space,
w_other))
def _compute_hash(self, space, x):
from rpython.rlib.rarithmetic import intmask
@@ -518,7 +518,7 @@
return x
def descr_hash(self, space):
- return space.wrap(self._compute_hash(space, 0x345678))
+ return space.newint(self._compute_hash(space, 0x345678))
def descr_str(self, space):
if self.fields:
@@ -540,12 +540,12 @@
def descr_repr(self, space):
if isinstance(self.itemtype, types.CharType):
- return space.wrap("dtype('S1')")
+ return space.newtext("dtype('S1')")
if self.fields:
r = self.descr_get_descr(space, style='repr')
name = space.str_w(space.str(self.w_box_type))
if name != "<type 'numpy.void'>":
- r = space.newtuple([space.wrap(self.w_box_type), r])
+ r = space.newtuple([self.w_box_type, r])
elif self.subdtype is not None:
r = space.newtuple([self.subdtype.descr_get_str(space),
self.descr_get_shape(space)])
@@ -558,12 +558,12 @@
size = self.elsize
if self.num == NPY.UNICODE:
size >>= 2
- r = space.wrap("'" + byteorder + self.char + str(size) + "'")
+ r = space.newtext("'" + byteorder + self.char + str(size) +
"'")
else:
r = self.descr_get_name(space, quote=True)
if space.isinstance_w(r, space.w_str):
- return space.wrap("dtype(%s)" % space.str_w(r))
- return space.wrap("dtype(%s)" % space.str_w(space.repr(r)))
+ return space.newtext("dtype(%s)" % space.str_w(r))
+ return space.newtext("dtype(%s)" % space.str_w(space.repr(r)))
def descr_getitem(self, space, w_item):
if not self.fields:
@@ -589,8 +589,8 @@
def descr_len(self, space):
if not self.fields:
- return space.wrap(0)
- return space.wrap(len(self.fields))
+ return space.newint(0)
+ return space.newint(len(self.fields))
def runpack_str(self, space, s):
if self.is_str_or_unicode():
@@ -609,10 +609,10 @@
def descr_reduce(self, space):
w_class = space.type(self)
builder_args = space.newtuple([
- space.wrap("%s%d" % (self.kind, self.elsize)),
- space.wrap(0), space.wrap(1)])
+ space.newbytes("%s%d" % (self.kind, self.elsize)),
+ space.newint(0), space.newint(1)])
- version = space.wrap(3)
+ version = space.newint(3)
endian = self.byteorder
if endian == NPY.NATIVE:
endian = NPY.NATBYTE
@@ -620,17 +620,17 @@
names = self.descr_get_names(space)
values = self.descr_get_fields(space)
if self.is_flexible():
- w_size = space.wrap(self.elsize)
+ w_size = space.newint(self.elsize)
if self.alignment > 2:
- w_alignment = space.wrap(self.alignment)
+ w_alignment = space.newint(self.alignment)
else:
- w_alignment = space.wrap(1)
+ w_alignment = space.newint(1)
else:
- w_size = space.wrap(-1)
- w_alignment = space.wrap(-1)
- w_flags = space.wrap(self.flags)
+ w_size = space.newint(-1)
+ w_alignment = space.newint(-1)
+ w_flags = space.newint(self.flags)
- data = space.newtuple([version, space.wrap(endian), subdescr,
+ data = space.newtuple([version, space.newbytes(endian), subdescr,
names, values, w_size, w_alignment, w_flags])
return space.newtuple([w_class, builder_args, data])
@@ -639,24 +639,24 @@
# if builtin dtype (but not w_voiddtype)
return space.w_None
- version = space.int_w(space.getitem(w_data, space.wrap(0)))
+ version = space.int_w(space.getitem(w_data, space.newint(0)))
if version != 3:
raise oefmt(space.w_ValueError,
"can't handle version %d of numpy.dtype pickle",
version)
- endian = byteorder_w(space, space.getitem(w_data, space.wrap(1)))
+ endian = byteorder_w(space, space.getitem(w_data, space.newint(1)))
if endian == NPY.NATBYTE:
endian = NPY.NATIVE
- w_subarray = space.getitem(w_data, space.wrap(2))
- w_names = space.getitem(w_data, space.wrap(3))
- w_fields = space.getitem(w_data, space.wrap(4))
- size = space.int_w(space.getitem(w_data, space.wrap(5)))
- alignment = space.int_w(space.getitem(w_data, space.wrap(6)))
+ w_subarray = space.getitem(w_data, space.newint(2))
+ w_names = space.getitem(w_data, space.newint(3))
+ w_fields = space.getitem(w_data, space.newint(4))
+ size = space.int_w(space.getitem(w_data, space.newint(5)))
+ alignment = space.int_w(space.getitem(w_data, space.newint(6)))
if alignment < 2:
alignment = -1
- flags = space.int_w(space.getitem(w_data, space.wrap(7)))
+ flags = space.int_w(space.getitem(w_data, space.newint(7)))
if (w_names == space.w_None) != (w_fields == space.w_None):
raise oefmt(space.w_ValueError, "inconsistent fields and names in
Numpy dtype unpickling")
@@ -685,11 +685,11 @@
self.fields = {}
for w_name in space.fixedview(w_names):
# XXX what happens if there is a title in the pickled dtype?
- name = space.str_w(w_name)
+ name = space.bytes_w(w_name)
value = space.getitem(w_fields, w_name)
- dtype = space.getitem(value, space.wrap(0))
- offset = space.int_w(space.getitem(value, space.wrap(1)))
+ dtype = space.getitem(value, space.newint(0))
+ offset = space.int_w(space.getitem(value, space.newint(1)))
self.names.append((name, None))
assert isinstance(dtype, W_Dtype)
self.fields[name] = offset, dtype
@@ -829,7 +829,7 @@
return retval
def _get_val_or_none(space, w_dict, key):
- w_key = space.wrap(key)
+ w_key = space.newtext(key)
try:
w_val = space.getitem(w_dict, w_key)
except OperationError as e:
@@ -890,7 +890,7 @@
try:
return get_appbridge_cache(space).call_method(space,
'numpy.core._internal', '_usefields', Arguments(space,
- [w_dict, space.wrap(alignment >= 0)]))
+ [w_dict, space.newbool(alignment >= 0)]))
except OperationError as e:
if e.match(space, space.w_ImportError):
return _usefields(space, w_dict, alignment >= 0)
@@ -950,7 +950,7 @@
"_commastring is not returning a list with len >= 1")
if space.len_w(w_lst) == 1:
return descr__new__(space, space.gettypefor(W_Dtype),
- space.getitem(w_lst, space.wrap(0)),
align=alignment>0)
+ space.getitem(w_lst, space.newint(0)),
align=alignment>0)
else:
try:
return dtype_from_list(space, w_lst, True, alignment)
@@ -1088,15 +1088,15 @@
return _set_metadata_and_copy( space, w_metadata,
dtype_from_list(space, w_dtype, False, alignment),
copy)
elif space.isinstance_w(w_dtype, space.w_tuple):
- w_dtype0 = space.getitem(w_dtype, space.wrap(0))
- w_dtype1 = space.getitem(w_dtype, space.wrap(1))
+ w_dtype0 = space.getitem(w_dtype, space.newint(0))
+ w_dtype1 = space.getitem(w_dtype, space.newint(1))
# create a new dtype object
l_side = make_new_dtype(space, w_subtype, w_dtype0, alignment, copy)
assert isinstance(l_side, W_Dtype)
if l_side.elsize == 0 and space.isinstance_w(w_dtype1, space.w_int):
#(flexible_dtype, itemsize)
name = "%s%d" % (l_side.kind, space.int_w(w_dtype1))
- retval = make_new_dtype(space, w_subtype, space.wrap(name),
alignment, copy)
+ retval = make_new_dtype(space, w_subtype, space.newtext(name),
alignment, copy)
return _set_metadata_and_copy(space, w_metadata, retval, copy)
elif (space.isinstance_w(w_dtype1, space.w_int) or
space.isinstance_w(w_dtype1, space.w_tuple) or
@@ -1467,15 +1467,15 @@
space.wrap(dtype.itemtype.get_element_size())]
if dtype.is_int():
if dtype.is_bool():
- w_maxobj = space.wrap(1)
- w_minobj = space.wrap(0)
+ w_maxobj = space.newint(1)
+ w_minobj = space.newint(0)
elif dtype.is_signed():
- w_maxobj = space.wrap(r_longlong((1 << (itembits - 1))
- - 1))
- w_minobj = space.wrap(r_longlong(-1) << (itembits - 1))
+ w_maxobj = space.newint(r_longlong((1 << (itembits - 1))
+ - 1))
+ w_minobj = space.newint(r_longlong(-1) << (itembits - 1))
else:
- w_maxobj = space.wrap(r_ulonglong(1 << itembits) - 1)
- w_minobj = space.wrap(0)
+ w_maxobj = space.newint(r_ulonglong(1 << itembits) - 1)
+ w_minobj = space.newint(0)
items_w = items_w + [w_maxobj, w_minobj]
items_w = items_w + [dtype.w_box_type]
space.setitem(w_typeinfo, space.wrap(k), space.newtuple(items_w))
diff --git a/pypy/module/micronumpy/flagsobj.py
b/pypy/module/micronumpy/flagsobj.py
--- a/pypy/module/micronumpy/flagsobj.py
+++ b/pypy/module/micronumpy/flagsobj.py
@@ -33,32 +33,32 @@
return self
def descr_c_contiguous(self, space):
- return space.wrap(bool(self.flags & NPY.ARRAY_C_CONTIGUOUS))
+ return space.newbool(bool(self.flags & NPY.ARRAY_C_CONTIGUOUS))
def descr_f_contiguous(self, space):
- return space.wrap(bool(self.flags & NPY.ARRAY_F_CONTIGUOUS))
+ return space.newbool(bool(self.flags & NPY.ARRAY_F_CONTIGUOUS))
def descr_get_writeable(self, space):
- return space.wrap(bool(self.flags & NPY.ARRAY_WRITEABLE))
+ return space.newbool(bool(self.flags & NPY.ARRAY_WRITEABLE))
def descr_get_owndata(self, space):
- return space.wrap(bool(self.flags & NPY.ARRAY_OWNDATA))
+ return space.newbool(bool(self.flags & NPY.ARRAY_OWNDATA))
def descr_get_aligned(self, space):
- return space.wrap(bool(self.flags & NPY.ARRAY_ALIGNED))
+ return space.newbool(bool(self.flags & NPY.ARRAY_ALIGNED))
def descr_get_fnc(self, space):
- return space.wrap(bool(
+ return space.newbool(bool(
self.flags & NPY.ARRAY_F_CONTIGUOUS and not
self.flags & NPY.ARRAY_C_CONTIGUOUS ))
def descr_get_forc(self, space):
- return space.wrap(bool(
+ return space.newbool(bool(
self.flags & NPY.ARRAY_F_CONTIGUOUS or
self.flags & NPY.ARRAY_C_CONTIGUOUS ))
def descr_get_num(self, space):
- return space.wrap(self.flags)
+ return space.newint(self.flags)
def descr_getitem(self, space, w_item):
key = space.str_w(w_item)
@@ -83,10 +83,10 @@
return self.flags == w_other.flags
def descr_eq(self, space, w_other):
- return space.wrap(self.eq(space, w_other))
+ return space.newbool(self.eq(space, w_other))
def descr_ne(self, space, w_other):
- return space.wrap(not self.eq(space, w_other))
+ return space.newbool(not self.eq(space, w_other))
def descr___str__(self, space):
s = StringBuilder()
@@ -102,7 +102,7 @@
s.append(get_tf_str(self.flags, NPY.ARRAY_ALIGNED))
s.append('\n UPDATEIFCOPY : ')
s.append(get_tf_str(self.flags, NPY.ARRAY_UPDATEIFCOPY))
- return space.wrap(s.build())
+ return space.newtext(s.build())
W_FlagsObject.typedef = TypeDef("numpy.flagsobj",
__new__ = interp2app(W_FlagsObject.descr__new__.im_func),
diff --git a/pypy/module/micronumpy/flatiter.py
b/pypy/module/micronumpy/flatiter.py
--- a/pypy/module/micronumpy/flatiter.py
+++ b/pypy/module/micronumpy/flatiter.py
@@ -53,7 +53,7 @@
return self
def descr_len(self, space):
- return space.wrap(self.iter.size)
+ return space.newint(self.iter.size)
def descr_next(self, space):
if self.iter.done(self.state):
diff --git a/pypy/module/micronumpy/iterators.py
b/pypy/module/micronumpy/iterators.py
--- a/pypy/module/micronumpy/iterators.py
+++ b/pypy/module/micronumpy/iterators.py
@@ -71,7 +71,7 @@
@jit.unroll_safe
def get_index(self, space, shapelen):
- return [space.wrap(self.indexes[i]) for i in range(shapelen)]
+ return [space.newint(self.indexes[i]) for i in range(shapelen)]
class IterState(object):
diff --git a/pypy/module/micronumpy/ndarray.py
b/pypy/module/micronumpy/ndarray.py
--- a/pypy/module/micronumpy/ndarray.py
+++ b/pypy/module/micronumpy/ndarray.py
@@ -54,7 +54,7 @@
@jit.unroll_safe
def descr_get_shape(self, space):
shape = self.get_shape()
- return space.newtuple([space.wrap(i) for i in shape])
+ return space.newtuple([space.newint(i) for i in shape])
def descr_set_shape(self, space, w_new_shape):
shape = get_shape_from_iterable(space, self.get_size(), w_new_shape)
@@ -67,7 +67,7 @@
def descr_get_strides(self, space):
strides = self.implementation.get_strides()
- return space.newtuple([space.wrap(i) for i in strides])
+ return space.newtuple([space.newint(i) for i in strides])
def descr_get_dtype(self, space):
return self.implementation.dtype
@@ -85,13 +85,13 @@
raise oefmt(space.w_AttributeError, "Cannot delete array dtype")
def descr_get_ndim(self, space):
- return space.wrap(self.ndims())
+ return space.newint(self.ndims())
def descr_get_itemsize(self, space):
- return space.wrap(self.get_dtype().elsize)
+ return space.newint(self.get_dtype().elsize)
def descr_get_nbytes(self, space):
- return space.wrap(self.get_size() * self.get_dtype().elsize)
+ return space.newint(self.get_size() * self.get_dtype().elsize)
def descr_fill(self, space, w_value):
self.fill(space, self.get_dtype().coerce(space, w_value))
@@ -105,7 +105,7 @@
arr = self
if order != arr.get_order():
arr = W_NDimArray(self.implementation.transpose(self, None))
- return space.wrap(loop.tostring(space, arr))
+ return space.newtext(loop.tostring(space, arr))
def getitem_filter(self, space, arr, axis=0):
shape = self.get_shape()
@@ -122,7 +122,7 @@
" boolean dimension is %d" % (axis, shape[axis],
arr.get_shape()[0]))
#warning =
space.gettypefor(support.W_VisibleDeprecationWarning)
- space.warn(space.wrap(msg), space.w_VisibleDeprecationWarning)
+ space.warn(space.newtext(msg),
space.w_VisibleDeprecationWarning)
res_shape = shape[:axis] + [size] + shape[axis+1:]
else:
res_shape = [size]
@@ -207,7 +207,7 @@
copy = True
w_ret = new_view(space, self, chunks)
if copy:
- w_ret = w_ret.descr_copy(space, space.wrap(w_ret.get_order()))
+ w_ret = w_ret.descr_copy(space,
space.newint(w_ret.get_order()))
return w_ret
shape = res_shape + self.get_shape()[len(indexes):]
w_res = W_NDimArray.from_shape(space, shape, self.get_dtype(),
@@ -231,7 +231,7 @@
dim = i
idx = c.w_idx
chunks.pop(i)
- chunks.insert(0, SliceChunk(space.newslice(space.wrap(0),
+ chunks.insert(0, SliceChunk(space.newslice(space.newint(0),
space.w_None, space.w_None)))
break
if dim > 0:
@@ -268,7 +268,7 @@
if isinstance(w_idx, boxes.W_IntegerBox):
# if w_idx is integer then getitem_array_int must contain a
single value and we must return it.
# Get 0-th element of the w_ret.
- w_ret = w_ret.implementation.descr_getitem(space, self,
space.wrap(0))
+ w_ret = w_ret.implementation.descr_getitem(space, self,
space.newint(0))
else:
try:
w_ret = self.implementation.descr_getitem(space, self, w_idx)
@@ -350,19 +350,19 @@
def descr_len(self, space):
shape = self.get_shape()
if len(shape):
- return space.wrap(shape[0])
+ return space.newint(shape[0])
raise oefmt(space.w_TypeError, "len() of unsized object")
def descr_repr(self, space):
cache = get_appbridge_cache(space)
if cache.w_array_repr is None:
- return space.wrap(self.dump_data())
+ return space.newtext(self.dump_data())
return space.call_function(cache.w_array_repr, self)
def descr_str(self, space):
cache = get_appbridge_cache(space)
if cache.w_array_str is None:
- return space.wrap(self.dump_data(prefix='', separator='',
suffix=''))
+ return space.newtext(self.dump_data(prefix='', separator='',
suffix=''))
return space.call_function(cache.w_array_str, self)
def dump_data(self, prefix='array(', separator=',', suffix=')'):
@@ -404,7 +404,7 @@
self.implementation.fill(space, box)
def descr_get_size(self, space):
- return space.wrap(self.get_size())
+ return space.newint(self.get_size())
def get_size(self):
return self.implementation.get_size()
@@ -449,7 +449,7 @@
if new_impl is not None:
return wrap_impl(space, space.type(self), self, new_impl)
# Create copy with contiguous data
- arr = self.descr_copy(space, space.wrap(order))
+ arr = self.descr_copy(space, space.newint(order))
if arr.get_size() > 0:
new_implementation = arr.implementation.reshape(self, new_shape,
order)
if new_implementation is None:
@@ -562,7 +562,7 @@
return self.get_scalar_value().item(space)
l_w = []
for i in range(self.get_shape()[0]):
- item_w = self.descr_getitem(space, space.wrap(i))
+ item_w = self.descr_getitem(space, space.newint(i))
if (isinstance(item_w, W_NDimArray) or
isinstance(item_w, boxes.W_GenericBox)):
l_w.append(space.call_method(item_w, "tolist"))
@@ -572,7 +572,7 @@
def descr_ravel(self, space, w_order=None):
order = order_converter(space, w_order, self.get_order())
- return self.reshape(space, space.wrap(-1), order)
+ return self.reshape(space, space.newint(-1), order)
@unwrap_spec(w_axis=WrappedDefault(None),
w_out=WrappedDefault(None),
@@ -586,7 +586,7 @@
"axis unsupported for compress")
arr = self
else:
- arr = self.reshape(space, space.wrap(-1), self.get_order())
+ arr = self.reshape(space, space.newint(-1), self.get_order())
index = convert_to_array(space, w_obj)
return arr.getitem_filter(space, index)
@@ -594,7 +594,7 @@
order = order_converter(space, w_order, self.get_order())
if self.is_scalar():
# scalars have no storage
- return self.reshape(space, space.wrap(1), order)
+ return self.reshape(space, space.newint(1), order)
w_res = self.descr_ravel(space, w_order)
if w_res.implementation.storage == self.implementation.storage:
return w_res.descr_copy(space)
@@ -614,7 +614,7 @@
def descr_get_flatiter(self, space):
from .flatiter import W_FlatIterator
- return space.wrap(W_FlatIterator(self))
+ return W_FlatIterator(self)
def descr_item(self, space, args_w):
if len(args_w) == 1 and space.isinstance_w(args_w[0], space.w_tuple):
@@ -674,7 +674,7 @@
# will explode if it can't
w_d = space.newdict()
space.setitem_str(w_d, 'data',
- space.newtuple([space.wrap(addr),
space.w_False]))
+ space.newtuple([space.newint(addr),
space.w_False]))
space.setitem_str(w_d, 'shape', self.descr_get_shape(space))
space.setitem_str(w_d, 'typestr',
self.get_dtype().descr_get_str(space))
if self.implementation.order == NPY.CORDER:
@@ -683,7 +683,7 @@
else:
strides = self.descr_get_strides(space)
space.setitem_str(w_d, 'strides', strides)
- space.setitem_str(w_d, 'version', space.wrap(3))
+ space.setitem_str(w_d, 'version', space.newint(3))
return w_d
w_pypy_data = None
@@ -700,7 +700,7 @@
__array_priority__ = 0.0
def descr___array_priority__(self, space):
- return space.wrap(self.__array_priority__)
+ return space.newfloat(self.__array_priority__)
def descr_argsort(self, space, w_axis=None, w_kind=None, w_order=None):
# happily ignore the kind
@@ -709,7 +709,7 @@
# we would modify the array in-place. Use this to our advantage
# by converting nonnative byte order.
if self.is_scalar():
- return space.wrap(0)
+ return space.newint(0)
dtype = self.get_dtype().descr_newbyteorder(space, NPY.NATIVE)
contig = self.implementation.astype(space, dtype, self.get_order())
return contig.argsort(space, w_axis)
@@ -739,7 +739,7 @@
"according to the rule %s",
space.str_w(self.get_dtype().descr_repr(space)),
space.str_w(new_dtype.descr_repr(space)), casting)
- order = order_converter(space, space.wrap(order), self.get_order())
+ order = order_converter(space, space.newtext(order), self.get_order())
if (not copy and new_dtype == self.get_dtype()
and (order in (NPY.KEEPORDER, NPY.ANYORDER) or order ==
self.get_order())
and (subok or type(self) is W_NDimArray)):
@@ -838,7 +838,7 @@
def descr_trace(self, space, offset=0, axis1=0, axis2=1,
w_dtype=None, w_out=None):
diag = self.descr_diagonal(space, offset, axis1, axis2)
- return diag.descr_sum(space, w_axis=space.wrap(-1), w_dtype=w_dtype,
w_out=w_out)
+ return diag.descr_sum(space, w_axis=space.newint(-1), w_dtype=w_dtype,
w_out=w_out)
def descr_dump(self, space, w_file):
raise oefmt(space.w_NotImplementedError, "dump not implemented yet")
@@ -1071,7 +1071,7 @@
"The truth value of an array with more than one "
"element is ambiguous. Use a.any() or a.all()")
iter, state = self.create_iter()
- return space.wrap(space.is_true(iter.getitem(state)))
+ return space.newbool(space.is_true(iter.getitem(state)))
def _binop_impl(ufunc_name):
def impl(self, space, w_other, w_out=None):
@@ -1174,11 +1174,11 @@
elif self.ndims() < 2 and other.ndims() < 2:
w_res = self.descr_mul(space, other)
assert isinstance(w_res, W_NDimArray)
- return w_res.descr_sum(space, space.wrap(-1), out)
+ return w_res.descr_sum(space, space.newint(-1), out)
dtype = find_result_type(space, [self, other], [])
if self.get_size() < 1 and other.get_size() < 1:
# numpy compatability
- return W_NDimArray.new_scalar(space, dtype, space.wrap(0))
+ return W_NDimArray.new_scalar(space, dtype, space.newint(0))
# Do the dims match?
out_shape, other_critical_dim = _match_dot_shapes(space, self, other)
if out:
@@ -1243,8 +1243,8 @@
def method(self, space, w_axis=None, w_dtype=None, w_out=None):
out = out_converter(space, w_out)
if space.is_none(w_axis):
- w_axis = space.wrap(0)
- arr = self.reshape(space, space.wrap(-1), self.get_order())
+ w_axis = space.newint(0)
+ arr = self.reshape(space, space.newint(-1), self.get_order())
else:
arr = self
ufunc = getattr(ufuncs.get(space), ufunc_name)
@@ -1359,7 +1359,7 @@
assert isinstance(multiarray, MixedModule)
reconstruct = multiarray.get("_reconstruct")
parameters = space.newtuple([self.getclass(space), space.newtuple(
- [space.wrap(0)]), space.wrap("b")])
+ [space.newint(0)]), space.wrap("b")])
builder = StringBuilder()
if self.get_dtype().is_object():
@@ -1377,11 +1377,11 @@
self.implementation.get_storage_size())
state = space.newtuple([
- space.wrap(1), # version
+ space.newint(1), # version
self.descr_get_shape(space),
self.get_dtype(),
- space.wrap(False), # is_fortran
- space.wrap(builder.build()),
+ space.newbool(False), # is_fortran
+ space.newbytes(builder.build()),
])
return space.newtuple([reconstruct, parameters, state])
@@ -1397,17 +1397,17 @@
raise oefmt(space.w_ValueError,
"__setstate__ called with len(args[1])==%d, not 5 or
4",
lens)
- shape = space.getitem(w_state, space.wrap(base_index))
- dtype = space.getitem(w_state, space.wrap(base_index+1))
- #isfortran = space.getitem(w_state, space.wrap(base_index+2))
- storage = space.getitem(w_state, space.wrap(base_index+3))
+ shape = space.getitem(w_state, space.newint(base_index))
+ dtype = space.getitem(w_state, space.newint(base_index+1))
+ #isfortran = space.getitem(w_state, space.newint(base_index+2))
+ storage = space.getitem(w_state, space.newint(base_index+3))
if not isinstance(dtype, descriptor.W_Dtype):
raise oefmt(space.w_ValueError,
"__setstate__(self, (shape, dtype, .. called with "
"improper dtype '%R'", dtype)
self.implementation = W_NDimArray.from_shape_and_storage(
space, [space.int_w(i) for i in space.listview(shape)],
- rffi.str2charp(space.str_w(storage), track_allocation=False),
+ rffi.str2charp(space.bytes_w(storage), track_allocation=False),
dtype, storage_bytes=space.len_w(storage),
owning=True).implementation
def descr___array_finalize__(self, space, w_obj):
@@ -1470,7 +1470,7 @@
w_ret = space.allocate_instance(W_NDimArray, w_subtype)
W_NDimArray.__init__(w_ret, impl)
space.call_function(space.getattr(w_ret,
- space.wrap('__array_finalize__')), w_subtype)
+ space.newtext('__array_finalize__')), w_subtype)
return w_ret
diff --git a/pypy/module/micronumpy/nditer.py b/pypy/module/micronumpy/nditer.py
--- a/pypy/module/micronumpy/nditer.py
+++ b/pypy/module/micronumpy/nditer.py
@@ -17,7 +17,7 @@
def parse_op_arg(space, name, w_op_flags, n, parse_one_arg):
if space.is_w(w_op_flags, space.w_None):
- w_op_flags = space.newtuple([space.wrap('readonly')])
+ w_op_flags = space.newtuple([space.newtext('readonly')])
if not space.isinstance_w(w_op_flags, space.w_tuple) and not \
space.isinstance_w(w_op_flags, space.w_list):
raise oefmt(space.w_ValueError,
@@ -510,7 +510,7 @@
for i in range(len(self.seq)):
if i not in outargs:
self.seq[i] = self.seq[i].descr_copy(space,
- w_order=space.wrap(self.order))
+ w_order=space.newint(self.order))
self.dtypes = [s.get_dtype() for s in self.seq]
else:
#copy them from seq
@@ -592,7 +592,7 @@
return oa_ndim
def descr_iter(self, space):
- return space.wrap(self)
+ return self
def getitem(self, it, st):
w_res = W_NDimArray(it.getoperand(st))
@@ -611,7 +611,7 @@
raise oefmt(space.w_NotImplementedError, "not implemented yet")
def descr_len(self, space):
- space.wrap(len(self.iters))
+ space.newint(len(self.iters))
@jit.unroll_safe
def descr_next(self, space):
@@ -648,7 +648,7 @@
return self.done
def descr_iternext(self, space):
- return space.wrap(self.iternext())
+ return space.newbool(self.iternext())
def descr_copy(self, space):
raise oefmt(space.w_NotImplementedError, "not implemented yet")
@@ -682,30 +682,30 @@
return space.newtuple(res)
def descr_get_finished(self, space):
- return space.wrap(self.done)
+ return space.newbool(self.done)
def descr_get_has_delayed_bufalloc(self, space):
raise oefmt(space.w_NotImplementedError, "not implemented yet")
def descr_get_has_index(self, space):
- return space.wrap(self.tracked_index in ["C", "F"])
+ return space.newbool(self.tracked_index in ["C", "F"])
def descr_get_index(self, space):
if not self.tracked_index in ["C", "F"]:
raise oefmt(space.w_ValueError, "Iterator does not have an index")
if self.done:
raise oefmt(space.w_ValueError, "Iterator is past the end")
- return space.wrap(self.index_iter.getvalue())
+ return space.newint(self.index_iter.getvalue())
def descr_get_has_multi_index(self, space):
- return space.wrap(self.tracked_index == "multi")
+ return space.newbool(self.tracked_index == "multi")
def descr_get_multi_index(self, space):
if not self.tracked_index == "multi":
raise oefmt(space.w_ValueError, "Iterator is not tracking a
multi-index")
if self.done:
raise oefmt(space.w_ValueError, "Iterator is past the end")
- return space.newtuple([space.wrap(x) for x in self.index_iter.index])
+ return space.newtuple([space.newint(x) for x in self.index_iter.index])
def descr_get_iterationneedsapi(self, space):
raise oefmt(space.w_NotImplementedError, "not implemented yet")
@@ -714,13 +714,13 @@
raise oefmt(space.w_NotImplementedError, "not implemented yet")
def descr_get_itersize(self, space):
- return space.wrap(support.product(self.shape))
+ return space.newint(support.product(self.shape))
def descr_get_itviews(self, space):
raise oefmt(space.w_NotImplementedError, "not implemented yet")
def descr_get_ndim(self, space):
- return space.wrap(self.ndim)
+ return space.newint(self.ndim)
def descr_get_nop(self, space):
raise oefmt(space.w_NotImplementedError, "not implemented yet")
diff --git a/pypy/module/micronumpy/strides.py
b/pypy/module/micronumpy/strides.py
--- a/pypy/module/micronumpy/strides.py
+++ b/pypy/module/micronumpy/strides.py
@@ -98,11 +98,11 @@
if dim >= 0:
# filter by axis dim
filtr = chunks[dim]
- assert isinstance(filtr, BooleanChunk)
+ assert isinstance(filtr, BooleanChunk)
# XXX this creates a new array, and fails in setitem
w_arr = w_arr.getitem_filter(space, filtr.w_idx, axis=dim)
arr = w_arr.implementation
- chunks[dim] = SliceChunk(space.newslice(space.wrap(0),
+ chunks[dim] = SliceChunk(space.newslice(space.newint(0),
space.w_None, space.w_None))
r = calculate_slice_strides(space, arr.shape, arr.start,
arr.get_strides(), arr.get_backstrides(), chunks)
diff --git a/pypy/module/micronumpy/support.py
b/pypy/module/micronumpy/support.py
--- a/pypy/module/micronumpy/support.py
+++ b/pypy/module/micronumpy/support.py
@@ -181,9 +181,9 @@
return rffi.cast(lltype.Signed, storage) + start
def is_rhs_priority_higher(space, w_lhs, w_rhs):
- w_zero = space.wrap(0.0)
- w_priority_l = space.findattr(w_lhs, space.wrap('__array_priority__')) or
w_zero
- w_priority_r = space.findattr(w_rhs, space.wrap('__array_priority__')) or
w_zero
+ w_zero = space.newfloat(0.0)
+ w_priority_l = space.findattr(w_lhs, space.newtext('__array_priority__'))
or w_zero
+ w_priority_r = space.findattr(w_rhs, space.newtext('__array_priority__'))
or w_zero
# XXX what is better, unwrapping values or space.gt?
return space.is_true(space.gt(w_priority_r, w_priority_l))
diff --git a/pypy/module/micronumpy/types.py b/pypy/module/micronumpy/types.py
--- a/pypy/module/micronumpy/types.py
+++ b/pypy/module/micronumpy/types.py
@@ -196,7 +196,7 @@
return w_obj
def to_builtin_type(self, space, box):
- return space.wrap(self.for_computation(self.unbox(box)))
+ raise NotImplementedError("has to be provided by subclass")
def _coerce(self, space, w_item):
raise NotImplementedError
@@ -398,7 +398,7 @@
return self.box(space.is_true(w_item))
def to_builtin_type(self, space, w_item):
- return space.wrap(self.unbox(w_item))
+ return space.newbool(self.unbox(w_item))
def str_format(self, box, add_quotes=True):
return "True" if self.unbox(box) else "False"
@@ -461,6 +461,9 @@
_mixin_ = True
signed = True
+ def to_builtin_type(self, space, box):
+ return space.newint(self.for_computation(self.unbox(box)))
+
def _base_coerce(self, space, w_item):
if w_item is None:
return self.box(0)
@@ -736,6 +739,9 @@
_mixin_ = True
strlen = 32
+ def to_builtin_type(self, space, box):
+ return space.wrap(self.for_computation(self.unbox(box)))
+
def _coerce(self, space, w_item):
if w_item is None:
return self.box(0.0)
@@ -2015,17 +2021,17 @@
@simple_binary_op
def pow(self, v1, v2):
- return self.space.pow(v1, v2, self.space.wrap(1))
+ return self.space.pow(v1, v2, self.space.newint(1))
@simple_unary_op
def reciprocal(self, v1):
- return self.space.div(self.space.wrap(1.0), v1)
+ return self.space.div(self.space.newfloat(1.0), v1)
@simple_unary_op
def sign(self, v):
- zero = self.space.wrap(0)
- one = self.space.wrap(1)
- m_one = self.space.wrap(-1)
+ zero = self.space.newint(0)
+ one = self.space.newint(1)
+ m_one = self.space.newint(-1)
if self.space.is_true(self.space.gt(v, zero)):
return one
elif self.space.is_true(self.space.lt(v, zero)):
@@ -2158,7 +2164,7 @@
if isinstance(w_item, boxes.W_StringBox):
return w_item
if w_item is None:
- w_item = space.wrap('')
+ w_item = space.newbytes('')
arg = space.str_w(space.str(w_item))
arr = VoidBoxStorage(dtype.elsize, dtype)
with arr as storage:
@@ -2196,7 +2202,7 @@
# XXX move the rest of this to base class when UnicodeType is supported
def to_builtin_type(self, space, box):
- return space.wrap(self.to_str(box))
+ return space.newbytes(self.to_str(box))
@str_binary_op
def eq(self, v1, v2):
@@ -2317,7 +2323,7 @@
def to_builtin_type(self, space, box):
assert isinstance(box, boxes.W_UnicodeBox)
- return space.wrap(box._value)
+ return space.newunicode(box._value)
def eq(self, v1, v2):
assert isinstance(v1, boxes.W_UnicodeBox)
@@ -2469,7 +2475,7 @@
read_val = dtype.read(item.arr, ofs, 0)
if isinstance (read_val, boxes.W_StringBox):
# StringType returns a str
- read_val = space.wrap(dtype.itemtype.to_str(read_val))
+ read_val = space.newbytes(dtype.itemtype.to_str(read_val))
ret_unwrapped = ret_unwrapped + [read_val,]
if len(ret_unwrapped) == 0:
raise oefmt(space.w_NotImplementedError,
@@ -2490,7 +2496,7 @@
for i in range(len(dtype.names)):
name = dtype.names[i]
if name in w_item.dtype.names:
- items_w[i] = w_item.descr_getitem(space,
space.wrap(name[0]))
+ items_w[i] = w_item.descr_getitem(space,
space.newtext(name[0]))
elif w_item is not None:
if space.isinstance_w(w_item, space.w_tuple):
if len(dtype.names) != space.len_w(w_item):
diff --git a/pypy/module/micronumpy/ufuncs.py b/pypy/module/micronumpy/ufuncs.py
--- a/pypy/module/micronumpy/ufuncs.py
+++ b/pypy/module/micronumpy/ufuncs.py
@@ -105,10 +105,10 @@
self.complex_to_float = complex_to_float
def descr_get_name(self, space):
- return space.wrap(self.name)
+ return space.newtext(self.name)
def descr_repr(self, space):
- return space.wrap("<ufunc '%s'>" % self.name)
+ return space.newtext("<ufunc '%s'>" % self.name)
def get_doc(self, space):
# Note: allows any object to be set as docstring, because why not?
@@ -160,7 +160,7 @@
def descr_accumulate(self, space, w_obj, w_axis=None, w_dtype=None,
w_out=None):
if w_axis is None:
- w_axis = space.wrap(0)
+ w_axis = space.newint(0)
out = out_converter(space, w_out)
return self.reduce(space, w_obj, w_axis, True, #keepdims must be true
out, w_dtype, variant=ACCUMULATE)
@@ -170,7 +170,7 @@
w_out=None, keepdims=False):
from pypy.module.micronumpy.ndarray import W_NDimArray
if w_axis is None:
- w_axis = space.wrap(0)
+ w_axis = space.newint(0)
out = out_converter(space, w_out)
return self.reduce(space, w_obj, w_axis, keepdims, out, w_dtype)
@@ -207,7 +207,7 @@
axes[i] = x
else:
if space.isinstance_w(w_axis, space.w_tuple) and
space.len_w(w_axis) == 1:
- w_axis = space.getitem(w_axis, space.wrap(0))
+ w_axis = space.getitem(w_axis, space.newint(0))
axis = space.int_w(w_axis)
if axis < -shapelen or axis >= shapelen:
raise oefmt(space.w_ValueError, "'axis' entry is out of
bounds")
@@ -373,7 +373,7 @@
raise oefmt(space.w_ValueError,
"exactly two arguments expected")
args = [convert_to_array(space, w_obj) for w_obj in args_w]
- w_outshape = [space.wrap(i) for i in args[0].get_shape() +
[1]*args[1].ndims()]
+ w_outshape = [space.newint(i) for i in args[0].get_shape() +
[1]*args[1].ndims()]
args0 = args[0].reshape(space, space.newtuple(w_outshape))
return self.descr_call(space, Arguments.frompacked(space,
space.newlist([args0,
args[1]])))
@@ -391,7 +391,7 @@
return w_subok, w_out, sig, w_casting, extobj_w
def get_extobj(space):
- extobj_w = space.newlist([space.wrap(8192), space.wrap(0),
space.w_None])
+ extobj_w = space.newlist([space.newint(8192), space.newint(0),
space.w_None])
return extobj_w
@@ -426,7 +426,7 @@
def _has_reflected_op(space, w_obj, op):
if op not in _reflected_ops:
return False
- return space.getattr(w_obj, space.wrap(_reflected_ops[op])) is not None
+ return space.getattr(w_obj, space.newtext(_reflected_ops[op])) is not None
def safe_casting_mode(casting):
assert casting is not None
@@ -475,7 +475,7 @@
if out is None:
if w_res.is_scalar():
return w_res.get_scalar_value()
- ctxt = space.newtuple([self, space.newtuple([w_obj]),
space.wrap(0)])
+ ctxt = space.newtuple([self, space.newtuple([w_obj]),
space.newint(0)])
w_res = space.call_method(w_obj, '__array_wrap__', w_res, ctxt)
return w_res
@@ -578,9 +578,9 @@
elif ((w_ldtype.is_object() and w_ldtype.is_record()) or
(w_rdtype.is_object() and w_rdtype.is_record())):
if self.name == 'not_equal':
- return space.wrap(True)
+ return space.w_True
elif self.name == 'equal':
- return space.wrap(False)
+ return space.w_False
else:
msg = ("ufunc '%s' not supported for the input types, "
"and the inputs could not be safely coerced to "
@@ -595,19 +595,19 @@
elif (w_ldtype.is_str()) and \
self.bool_result and out is None:
if self.name in ('equal', 'less_equal', 'less'):
- return space.wrap(False)
- return space.wrap(True)
+ return space.w_False
+ return space.w_True
elif (w_rdtype.is_str()) and \
self.bool_result and out is None:
if self.name in ('not_equal','less', 'less_equal'):
- return space.wrap(True)
- return space.wrap(False)
+ return space.w_True
+ return space.w_False
elif w_ldtype.is_flexible() or w_rdtype.is_flexible():
if self.bool_result:
if self.name == 'equal' or self.name == 'not_equal':
res = w_ldtype.eq(space, w_rdtype)
if not res:
- return space.wrap(self.name == 'not_equal')
+ return space.newbool(self.name == 'not_equal')
else:
return space.w_NotImplemented
else:
@@ -641,7 +641,7 @@
if out is None:
if w_res.is_scalar():
return w_res.get_scalar_value()
- ctxt = space.newtuple([self, space.newtuple([w_lhs, w_rhs]),
space.wrap(0)])
+ ctxt = space.newtuple([self, space.newtuple([w_lhs, w_rhs]),
space.newint(0)])
w_res = space.call_method(w_highpriority, '__array_wrap__', w_res,
ctxt)
return w_res
@@ -907,7 +907,7 @@
# from frompyfunc
pass
# mimic NpyIter_AdvancedNew with a nditer
- w_itershape = space.newlist([space.wrap(i) for i in iter_shape])
+ w_itershape = space.newlist([space.newint(i) for i in iter_shape])
nd_it = W_NDIter(space, space.newlist(inargs + outargs), w_flags,
w_op_flags, w_op_dtypes, w_casting, w_op_axes,
w_itershape, allow_backward=False)
@@ -956,7 +956,7 @@
outiters[0].descr_setitem(space, space.w_Ellipsis, outs)
else:
for i in range(self.nout):
- w_val = space.getitem(outs, space.wrap(i))
+ w_val = space.getitem(outs, space.newint(i))
outiters[i].descr_setitem(space, space.w_Ellipsis,
w_val)
# XXX use _find_array_wrap and wrap outargs using __array_wrap__
if len(outargs) > 1:
@@ -1531,7 +1531,7 @@
if w_ret.external_loop:
_parse_signature(space, w_ret, w_ret.signature)
if doc:
- w_ret.set_doc(space, space.wrap(doc))
+ w_ret.set_doc(space, space.newtext(doc))
return w_ret
# Instantiated in cpyext/ndarrayobject. It is here since ufunc calls
@@ -1572,8 +1572,8 @@
arg_i = args_w[i]
if not isinstance(arg_i, W_NDimArray):
raise OperationError(space.w_NotImplementedError,
- space.wrap("cannot mix ndarray and %r (arg %d) in
call to ufunc" % (
- arg_i, i)))
+ space.newtext("cannot mix ndarray and %r (arg %d) in
call to ufunc" % (
+ arg_i, i)))
with arg_i.implementation as storage:
addr = get_storage_as_int(storage, arg_i.get_start())
raw_storage_setitem(dataps, CCHARP_SIZE * i,
rffi.cast(rffi.CCHARP, addr))
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
https://mail.python.org/mailman/listinfo/pypy-commit
