[pypy-commit] pypy py3k: merge default
pjenvey
noreply at buildbot.pypy.org
Tue Dec 31 01:49:45 CET 2013
Author: Philip Jenvey <pjenvey at underboss.org>
Branch: py3k
Changeset: r68573:91714ff3b0b3
Date: 2013-12-30 16:30 -0800
http://bitbucket.org/pypy/pypy/changeset/91714ff3b0b3/
Log: merge default
diff too long, truncating to 2000 out of 2663 lines
diff --git a/pypy/interpreter/gateway.py b/pypy/interpreter/gateway.py
--- a/pypy/interpreter/gateway.py
+++ b/pypy/interpreter/gateway.py
@@ -823,8 +823,8 @@
raise TypeError("Varargs and keywords not supported in unwrap_spec")
argspec = ', '.join([arg for arg in args.args[1:]])
func_code = py.code.Source("""
- def f(w_obj, %(args)s):
- return w_obj.%(func_name)s(%(args)s)
+ def f(self, %(args)s):
+ return self.%(func_name)s(%(args)s)
""" % {'args': argspec, 'func_name': func.func_name})
d = {}
exec func_code.compile() in d
@@ -839,7 +839,7 @@
else:
assert isinstance(unwrap_spec, dict)
unwrap_spec = unwrap_spec.copy()
- unwrap_spec['w_obj'] = base_cls
+ unwrap_spec['self'] = base_cls
return interp2app(globals()['unwrap_spec'](**unwrap_spec)(f))
class interp2app(W_Root):
diff --git a/pypy/module/_cffi_backend/handle.py b/pypy/module/_cffi_backend/handle.py
--- a/pypy/module/_cffi_backend/handle.py
+++ b/pypy/module/_cffi_backend/handle.py
@@ -42,7 +42,7 @@
if self.handles[d]() is None:
self.look_distance = d + 1
return d
- # full! extend, but don't use '!=' here
+ # full! extend, but don't use '+=' here
self.handles = self.handles + [dead_ref] * (length // 3 + 5)
self.look_distance = length + 1
return length
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
@@ -426,7 +426,13 @@
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
- w_groupnum = space.getitem(self.srepat.w_groupindex, w_arg)
+ try:
+ w_groupnum = space.getitem(self.srepat.w_groupindex, w_arg)
+ except OperationError, e:
+ if not e.match(space, space.w_KeyError):
+ raise
+ raise OperationError(space.w_IndexError,
+ space.wrap("no such group"))
groupnum = space.int_w(w_groupnum)
if groupnum == 0:
return self.ctx.match_start, self.ctx.match_end
diff --git a/pypy/module/_sre/test/test_app_sre.py b/pypy/module/_sre/test/test_app_sre.py
--- a/pypy/module/_sre/test/test_app_sre.py
+++ b/pypy/module/_sre/test/test_app_sre.py
@@ -178,6 +178,9 @@
assert ("1", "1", None) == m.group(1, 2, 3)
assert ("1", None) == m.group("first", "second")
raises(IndexError, m.group, 1, 4)
+ assert ("1", None) == m.group(1, "second")
+ raises(IndexError, m.group, 'foobarbaz')
+ raises(IndexError, m.group, 'first', 'foobarbaz')
def test_expand(self):
import re
diff --git a/pypy/module/micronumpy/arrayimpl/scalar.py b/pypy/module/micronumpy/arrayimpl/scalar.py
--- a/pypy/module/micronumpy/arrayimpl/scalar.py
+++ b/pypy/module/micronumpy/arrayimpl/scalar.py
@@ -131,7 +131,11 @@
if space.isinstance_w(w_idx, space.w_tuple):
if space.len_w(w_idx) == 0:
return self.get_scalar_value()
- if space.is_none(w_idx):
+ elif space.isinstance_w(w_idx, space.w_str):
+ if self.dtype.is_record_type():
+ w_val = self.value.descr_getitem(space, w_idx)
+ return convert_to_array(space, w_val)
+ elif space.is_none(w_idx):
new_shape = [1]
arr = W_NDimArray.from_shape(space, new_shape, self.dtype)
arr_iter = arr.create_iter(new_shape)
@@ -145,6 +149,12 @@
space.wrap("0-d arrays can't be indexed"))
def descr_setitem(self, space, _, w_idx, w_val):
+ if space.isinstance_w(w_idx, space.w_tuple):
+ if space.len_w(w_idx) == 0:
+ return self.set_scalar_value(self.dtype.coerce(space, w_val))
+ elif space.isinstance_w(w_idx, space.w_str):
+ if self.dtype.is_record_type():
+ return self.value.descr_setitem(space, w_idx, w_val)
raise OperationError(space.w_IndexError,
space.wrap("0-d arrays can't be indexed"))
@@ -176,7 +186,7 @@
s = self.dtype.itemtype.bool(self.value)
w_res = W_NDimArray.from_shape(space, [s], index_type)
if s == 1:
- w_res.implementation.setitem(0, index_type.itemtype.box(0))
+ w_res.implementation.setitem(0, index_type.itemtype.box(0))
return space.newtuple([w_res])
def fill(self, space, w_value):
diff --git a/pypy/module/micronumpy/arrayimpl/sort.py b/pypy/module/micronumpy/arrayimpl/sort.py
--- a/pypy/module/micronumpy/arrayimpl/sort.py
+++ b/pypy/module/micronumpy/arrayimpl/sort.py
@@ -123,7 +123,8 @@
if w_axis is space.w_None:
# note that it's fine ot pass None here as we're not going
# to pass the result around (None is the link to base in slices)
- arr = arr.reshape(space, None, [arr.get_size()])
+ if arr.get_size() > 0:
+ arr = arr.reshape(space, None, [arr.get_size()])
axis = 0
elif w_axis is None:
axis = -1
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
@@ -38,7 +38,7 @@
from pypy.module.micronumpy.arrayimpl import concrete, scalar
if not shape:
- w_val = dtype.base.coerce(space, space.wrap(0))
+ w_val = dtype.base.coerce(space, None)
impl = scalar.Scalar(dtype.base, w_val)
else:
strides, backstrides = calc_strides(shape, dtype.base, order)
diff --git a/pypy/module/micronumpy/interp_boxes.py b/pypy/module/micronumpy/interp_boxes.py
--- a/pypy/module/micronumpy/interp_boxes.py
+++ b/pypy/module/micronumpy/interp_boxes.py
@@ -11,6 +11,7 @@
from rpython.rtyper.lltypesystem import rffi
from rpython.tool.sourcetools import func_with_new_name
from pypy.module.micronumpy.arrayimpl.voidbox import VoidBoxStorage
+from pypy.module.micronumpy.base import W_NDimArray
from pypy.module.micronumpy.interp_flagsobj import W_FlagsObject
from pypy.interpreter.mixedmodule import MixedModule
from rpython.rtyper.lltypesystem import lltype
@@ -270,14 +271,25 @@
def descr_view(self, space, w_dtype):
from pypy.module.micronumpy.interp_dtype import W_Dtype
- dtype = space.interp_w(W_Dtype,
- space.call_function(space.gettypefor(W_Dtype), w_dtype))
- if dtype.get_size() == 0:
- raise OperationError(space.w_TypeError, space.wrap(
- "data-type must not be 0-sized"))
- if dtype.get_size() != self.get_dtype(space).get_size():
- raise OperationError(space.w_ValueError, space.wrap(
- "new type not compatible with array."))
+ try:
+ subclass = space.is_true(space.issubtype(
+ w_dtype, space.gettypefor(W_NDimArray)))
+ except OperationError, e:
+ if e.match(space, space.w_TypeError):
+ subclass = False
+ else:
+ raise
+ if subclass:
+ dtype = self.get_dtype(space)
+ else:
+ dtype = space.interp_w(W_Dtype,
+ space.call_function(space.gettypefor(W_Dtype), w_dtype))
+ if dtype.get_size() == 0:
+ raise OperationError(space.w_TypeError, space.wrap(
+ "data-type must not be 0-sized"))
+ if dtype.get_size() != self.get_dtype(space).get_size():
+ raise OperationError(space.w_ValueError, space.wrap(
+ "new type not compatible with array."))
if dtype.is_str_or_unicode():
return dtype.coerce(space, space.wrap(self.raw_str()))
elif dtype.is_record_type():
@@ -345,28 +357,22 @@
descr__new__, _get_dtype, descr_reduce = new_dtype_getter("uint16")
class W_Int32Box(W_SignedIntegerBox, PrimitiveBox):
- descr__new__, _get_dtype, descr_reduce = new_dtype_getter("int32")
+ descr__new__, _get_dtype, descr_reduce = new_dtype_getter("i")
class W_UInt32Box(W_UnsignedIntegerBox, PrimitiveBox):
- descr__new__, _get_dtype, descr_reduce = new_dtype_getter("uint32")
+ descr__new__, _get_dtype, descr_reduce = new_dtype_getter("I")
+
+class W_Int64Box(W_SignedIntegerBox, PrimitiveBox):
+ descr__new__, _get_dtype, descr_reduce = new_dtype_getter("q")
+
+class W_UInt64Box(W_UnsignedIntegerBox, PrimitiveBox):
+ descr__new__, _get_dtype, descr_reduce = new_dtype_getter("Q")
class W_LongBox(W_SignedIntegerBox, PrimitiveBox):
- descr__new__, _get_dtype, descr_reduce = new_dtype_getter("long")
+ descr__new__, _get_dtype, descr_reduce = new_dtype_getter("l")
class W_ULongBox(W_UnsignedIntegerBox, PrimitiveBox):
- descr__new__, _get_dtype, descr_reduce = new_dtype_getter("ulong")
-
-class W_Int64Box(W_SignedIntegerBox, PrimitiveBox):
- descr__new__, _get_dtype, descr_reduce = new_dtype_getter("int64")
-
-class W_LongLongBox(W_SignedIntegerBox, PrimitiveBox):
- descr__new__, _get_dtype, descr_reduce = new_dtype_getter('longlong')
-
-class W_UInt64Box(W_UnsignedIntegerBox, PrimitiveBox):
- descr__new__, _get_dtype, descr_reduce = new_dtype_getter("uint64")
-
-class W_ULongLongBox(W_SignedIntegerBox, PrimitiveBox):
- descr__new__, _get_dtype, descr_reduce = new_dtype_getter('ulonglong')
+ descr__new__, _get_dtype, descr_reduce = new_dtype_getter("L")
class W_InexactBox(W_NumberBox):
pass
@@ -422,7 +428,7 @@
self.dtype = dtype
def get_dtype(self, space):
- return self.arr.dtype
+ return self.dtype
def raw_str(self):
return self.arr.dtype.itemtype.to_str(self)
@@ -460,13 +466,17 @@
return space.wrap(dtype.itemtype.to_str(read_val))
return read_val
- @unwrap_spec(item=str)
- def descr_setitem(self, space, item, w_value):
+ def descr_setitem(self, space, w_item, w_value):
+ if space.isinstance_w(w_item, space.w_basestring):
+ item = space.str_w(w_item)
+ else:
+ raise OperationError(space.w_IndexError, space.wrap(
+ "invalid index"))
try:
ofs, dtype = self.dtype.fields[item]
except KeyError:
- raise OperationError(space.w_IndexError,
- space.wrap("Field %s does not exist" % item))
+ raise OperationError(space.w_ValueError,
+ space.wrap("field named %s not found" % item))
dtype.itemtype.store(self.arr, self.ofs, ofs,
dtype.coerce(space, w_value))
@@ -658,13 +668,6 @@
__reduce__ = interp2app(W_Int64Box.descr_reduce),
)
-if LONG_BIT == 32:
- W_LongBox = W_Int32Box
- W_ULongBox = W_UInt32Box
-elif LONG_BIT == 64:
- W_LongBox = W_Int64Box
- W_ULongBox = W_UInt64Box
-
W_UInt64Box.typedef = TypeDef("uint64", W_UnsignedIntegerBox.typedef,
__module__ = "numpy",
__new__ = interp2app(W_UInt64Box.descr__new__.im_func),
@@ -672,6 +675,21 @@
__reduce__ = interp2app(W_UInt64Box.descr_reduce),
)
+W_LongBox.typedef = TypeDef("int%d" % LONG_BIT,
+ (W_SignedIntegerBox.typedef, int_typedef),
+ __module__ = "numpy",
+ __new__ = interp2app(W_LongBox.descr__new__.im_func),
+ __index__ = interp2app(W_LongBox.descr_index),
+ __reduce__ = interp2app(W_LongBox.descr_reduce),
+)
+
+W_ULongBox.typedef = TypeDef("uint%d" % LONG_BIT, W_UnsignedIntegerBox.typedef,
+ __module__ = "numpy",
+ __new__ = interp2app(W_ULongBox.descr__new__.im_func),
+ __index__ = interp2app(W_ULongBox.descr_index),
+ __reduce__ = interp2app(W_ULongBox.descr_reduce),
+)
+
W_InexactBox.typedef = TypeDef("inexact", W_NumberBox.typedef,
__module__ = "numpy",
)
diff --git a/pypy/module/micronumpy/interp_dtype.py b/pypy/module/micronumpy/interp_dtype.py
--- a/pypy/module/micronumpy/interp_dtype.py
+++ b/pypy/module/micronumpy/interp_dtype.py
@@ -136,6 +136,8 @@
return space.wrap(self.itemtype.alignment)
def descr_get_subdtype(self, space):
+ if self.subdtype is None:
+ return space.w_None
return space.newtuple([space.wrap(self.subdtype), self.descr_get_shape(space)])
def descr_get_str(self, space):
@@ -157,8 +159,20 @@
return space.newlist([space.newtuple([space.wrap(""),
self.descr_get_str(space)])])
else:
- raise OperationError(space.w_NotImplementedError, space.wrap(
- "descr not implemented for record types"))
+ descr = []
+ for name in self.fieldnames:
+ subdtype = self.fields[name][1]
+ subdescr = [space.wrap(name)]
+ if subdtype.is_record_type():
+ subdescr.append(subdtype.descr_get_descr(space))
+ elif subdtype.subdtype is not None:
+ subdescr.append(subdtype.subdtype.descr_get_str(space))
+ else:
+ subdescr.append(subdtype.descr_get_str(space))
+ if subdtype.shape != []:
+ subdescr.append(subdtype.descr_get_shape(space))
+ descr.append(space.newtuple(subdescr[:]))
+ return space.newlist(descr)
def descr_get_base(self, space):
return space.wrap(self.base)
@@ -651,6 +665,7 @@
w_box_type = space.gettypefor(interp_boxes.W_Float64Box),
alternate_constructors=[space.w_float,
space.gettypefor(interp_boxes.W_NumberBox),
+ space.gettypefor(interp_boxes.W_FloatingBox),
],
aliases=["float", "double"],
)
@@ -680,7 +695,8 @@
name="complex128",
char=NPY_CDOUBLELTR,
w_box_type = space.gettypefor(interp_boxes.W_Complex128Box),
- alternate_constructors=[space.w_complex],
+ alternate_constructors=[space.w_complex,
+ space.gettypefor(interp_boxes.W_ComplexFloatingBox)],
aliases=["complex", 'cfloat', 'cdouble'],
float_type = self.w_float64dtype,
)
@@ -702,7 +718,8 @@
name='string',
char=NPY_STRINGLTR,
w_box_type = space.gettypefor(interp_boxes.W_StringBox),
- alternate_constructors=[space.w_str, space.gettypefor(interp_boxes.W_CharacterBox)],
+ alternate_constructors=[space.w_str,
+ space.gettypefor(interp_boxes.W_CharacterBox)],
aliases=["str"],
)
self.w_unicodedtype = W_Dtype(
@@ -736,38 +753,21 @@
char=NPY_HALFLTR,
w_box_type=space.gettypefor(interp_boxes.W_Float16Box),
)
- ptr_size = rffi.sizeof(rffi.CCHARP)
- if ptr_size == 4:
- intp_box = interp_boxes.W_Int32Box
- intp_type = types.Int32()
- intp_num = NPY_INT
- uintp_box = interp_boxes.W_UInt32Box
- uintp_type = types.UInt32()
- uintp_num = NPY_UINT
- elif ptr_size == 8:
- intp_box = interp_boxes.W_Int64Box
- intp_type = types.Int64()
- intp_num = NPY_LONG
- uintp_box = interp_boxes.W_UInt64Box
- uintp_type = types.UInt64()
- uintp_num = NPY_ULONG
- else:
- raise ValueError('unknown point size %d' % ptr_size)
self.w_intpdtype = W_Dtype(
- intp_type,
- num=intp_num,
- kind=NPY_INTPLTR,
+ types.Long(),
+ num=NPY_LONG,
+ kind=NPY_SIGNEDLTR,
name='intp',
char=NPY_INTPLTR,
- w_box_type = space.gettypefor(intp_box),
+ w_box_type = space.gettypefor(interp_boxes.W_LongBox),
)
self.w_uintpdtype = W_Dtype(
- uintp_type,
- num=uintp_num,
- kind=NPY_UINTPLTR,
+ types.ULong(),
+ num=NPY_ULONG,
+ kind=NPY_UNSIGNEDLTR,
name='uintp',
char=NPY_UINTPLTR,
- w_box_type = space.gettypefor(uintp_box),
+ w_box_type = space.gettypefor(interp_boxes.W_ULongBox),
)
float_dtypes = [self.w_float16dtype, self.w_float32dtype,
self.w_float64dtype, self.w_floatlongdtype]
diff --git a/pypy/module/micronumpy/interp_numarray.py b/pypy/module/micronumpy/interp_numarray.py
--- a/pypy/module/micronumpy/interp_numarray.py
+++ b/pypy/module/micronumpy/interp_numarray.py
@@ -731,11 +731,15 @@
def descr_view(self, space, w_dtype=None, w_type=None):
if not w_type and w_dtype:
try:
- if space.is_true(space.issubtype(w_dtype, space.gettypefor(W_NDimArray))):
+ if space.is_true(space.issubtype(
+ w_dtype, space.gettypefor(W_NDimArray))):
w_type = w_dtype
w_dtype = None
- except (OperationError, TypeError):
- pass
+ except OperationError, e:
+ if e.match(space, space.w_TypeError):
+ pass
+ else:
+ raise
if w_dtype:
dtype = space.interp_w(interp_dtype.W_Dtype,
space.call_function(space.gettypefor(interp_dtype.W_Dtype),
@@ -1170,12 +1174,15 @@
def take(a, indices, axis, out, mode):
assert mode == 'raise'
if axis is None:
- res = a.ravel()[indices]
+ from numpy import array
+ indices = array(indices)
+ res = a.ravel()[indices.ravel()].reshape(indices.shape)
else:
+ from operator import mul
if axis < 0: axis += len(a.shape)
s0, s1 = a.shape[:axis], a.shape[axis+1:]
- l0 = prod(s0) if s0 else 1
- l1 = prod(s1) if s1 else 1
+ l0 = reduce(mul, s0) if s0 else 1
+ l1 = reduce(mul, s1) if s1 else 1
res = a.reshape((l0, -1, l1))[:,indices,:].reshape(s0 + (-1,) + s1)
if out is not None:
out[:] = res
@@ -1423,12 +1430,11 @@
arr_iter.next()
return w_arr
- at unwrap_spec(order=str)
-def zeros(space, w_shape, w_dtype=None, order='C'):
+def zeros(space, w_shape, w_dtype=None, w_order=None):
dtype = space.interp_w(interp_dtype.W_Dtype,
space.call_function(space.gettypefor(interp_dtype.W_Dtype), w_dtype))
shape = _find_shape(space, w_shape, dtype)
- return W_NDimArray.from_shape(space, shape, dtype=dtype, order=order)
+ return W_NDimArray.from_shape(space, shape, dtype=dtype)
@unwrap_spec(subok=bool)
def empty_like(space, w_a, w_dtype=None, w_order=None, subok=True):
diff --git a/pypy/module/micronumpy/interp_ufuncs.py b/pypy/module/micronumpy/interp_ufuncs.py
--- a/pypy/module/micronumpy/interp_ufuncs.py
+++ b/pypy/module/micronumpy/interp_ufuncs.py
@@ -33,6 +33,9 @@
self.allow_complex = allow_complex
self.complex_to_float = complex_to_float
+ def descr_get_name(self, space):
+ return space.wrap(self.name)
+
def descr_repr(self, space):
return space.wrap("<ufunc '%s'>" % self.name)
@@ -373,14 +376,19 @@
w_rdtype = w_ldtype
elif w_lhs.is_scalar() and not w_rhs.is_scalar():
w_ldtype = w_rdtype
- if (self.int_only and (not w_ldtype.is_int_type() or not w_rdtype.is_int_type()) or
- not self.allow_bool and (w_ldtype.is_bool_type() or w_rdtype.is_bool_type()) or
- not self.allow_complex and (w_ldtype.is_complex_type() or w_rdtype.is_complex_type())):
- raise OperationError(space.w_TypeError, space.wrap("Unsupported types"))
calc_dtype = find_binop_result_dtype(space,
w_ldtype, w_rdtype,
promote_to_float=self.promote_to_float,
promote_bools=self.promote_bools)
+ if (self.int_only and (not w_ldtype.is_int_type() or
+ not w_rdtype.is_int_type() or
+ not calc_dtype.is_int_type()) or
+ not self.allow_bool and (w_ldtype.is_bool_type() or
+ w_rdtype.is_bool_type()) or
+ not self.allow_complex and (w_ldtype.is_complex_type() or
+ w_rdtype.is_complex_type())):
+ raise OperationError(space.w_TypeError, space.wrap(
+ "ufunc '%s' not supported for the input types" % self.name))
if space.is_none(w_out):
out = None
elif not isinstance(w_out, W_NDimArray):
@@ -417,6 +425,7 @@
__call__ = interp2app(W_Ufunc.descr_call),
__repr__ = interp2app(W_Ufunc.descr_repr),
+ __name__ = GetSetProperty(W_Ufunc.descr_get_name),
identity = GetSetProperty(W_Ufunc.descr_get_identity),
accumulate = interp2app(W_Ufunc.descr_accumulate),
@@ -428,6 +437,8 @@
def find_binop_result_dtype(space, dt1, dt2, promote_to_float=False,
promote_bools=False):
+ if dt2 is None:
+ return dt1
# dt1.num should be <= dt2.num
if dt1.num > dt2.num:
dt1, dt2 = dt2, dt1
@@ -523,31 +534,30 @@
bool_dtype = interp_dtype.get_dtype_cache(space).w_booldtype
long_dtype = interp_dtype.get_dtype_cache(space).w_longdtype
int64_dtype = interp_dtype.get_dtype_cache(space).w_int64dtype
- complex_type = interp_dtype.get_dtype_cache(space).w_complex128dtype
- float_type = interp_dtype.get_dtype_cache(space).w_float64dtype
+ uint64_dtype = interp_dtype.get_dtype_cache(space).w_uint64dtype
+ complex_dtype = interp_dtype.get_dtype_cache(space).w_complex128dtype
+ float_dtype = interp_dtype.get_dtype_cache(space).w_float64dtype
if isinstance(w_obj, interp_boxes.W_GenericBox):
dtype = w_obj.get_dtype(space)
- if current_guess is None:
- return dtype
return find_binop_result_dtype(space, dtype, current_guess)
if space.isinstance_w(w_obj, space.w_bool):
- if current_guess is None or current_guess is bool_dtype:
- return bool_dtype
- return current_guess
+ return find_binop_result_dtype(space, bool_dtype, current_guess)
elif space.isinstance_w(w_obj, space.w_int):
- if (current_guess is None or current_guess is bool_dtype or
- current_guess is long_dtype or current_guess is int64_dtype):
- return int64_dtype
- return current_guess
+ try:
+ space.int_w(w_obj)
+ except OperationError, e:
+ if e.match(space, space.w_OverflowError):
+ return find_binop_result_dtype(space, uint64_dtype,
+ current_guess)
+ raise
+ return find_binop_result_dtype(space, int64_dtype, current_guess)
+ elif space.isinstance_w(w_obj, space.w_float):
+ return find_binop_result_dtype(space, float_dtype, current_guess)
elif space.isinstance_w(w_obj, space.w_complex):
- if (current_guess is None or current_guess is bool_dtype or
- current_guess is long_dtype or current_guess is int64_dtype or
- current_guess is complex_type or current_guess is float_type):
- return complex_type
- return current_guess
+ return complex_dtype
elif space.isinstance_w(w_obj, space.w_str):
- if (current_guess is None):
+ if current_guess is None:
return interp_dtype.variable_dtype(space,
'S%d' % space.len_w(w_obj))
elif current_guess.num == NPY_STRING:
@@ -555,12 +565,6 @@
return interp_dtype.variable_dtype(space,
'S%d' % space.len_w(w_obj))
return current_guess
- if current_guess is complex_type:
- return complex_type
- if space.isinstance_w(w_obj, space.w_float):
- return float_type
- elif space.isinstance_w(w_obj, space.w_slice):
- return long_dtype
raise operationerrfmt(space.w_NotImplementedError,
'unable to create dtype from objects, ' '"%T" instance not supported',
w_obj)
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
@@ -69,9 +69,11 @@
return True
def find_shape_and_elems(space, w_iterable, dtype):
+ is_rec_type = dtype is not None and dtype.is_record_type()
+ if is_rec_type and is_single_elem(space, w_iterable, is_rec_type):
+ return [], [w_iterable]
shape = [space.len_w(w_iterable)]
batch = space.listview(w_iterable)
- is_rec_type = dtype is not None and dtype.is_record_type()
while True:
if not batch:
return shape[:], []
diff --git a/pypy/module/micronumpy/test/test_dtypes.py b/pypy/module/micronumpy/test/test_dtypes.py
--- a/pypy/module/micronumpy/test/test_dtypes.py
+++ b/pypy/module/micronumpy/test/test_dtypes.py
@@ -33,6 +33,11 @@
assert typeinfo['CFLOAT'] == ('F', 14, 64, 8, np.complex64)
assert typeinfo['CDOUBLE'] == ('D', 15, 128, 16, np.complex128)
assert typeinfo['HALF'] == ('e', 23, 16, 2, np.float16)
+ assert typeinfo['INTP'] == ('p', np.dtype('int').num,
+ self.ptr_size*8, self.ptr_size,
+ 2**(self.ptr_size*8 - 1) - 1,
+ -2**(self.ptr_size*8 - 1),
+ np.dtype('int').type)
def test_dtype_basic(self):
from numpypy import dtype
@@ -49,6 +54,7 @@
assert dtype(int).fields is None
assert dtype(int).names is None
assert dtype(int).hasobject is False
+ assert dtype(int).subdtype is None
assert dtype(None) is dtype(float)
@@ -109,15 +115,11 @@
assert dtype(bool).num == 0
if self.ptr_size == 4:
- assert dtype('intp').num == 5
- assert dtype('uintp').num == 6
assert dtype('int32').num == 7
assert dtype('uint32').num == 8
assert dtype('int64').num == 9
assert dtype('uint64').num == 10
else:
- assert dtype('intp').num == 7
- assert dtype('uintp').num == 8
assert dtype('int32').num == 5
assert dtype('uint32').num == 6
assert dtype('int64').num == 7
@@ -125,6 +127,8 @@
assert dtype(int).num == 7
assert dtype('int').num == 7
assert dtype('uint').num == 8
+ assert dtype('intp').num == 7
+ assert dtype('uintp').num == 8
assert dtype(float).num == 12
assert dtype('float').num == 12
assert dtype('complex').num == 15
@@ -365,16 +369,22 @@
# numpy allows abstract types in array creation
a_n = numpy.array([4,4], numpy.number)
+ a_f = numpy.array([4,4], numpy.floating)
+ a_c = numpy.array([4,4], numpy.complexfloating)
a_i = numpy.array([4,4], numpy.integer)
a_s = numpy.array([4,4], numpy.signedinteger)
a_u = numpy.array([4,4], numpy.unsignedinteger)
assert a_n.dtype.num == 12
+ assert a_f.dtype.num == 12
+ assert a_c.dtype.num == 15
assert a_i.dtype.num == 7
assert a_s.dtype.num == 7
assert a_u.dtype.num == 8
assert a_n.dtype is numpy.dtype('float64')
+ assert a_f.dtype is numpy.dtype('float64')
+ assert a_c.dtype is numpy.dtype('complex128')
if self.ptr_size == 4:
assert a_i.dtype is numpy.dtype('int32')
assert a_s.dtype is numpy.dtype('int32')
@@ -472,8 +482,7 @@
assert numpy.int16('32768') == -32768
def test_uint16(self):
- import numpypy as numpy
-
+ import numpy
assert numpy.uint16(65535) == 65535
assert numpy.uint16(65536) == 0
assert numpy.uint16('65535') == 65535
@@ -481,8 +490,7 @@
def test_int32(self):
import sys
- import numpypy as numpy
-
+ import numpy
x = numpy.int32(23)
assert x == 23
assert numpy.int32(2147483647) == 2147483647
@@ -497,10 +505,8 @@
def test_uint32(self):
import sys
- import numpypy as numpy
-
+ import numpy
assert numpy.uint32(10) == 10
-
if sys.maxsize > 2 ** 31 - 1:
assert numpy.uint32(4294967295) == 4294967295
assert numpy.uint32(4294967296) == 0
@@ -517,8 +523,7 @@
def test_int64(self):
import sys
- import numpypy as numpy
-
+ import numpy
if sys.maxsize == 2 ** 63 -1:
assert numpy.int64.mro() == [numpy.int64, numpy.signedinteger,
numpy.integer, numpy.number,
@@ -533,30 +538,30 @@
assert numpy.int64(9223372036854775807) == 9223372036854775807
assert numpy.int64(9223372036854775807) == 9223372036854775807
-
raises(OverflowError, numpy.int64, 9223372036854775808)
raises(OverflowError, numpy.int64, 9223372036854775808L)
def test_uint64(self):
- import sys
- import numpypy as numpy
-
+ import numpy
+ assert numpy.dtype(numpy.uint64).type is numpy.uint64
assert numpy.uint64.mro() == [numpy.uint64, numpy.unsignedinteger,
numpy.integer, numpy.number,
numpy.generic, object]
-
- assert numpy.dtype(numpy.uint64).type is numpy.uint64
- skip("see comment")
- # These tests pass "by chance" on numpy, things that are larger than
- # platform long (i.e. a python int), don't get put in a normal box,
- # instead they become an object array containing a long, we don't have
- # yet, so these can't pass.
- assert numpy.uint64(9223372036854775808) == 9223372036854775808
- assert numpy.uint64(18446744073709551615) == 18446744073709551615
- raises(OverflowError, numpy.uint64(18446744073709551616))
+ import sys
+ if '__pypy__' not in sys.builtin_module_names:
+ # These tests pass "by chance" on numpy, things that are larger than
+ # platform long (i.e. a python int), don't get put in a normal box,
+ # instead they become an object array containing a long, we don't have
+ # yet, so these can't pass.
+ assert numpy.uint64(9223372036854775808) == 9223372036854775808
+ assert numpy.uint64(18446744073709551615) == 18446744073709551615
+ else:
+ raises(OverflowError, numpy.int64, 9223372036854775808)
+ raises(OverflowError, numpy.int64, 18446744073709551615)
+ raises(OverflowError, numpy.uint64, 18446744073709551616)
def test_float16(self):
- import numpypy as numpy
+ import numpy
assert numpy.float16.mro() == [numpy.float16, numpy.floating,
numpy.inexact, numpy.number,
numpy.generic, object]
@@ -567,8 +572,7 @@
def test_float32(self):
- import numpypy as numpy
-
+ import numpy
assert numpy.float32.mro() == [numpy.float32, numpy.floating,
numpy.inexact, numpy.number,
numpy.generic, object]
@@ -578,8 +582,7 @@
raises(ValueError, numpy.float32, '23.2df')
def test_float64(self):
- import numpypy as numpy
-
+ import numpy
assert numpy.float64.mro() == [numpy.float64, numpy.floating,
numpy.inexact, numpy.number,
numpy.generic, float, object]
@@ -595,14 +598,14 @@
raises(ValueError, numpy.float64, '23.2df')
def test_float_None(self):
- import numpypy as numpy
+ import numpy
from math import isnan
assert isnan(numpy.float32(None))
assert isnan(numpy.float64(None))
assert isnan(numpy.longdouble(None))
def test_longfloat(self):
- import numpypy as numpy
+ import numpy
# it can be float96 or float128
if numpy.longfloat != numpy.float64:
assert numpy.longfloat.mro()[1:] == [numpy.floating,
@@ -615,8 +618,7 @@
raises(ValueError, numpy.longfloat, '23.2df')
def test_complex_floating(self):
- import numpypy as numpy
-
+ import numpy
assert numpy.complexfloating.__mro__ == (numpy.complexfloating,
numpy.inexact, numpy.number, numpy.generic, object)
@@ -714,10 +716,14 @@
assert numpy.int16 is numpy.short
assert numpy.int8 is numpy.byte
assert numpy.bool_ is numpy.bool8
+ assert numpy.intp().dtype.num == 7
+ assert numpy.intp().dtype.char == 'l'
if self.ptr_size == 4:
+ assert numpy.intp().dtype.name == 'int32'
assert numpy.intp is numpy.int32
assert numpy.uintp is numpy.uint32
elif self.ptr_size == 8:
+ assert numpy.intp().dtype.name == 'int64'
assert numpy.intp is numpy.int64
assert numpy.uintp is numpy.uint64
@@ -786,8 +792,22 @@
def test_intp(self):
from numpypy import dtype
- assert dtype('p') == dtype('intp')
- assert dtype('P') == dtype('uintp')
+ assert dtype('p') is dtype('intp')
+ assert dtype('P') is dtype('uintp')
+ #assert dtype('p') is dtype('int')
+ #assert dtype('P') is dtype('uint')
+ assert dtype('p').num == 7
+ assert dtype('P').num == 8
+ #assert dtype('p').char == 'l'
+ #assert dtype('P').char == 'L'
+ assert dtype('p').kind == 'i'
+ assert dtype('P').kind == 'u'
+ #if self.ptr_size == 4:
+ # assert dtype('p').name == 'int32'
+ # assert dtype('P').name == 'uint32'
+ #else:
+ # assert dtype('p').name == 'int64'
+ # assert dtype('P').name == 'uint64'
def test_alignment(self):
from numpypy import dtype
@@ -835,12 +855,12 @@
import numpy as np
assert np.dtype('<i8').descr == [('', '<i8')]
assert np.dtype('|S4').descr == [('', '|S4')]
+ assert np.dtype(('<i8', (5,))).descr == [('', '|V40')]
d = [('test', '<i8'), ('blah', '<i2', (2, 3))]
- import sys
- if '__pypy__' in sys.builtin_module_names:
- raises(NotImplementedError, "np.dtype(d).descr")
- else:
- assert np.dtype(d).descr == d
+ assert np.dtype(d).descr == d
+ a = [('x', '<i8'), ('y', '<f8')]
+ b = [('x', '<i4'), ('y', a)]
+ assert np.dtype(b).descr == b
class AppTestStrUnicodeDtypes(BaseNumpyAppTest):
def test_mro(self):
@@ -931,10 +951,14 @@
raises(KeyError, 'd.fields["xyz"]')
def test_create_from_dict(self):
- skip("not yet")
- from numpypy import dtype
- d = dtype({'names': ['a', 'b', 'c'],
- })
+ import numpy as np
+ import sys
+ d = {'names': ['r','g','b','a'],
+ 'formats': [np.uint8, np.uint8, np.uint8, np.uint8]}
+ if '__pypy__' not in sys.builtin_module_names:
+ dt = np.dtype(d)
+ else:
+ raises(NotImplementedError, np.dtype, d)
def test_create_subarrays(self):
from numpypy import dtype
diff --git a/pypy/module/micronumpy/test/test_numarray.py b/pypy/module/micronumpy/test/test_numarray.py
--- a/pypy/module/micronumpy/test/test_numarray.py
+++ b/pypy/module/micronumpy/test/test_numarray.py
@@ -217,6 +217,7 @@
assert get(1, 0) == 2
assert get(1, 1) == 3
+
class AppTestNumArray(BaseNumpyAppTest):
spaceconfig = dict(usemodules=["micronumpy", "struct", "binascii"])
@@ -353,7 +354,10 @@
# And check that changes stick.
a[13] = 5.3
assert a[13] == 5.3
+ assert zeros(()) == 0
assert zeros(()).shape == ()
+ assert zeros((), dtype='S') == ''
+ assert zeros((), dtype='S').shape == ()
def test_empty_like(self):
import numpy as np
@@ -744,6 +748,8 @@
b = a[()]
assert type(b) is int_
assert b == 3
+ a[()] = 4
+ assert a == 4
def test_len(self):
from numpypy import array
@@ -1158,14 +1164,20 @@
assert (2 << a == [2, 4, 8]).all()
def test_rshift(self):
- from numpypy import arange, array
-
- a = arange(10)
+ import numpy as np
+ a = np.arange(10)
assert (a >> 2 == [0, 0, 0, 0, 1, 1, 1, 1, 2, 2]).all()
- a = array([True, False])
+ a = np.array([True, False])
assert (a >> 1 == [0, 0]).all()
- a = arange(3, dtype=float)
+ a = np.arange(3, dtype=float)
raises(TypeError, lambda: a >> 1)
+ a = np.array([123], dtype='uint64')
+ b = a >> 1
+ assert b == 61
+ assert b.dtype.type is np.uint64
+ a = np.array(123, dtype='uint64')
+ exc = raises(TypeError, "a >> 1")
+ assert 'not supported for the input types' in exc.value.message
def test_rrshift(self):
from numpypy import arange
@@ -1407,11 +1419,11 @@
for dt in ['bool', 'int8', 'uint8', 'int16', 'uint16']:
a = array([True, False], dtype=dt)
assert a.prod() == 0
- assert a.prod().dtype == dtype('uint' if dt[0] == 'u' else 'int')
+ assert a.prod().dtype is dtype('uint' if dt[0] == 'u' else 'int')
for dt in ['l', 'L', 'q', 'Q', 'e', 'f', 'd', 'F', 'D']:
a = array([True, False], dtype=dt)
assert a.prod() == 0
- assert a.prod().dtype == dtype(dt)
+ assert a.prod().dtype is dtype(dt)
def test_max(self):
from numpypy import array, zeros
@@ -1494,12 +1506,12 @@
def test_dtype_guessing(self):
from numpypy import array, dtype
-
+ import sys
assert array([True]).dtype is dtype(bool)
assert array([True, False]).dtype is dtype(bool)
assert array([True, 1]).dtype is dtype(int)
assert array([1, 2, 3]).dtype is dtype(int)
- #assert array([1L, 2, 3]).dtype is dtype(long)
+ assert array([1L, 2, 3]).dtype is dtype('q')
assert array([1.2, True]).dtype is dtype(float)
assert array([1.2, 5]).dtype is dtype(float)
assert array([]).dtype is dtype(float)
@@ -1510,6 +1522,12 @@
assert array([int8(3)]).dtype is dtype("int8")
assert array([bool_(True)]).dtype is dtype(bool)
assert array([bool_(True), 3.0]).dtype is dtype(float)
+ assert array(sys.maxint + 42).dtype is dtype('Q')
+ assert array([sys.maxint + 42] * 2).dtype is dtype('Q')
+ assert array([sys.maxint + 42, 123]).dtype is dtype(float)
+ assert array([sys.maxint + 42, 123L]).dtype is dtype(float)
+ assert array([1+2j, 123]).dtype is dtype(complex)
+ assert array([1+2j, 123L]).dtype is dtype(complex)
def test_comparison(self):
import operator
@@ -2176,12 +2194,6 @@
a[b] = 1.
assert (a == [[1., 1., 1.]]).all()
- @py.test.mark.xfail
- def test_boolean_array(self):
- import numpypy as np
- a = np.ndarray([1], dtype=bool)
- assert a[0] == True
-
class AppTestNumArrayFromBuffer(BaseNumpyAppTest):
spaceconfig = dict(usemodules=["micronumpy", "array", "mmap"])
@@ -2244,7 +2256,6 @@
f.close()
-
class AppTestMultiDim(BaseNumpyAppTest):
def test_init(self):
import numpypy
@@ -2718,7 +2729,12 @@
assert (arange(10).take([1, 2, 1, 1]) == [1, 2, 1, 1]).all()
raises(IndexError, "arange(3).take([15])")
a = arange(6).reshape(2, 3)
+ assert a.take(3) == 3
+ assert a.take(3).shape == ()
assert (a.take([1, 0, 3]) == [1, 0, 3]).all()
+ assert (a.take([[1, 0], [2, 3]]) == [[1, 0], [2, 3]]).all()
+ assert (a.take([1], axis=0) == [[3, 4, 5]]).all()
+ assert (a.take([1], axis=1) == [[1], [4]]).all()
assert ((a + a).take([3]) == [6]).all()
a = arange(12).reshape(2, 6)
assert (a[:,::2].take([3, 2, 1]) == [6, 4, 2]).all()
@@ -2815,7 +2831,11 @@
assert b[35] == 200
b[[slice(25, 30)]] = range(5)
assert all(a[:5] == range(5))
- raises(TypeError, 'b[[[slice(25, 125)]]]')
+ import sys
+ if '__pypy__' not in sys.builtin_module_names:
+ raises(TypeError, 'b[[[slice(25, 125)]]]')
+ else:
+ raises(NotImplementedError, 'b[[[slice(25, 125)]]]')
def test_cumsum(self):
from numpypy import arange
@@ -2969,17 +2989,18 @@
assert j[0] == 12
k = fromstring(self.float16val, dtype='float16')
assert k[0] == dtype('float16').type(5.)
- dt = array([5],dtype='longfloat').dtype
- if dt.itemsize == 12:
+ dt = array([5], dtype='longfloat').dtype
+ if dt.itemsize == 8:
+ m = fromstring('\x00\x00\x00\x00\x00\x00\x14@',
+ dtype='float64')
+ elif dt.itemsize == 12:
m = fromstring('\x00\x00\x00\x00\x00\x00\x00\xa0\x01@\x00\x00',
dtype='float96')
elif dt.itemsize == 16:
m = fromstring('\x00\x00\x00\x00\x00\x00\x00\xa0\x01@\x00\x00' \
'\x00\x00\x00\x00', dtype='float128')
- elif dt.itemsize == 8:
- skip('longfloat is float64')
else:
- skip('unknown itemsize for longfloat')
+ assert False, 'unknown itemsize for longfloat'
assert m[0] == dtype('longfloat').type(5.)
def test_fromstring_invalid(self):
@@ -3040,7 +3061,13 @@
spaceconfig = dict(usemodules=["micronumpy", "struct", "binascii"])
def test_zeros(self):
- from numpypy import zeros
+ from numpypy import zeros, void
+ a = zeros((), dtype=[('x', int), ('y', float)])
+ assert type(a[()]) is void
+ assert type(a.item()) is tuple
+ assert a[()]['x'] == 0
+ assert a[()]['y'] == 0
+ assert a.shape == ()
a = zeros(2, dtype=[('x', int), ('y', float)])
raises(IndexError, 'a[0]["xyz"]')
assert a[0]['x'] == 0
@@ -3055,7 +3082,12 @@
assert a[1]['y'] == 2
def test_views(self):
- from numpypy import array
+ from numpypy import array, zeros, ndarray
+ a = zeros((), dtype=[('x', int), ('y', float)])
+ raises(IndexError, 'a[0]')
+ assert type(a['x']) is ndarray
+ assert a['x'] == 0
+ assert a['y'] == 0
a = array([(1, 2), (3, 4)], dtype=[('x', int), ('y', float)])
raises((IndexError, ValueError), 'array([1])["x"]')
raises((IndexError, ValueError), 'a["z"]')
@@ -3076,14 +3108,44 @@
def test_creation_and_repr(self):
from numpypy import array
+ a = array((1, 2), dtype=[('x', int), ('y', float)])
+ assert a.shape == ()
+ assert repr(a[()]) == '(1, 2.0)'
a = array([(1, 2), (3, 4)], dtype=[('x', int), ('y', float)])
assert repr(a[0]) == '(1, 2.0)'
+ def test_void_copyswap(self):
+ import numpy as np
+ dt = np.dtype([('one', '<i4'), ('two', '<i4')])
+ x = np.array((1, 2), dtype=dt)
+ x = x.byteswap()
+ import sys
+ if '__pypy__' not in sys.builtin_module_names:
+ assert x['one'] > 0 and x['two'] > 2
+ else:
+ assert x['one'] == 1 and x['two'] == 2
+
def test_nested_dtype(self):
- from numpypy import zeros
+ import numpy as np
a = [('x', int), ('y', float)]
b = [('x', int), ('y', a)]
- arr = zeros(3, dtype=b)
+ arr = np.zeros((), dtype=b)
+ assert arr['x'] == 0
+ arr['x'] = 2
+ assert arr['x'] == 2
+ exc = raises(IndexError, "arr[3L]")
+ assert exc.value.message == "0-d arrays can't be indexed"
+ exc = raises(ValueError, "arr['xx'] = 2")
+ assert exc.value.message == "field named xx not found"
+ assert arr['y'].dtype == a
+ assert arr['y'].shape == ()
+ assert arr['y'][()]['x'] == 0
+ assert arr['y'][()]['y'] == 0
+ arr['y'][()]['x'] = 2
+ arr['y'][()]['y'] = 3
+ assert arr['y'][()]['x'] == 2
+ assert arr['y'][()]['y'] == 3
+ arr = np.zeros(3, dtype=b)
arr[1]['x'] = 15
assert arr[1]['x'] == 15
arr[1]['y']['y'] = 3.5
@@ -3208,11 +3270,15 @@
def test_subarrays(self):
from numpypy import dtype, array, zeros
-
d = dtype([("x", "int", 3), ("y", "float", 5)])
+
+ a = zeros((), dtype=d)
+ #assert a['x'].dtype == int
+ #assert a['x'].shape == (3,)
+ #assert (a['x'] == [0, 0, 0]).all()
+
a = array([([1, 2, 3], [0.5, 1.5, 2.5, 3.5, 4.5]),
([4, 5, 6], [5.5, 6.5, 7.5, 8.5, 9.5])], dtype=d)
-
for v in ['x', u'x', 0, -2]:
assert (a[0][v] == [1, 2, 3]).all()
assert (a[1][v] == [4, 5, 6]).all()
@@ -3230,6 +3296,13 @@
a[0]["x"][0] = 200
assert a[0]["x"][0] == 200
+ a[1]["x"][2] = 123
+ assert (a[1]["x"] == [4, 5, 123]).all()
+ a[1]['y'][3] = 4
+ assert a[1]['y'][3] == 4
+ assert a['y'][1][3] == 4
+ a['y'][1][4] = 5
+ assert a[1]['y'][4] == 5
d = dtype([("x", "int64", (2, 3))])
a = array([([[1, 2, 3], [4, 5, 6]],)], dtype=d)
@@ -3303,14 +3376,16 @@
a = array([('aaaa', 1.0, 8.0, [[[1, 2, 3], [4, 5, 6]],
[[7, 8, 9], [10, 11, 12]]])],
dtype=dt)
- s = str(a)
i = a.item()
assert isinstance(i, tuple)
assert len(i) == 4
- skip('incorrect formatting via dump_data')
- assert s.endswith("[('aaaa', 1.0, 8.0, [[[1, 2, 3], [4, 5, 6]], "
- "[[7, 8, 9], [10, 11, 12]]])]")
-
+ import sys
+ if '__pypy__' not in sys.builtin_module_names:
+ assert str(a) == "[('aaaa', 1.0, 8.0, [[[1, 2, 3], [4, 5, 6]], " \
+ "[[7, 8, 9], [10, 11, 12]]])]"
+ else:
+ assert str(a) == "array([('aaaa', 1.0, 8.0, [1, 2, 3, 4, 5, 6, " \
+ "7, 8, 9, 10, 11, 12])])"
def test_issue_1589(self):
import numpypy as numpy
@@ -3323,6 +3398,7 @@
a = np.array([1,2,3], dtype='int16')
assert (a * 2).dtype == np.dtype('int16')
+
class AppTestPyPy(BaseNumpyAppTest):
def setup_class(cls):
if option.runappdirect and '__pypy__' not in sys.builtin_module_names:
diff --git a/pypy/module/micronumpy/test/test_scalar.py b/pypy/module/micronumpy/test/test_scalar.py
--- a/pypy/module/micronumpy/test/test_scalar.py
+++ b/pypy/module/micronumpy/test/test_scalar.py
@@ -4,8 +4,9 @@
spaceconfig = dict(usemodules=["micronumpy", "binascii", "struct"])
def test_init(self):
- import numpypy as np
+ import numpy as np
import math
+ import sys
assert np.intp() == np.intp(0)
assert np.intp('123') == np.intp(123)
raises(TypeError, np.intp, None)
@@ -17,6 +18,9 @@
assert np.complex_() == np.complex_(0)
#raises(TypeError, np.complex_, '1+2j')
assert math.isnan(np.complex_(None))
+ for c in ['i', 'I', 'l', 'L', 'q', 'Q']:
+ assert np.dtype(c).type().dtype.char == c
+ assert np.dtype('L').type(sys.maxint + 42) == sys.maxint + 42
def test_builtin(self):
import numpy as np
@@ -37,7 +41,7 @@
assert len(np.string_('123')) == 3
def test_pickle(self):
- from numpypy import dtype, zeros
+ from numpy import dtype, zeros
try:
from numpy.core.multiarray import scalar
except ImportError:
@@ -111,8 +115,17 @@
assert a.squeeze() is a
raises(TypeError, a.squeeze, 2)
+ def test_bitshift(self):
+ import numpy as np
+ assert np.int32(123) >> 1 == 61
+ assert type(np.int32(123) >> 1) is np.int_
+ assert np.int64(123) << 1 == 246
+ assert type(np.int64(123) << 1) is np.int64
+ exc = raises(TypeError, "np.uint64(123) >> 1")
+ assert 'not supported for the input types' in exc.value.message
+
def test_attributes(self):
- import numpypy as np
+ import numpy as np
value = np.dtype('int64').type(12345)
assert value.dtype == np.dtype('int64')
assert value.size == 1
diff --git a/pypy/module/micronumpy/test/test_sorting.py b/pypy/module/micronumpy/test/test_sorting.py
--- a/pypy/module/micronumpy/test/test_sorting.py
+++ b/pypy/module/micronumpy/test/test_sorting.py
@@ -45,6 +45,9 @@
def test_argsort_axis(self):
from numpypy import array
+ a = array([])
+ for axis in [None, -1, 0]:
+ assert a.argsort(axis=axis).shape == (0,)
a = array([[4, 2], [1, 3]])
assert (a.argsort(axis=None) == [2, 1, 3, 0]).all()
assert (a.argsort(axis=-1) == [[1, 0], [0, 1]]).all()
@@ -306,9 +309,8 @@
# tests from numpy/core/tests/test_regression.py
def test_sort_bigendian(self):
- skip('not implemented yet')
- from numpypy import array, dtype
- a = array(range(11),dtype='float64')
+ from numpy import array, dtype
+ a = array(range(11), dtype='float64')
c = a.astype(dtype('<f8'))
c.sort()
assert max(abs(a-c)) < 1e-32
diff --git a/pypy/module/micronumpy/test/test_subtype.py b/pypy/module/micronumpy/test/test_subtype.py
--- a/pypy/module/micronumpy/test/test_subtype.py
+++ b/pypy/module/micronumpy/test/test_subtype.py
@@ -75,6 +75,11 @@
b = matrix(a)
assert isinstance(b, matrix)
assert (b == a).all()
+ a = array(5)[()]
+ for s in [matrix, ndarray]:
+ b = a.view(s)
+ assert b == a
+ assert type(b) is type(a)
def test_subtype_like_matrix(self):
import numpy as np
diff --git a/pypy/module/micronumpy/test/test_ufuncs.py b/pypy/module/micronumpy/test/test_ufuncs.py
--- a/pypy/module/micronumpy/test/test_ufuncs.py
+++ b/pypy/module/micronumpy/test/test_ufuncs.py
@@ -82,6 +82,7 @@
assert isinstance(add, ufunc)
assert repr(add) == "<ufunc 'add'>"
assert repr(ufunc) == "<type 'numpy.ufunc'>"
+ assert add.__name__ == 'add'
def test_ufunc_attrs(self):
from numpypy import add, multiply, sin
@@ -390,23 +391,17 @@
assert (a == ref).all()
def test_signbit(self):
- from numpypy import signbit, add
-
+ from numpy import signbit, add, copysign, nan
+ assert signbit(add.identity) == False
assert (signbit([0, 0.0, 1, 1.0, float('inf')]) ==
- [False, False, False, False, False]).all()
+ [False, False, False, False, False]).all()
assert (signbit([-0, -0.0, -1, -1.0, float('-inf')]) ==
- [False, True, True, True, True]).all()
-
- a = add.identity
- assert signbit(a) == False
-
- skip('sign of nan is non-determinant')
- assert (signbit([float('nan'), float('-nan'), -float('nan')]) ==
- [False, True, True]).all()
+ [False, True, True, True, True]).all()
+ assert (signbit([copysign(nan, 1), copysign(nan, -1)]) ==
+ [False, True]).all()
def test_reciprocal(self):
- from numpypy import array, reciprocal
-
+ from numpy import array, reciprocal
inf = float('inf')
nan = float('nan')
reference = [-0.2, inf, -inf, 2.0, nan]
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
@@ -12,7 +12,7 @@
from rpython.rlib.rawstorage import (alloc_raw_storage, raw_storage_setitem,
raw_storage_getitem)
from rpython.rlib.objectmodel import specialize
-from rpython.rlib.rarithmetic import widen, byteswap, r_ulonglong, most_neg_value_of
+from rpython.rlib.rarithmetic import widen, byteswap, r_ulonglong, most_neg_value_of, LONG_BIT
from rpython.rtyper.lltypesystem import lltype, rffi
from rpython.rlib.rstruct.runpack import runpack
from rpython.rlib.rstruct.nativefmttable import native_is_bigendian
@@ -568,16 +568,6 @@
BoxType = interp_boxes.W_UInt32Box
format_code = "I"
-class Long(BaseType, Integer):
- T = rffi.LONG
- BoxType = interp_boxes.W_LongBox
- format_code = "l"
-
-class ULong(BaseType, Integer):
- T = rffi.ULONG
- BoxType = interp_boxes.W_ULongBox
- format_code = "L"
-
def _int64_coerce(self, space, w_item):
try:
return self._base_coerce(space, w_item)
@@ -618,6 +608,22 @@
_coerce = func_with_new_name(_uint64_coerce, '_coerce')
+class Long(BaseType, Integer):
+ T = rffi.LONG
+ BoxType = interp_boxes.W_LongBox
+ format_code = "l"
+
+ if LONG_BIT == 64:
+ _coerce = func_with_new_name(_int64_coerce, '_coerce')
+
+class ULong(BaseType, Integer):
+ T = rffi.ULONG
+ BoxType = interp_boxes.W_ULongBox
+ format_code = "L"
+
+ if LONG_BIT == 64:
+ _coerce = func_with_new_name(_uint64_coerce, '_coerce')
+
class Float(Primitive):
_mixin_ = True
@@ -1620,6 +1626,8 @@
from pypy.module.micronumpy.interp_dtype import new_string_dtype
if isinstance(w_item, interp_boxes.W_StringBox):
return w_item
+ if w_item is None:
+ w_item = space.wrap('')
arg = space.str_w(space.str(w_item))
arr = VoidBoxStorage(len(arg), new_string_dtype(space, len(arg)))
for i in range(len(arg)):
@@ -1733,13 +1741,16 @@
def _coerce(self, space, arr, ofs, dtype, w_items, shape):
# TODO: Make sure the shape and the array match
from interp_dtype import W_Dtype
- items_w = space.fixedview(w_items)
+ if w_items is not None:
+ items_w = space.fixedview(w_items)
+ else:
+ items_w = [None] * shape[0]
subdtype = dtype.subdtype
assert isinstance(subdtype, W_Dtype)
itemtype = subdtype.itemtype
if len(shape) <= 1:
for i in range(len(items_w)):
- w_box = itemtype.coerce(space, dtype.subdtype, items_w[i])
+ w_box = itemtype.coerce(space, subdtype, items_w[i])
itemtype.store(arr, 0, ofs, w_box)
ofs += itemtype.get_element_size()
else:
@@ -1758,7 +1769,9 @@
@jit.unroll_safe
def store(self, arr, i, ofs, box):
+ assert i == 0
assert isinstance(box, interp_boxes.W_VoidBox)
+ assert box.dtype is box.arr.dtype
for k in range(box.arr.dtype.get_size()):
arr.storage[k + ofs] = box.arr.storage[k + box.ofs]
@@ -1819,29 +1832,35 @@
def coerce(self, space, dtype, w_item):
if isinstance(w_item, interp_boxes.W_VoidBox):
return w_item
- # we treat every sequence as sequence, no special support
- # for arrays
- if not space.issequence_w(w_item):
- raise OperationError(space.w_TypeError, space.wrap(
- "expected sequence"))
- if len(dtype.fields) != space.len_w(w_item):
- raise OperationError(space.w_ValueError, space.wrap(
- "wrong length"))
- items_w = space.fixedview(w_item)
+ if w_item is not None:
+ # we treat every sequence as sequence, no special support
+ # for arrays
+ if not space.issequence_w(w_item):
+ raise OperationError(space.w_TypeError, space.wrap(
+ "expected sequence"))
+ if len(dtype.fields) != space.len_w(w_item):
+ raise OperationError(space.w_ValueError, space.wrap(
+ "wrong length"))
+ items_w = space.fixedview(w_item)
+ else:
+ items_w = [None] * len(dtype.fields)
arr = VoidBoxStorage(dtype.get_size(), dtype)
for i in range(len(items_w)):
ofs, subdtype = dtype.fields[dtype.fieldnames[i]]
itemtype = subdtype.itemtype
- w_item = items_w[i]
- w_box = itemtype.coerce(space, subdtype, w_item)
+ w_box = itemtype.coerce(space, subdtype, items_w[i])
itemtype.store(arr, 0, ofs, w_box)
return interp_boxes.W_VoidBox(arr, 0, dtype)
@jit.unroll_safe
def store(self, arr, i, ofs, box):
assert isinstance(box, interp_boxes.W_VoidBox)
- for k in range(box.arr.dtype.get_size()):
- arr.storage[k + i] = box.arr.storage[k + box.ofs]
+ for k in range(box.dtype.get_size()):
+ arr.storage[k + i + ofs] = box.arr.storage[k + box.ofs]
+
+ def byteswap(self, w_v):
+ # XXX implement
+ return w_v
def to_builtin_type(self, space, box):
assert isinstance(box, interp_boxes.W_VoidBox)
diff --git a/pypy/objspace/descroperation.py b/pypy/objspace/descroperation.py
--- a/pypy/objspace/descroperation.py
+++ b/pypy/objspace/descroperation.py
@@ -50,6 +50,13 @@
return w_iter
list_iter._annspecialcase_ = 'specialize:memo'
+def tuple_iter(space):
+ "Utility that returns the app-level descriptor tuple.__iter__."
+ w_src, w_iter = space.lookup_in_type_where(space.w_tuple,
+ '__iter__')
+ return w_iter
+tuple_iter._annspecialcase_ = 'specialize:memo'
+
def raiseattrerror(space, w_obj, w_name, w_descr=None):
# space.repr always returns an encodable string.
if w_descr is None:
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
@@ -921,7 +921,8 @@
def _extend_from_iterable(self, w_list, w_iterable):
space = self.space
- if isinstance(w_iterable, W_AbstractTupleObject):
+ if (isinstance(w_iterable, W_AbstractTupleObject)
+ and space._uses_tuple_iter(w_iterable)):
w_list.__init__(space, w_iterable.getitems_copy())
return
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
@@ -413,7 +413,7 @@
got, got != 1 and "s" or "")
def unpackiterable(self, w_obj, expected_length=-1):
- if isinstance(w_obj, W_AbstractTupleObject):
+ if isinstance(w_obj, W_AbstractTupleObject) and self._uses_tuple_iter(w_obj):
t = w_obj.getitems_copy()
elif type(w_obj) is W_ListObject:
t = w_obj.getitems_copy()
@@ -427,7 +427,7 @@
def fixedview(self, w_obj, expected_length=-1, unroll=False):
""" Fast paths
"""
- if isinstance(w_obj, W_AbstractTupleObject):
+ if isinstance(w_obj, W_AbstractTupleObject) and self._uses_tuple_iter(w_obj):
t = w_obj.tolist()
elif type(w_obj) is W_ListObject:
if unroll:
@@ -452,7 +452,7 @@
def listview(self, w_obj, expected_length=-1):
if type(w_obj) is W_ListObject:
t = w_obj.getitems()
- elif isinstance(w_obj, W_AbstractTupleObject):
+ elif isinstance(w_obj, W_AbstractTupleObject) and self._uses_tuple_iter(w_obj):
t = w_obj.getitems_copy()
elif isinstance(w_obj, W_ListObject) and self._uses_list_iter(w_obj):
t = w_obj.getitems()
@@ -487,7 +487,7 @@
return w_obj.listview_unicode()
if type(w_obj) is W_SetObject or type(w_obj) is W_FrozensetObject:
return w_obj.listview_unicode()
- if isinstance(w_obj, W_UnicodeObject):
+ if isinstance(w_obj, W_UnicodeObject) and self._uses_no_iter(w_obj):
return w_obj.listview_unicode()
if isinstance(w_obj, W_ListObject) and self._uses_list_iter(w_obj):
return w_obj.getitems_unicode()
@@ -522,6 +522,13 @@
from pypy.objspace.descroperation import list_iter
return self.lookup(w_obj, '__iter__') is list_iter(self)
+ def _uses_tuple_iter(self, w_obj):
+ from pypy.objspace.descroperation import tuple_iter
+ return self.lookup(w_obj, '__iter__') is tuple_iter(self)
+
+ def _uses_no_iter(self, w_obj):
+ return self.lookup(w_obj, '__iter__') is None
+
def sliceindices(self, w_slice, w_length):
if isinstance(w_slice, W_SliceObject):
a, b, c = w_slice.indices3(self, self.int_w(w_length))
diff --git a/pypy/objspace/std/test/test_listobject.py b/pypy/objspace/std/test/test_listobject.py
--- a/pypy/objspace/std/test/test_listobject.py
+++ b/pypy/objspace/std/test/test_listobject.py
@@ -1274,6 +1274,57 @@
non_list = NonList()
assert [] != non_list
+ def test_extend_from_empty_list_with_subclasses(self):
+ # some of these tests used to fail by ignoring the
+ # custom __iter__() --- but only if the list has so
+ # far the empty strategy, as opposed to .extend()ing
+ # a non-empty list.
+ class T(tuple):
+ def __iter__(self):
+ yield "ok"
+ assert list(T([5, 6])) == ["ok"]
+ #
+ class L(list):
+ def __iter__(self):
+ yield "ok"
+ assert list(L([5, 6])) == ["ok"]
+ assert list(L([5.2, 6.3])) == ["ok"]
+ #
+ class S(str):
+ def __iter__(self):
+ yield "ok"
+ assert list(S("don't see me")) == ["ok"]
+ #
+ class U(unicode):
+ def __iter__(self):
+ yield "ok"
+ assert list(U(u"don't see me")) == ["ok"]
+
+ def test_extend_from_nonempty_list_with_subclasses(self):
+ l = ["hi!"]
+ class T(tuple):
+ def __iter__(self):
+ yield "okT"
+ l.extend(T([5, 6]))
+ #
+ class L(list):
+ def __iter__(self):
+ yield "okL"
+ l.extend(L([5, 6]))
+ l.extend(L([5.2, 6.3]))
+ #
+ class S(str):
+ def __iter__(self):
+ yield "okS"
+ l.extend(S("don't see me"))
+ #
+ class U(unicode):
+ def __iter__(self):
+ yield "okU"
+ l.extend(U(u"don't see me"))
+ #
+ assert l == ["hi!", "okT", "okL", "okL", "okS", "okU"]
+
def test_issue1266(self):
l = list(range(1))
l.pop()
@@ -1304,6 +1355,94 @@
assert item11 in l[::11]
+class AppTestForRangeLists(AppTestW_ListObject):
+ spaceconfig = {"objspace.std.withrangelist": True}
+
+ def test_range_simple_backwards(self):
+ x = range(5,1)
+ assert x == []
+
+ def test_range_big_start(self):
+ x = range(1,10)
+ x[22:0:-1] == range(1,10)
+
+ def test_range_list_invalid_slice(self):
+ x = [1,2,3,4]
+ assert x[10:0] == []
+ assert x[10:0:None] == []
+
+ x = range(1,5)
+ assert x[10:0] == []
+ assert x[10:0:None] == []
+
+ assert x[0:22] == [1,2,3,4]
+ assert x[-1:10] == [4]
+
+ assert x[0:22:None] == [1,2,3,4]
+ assert x[-1:10:None] == [4]
+
+ def test_range_backwards(self):
+ x = range(1,10)
+ assert x[22:-10] == []
+ assert x[22:-10:-1] == [9,8,7,6,5,4,3,2,1]
+ assert x[10:3:-1] == [9,8,7,6,5]
+ assert x[10:3:-2] == [9,7,5]
+ assert x[1:5:-1] == []
+
+ def test_sort_range(self):
+ l = range(3,10,3)
+ l.sort()
+ assert l == [3, 6, 9]
+ l.sort(reverse = True)
+ assert l == [9, 6, 3]
+ l.sort(reverse = True)
+ assert l == [9, 6, 3]
+ l.sort()
+ assert l == [3, 6, 9]
+
+ def test_slice(self):
+ l = []
+ l2 = range(3)
+ l.__setslice__(0,3,l2)
+ assert l == [0,1,2]
+
+ def test_getitem(self):
+ l = range(5)
+ raises(IndexError, "l[-10]")
+
+ def test_append(self):
+ l = range(5)
+ l.append(26)
+ assert l == [0,1,2,3,4,26]
+
+ l = range(5)
+ l.append("a")
+ assert l == [0,1,2,3,4,"a"]
+
+ l = range(5)
+ l.append(5)
+ assert l == [0,1,2,3,4,5]
+
+ def test_pop(self):
+ l = range(3)
+ assert l.pop(0) == 0
+
+ def test_setitem(self):
+ l = range(3)
+ l[0] = 1
+ assert l == [1,1,2]
+
+ def test_inset(self):
+ l = range(3)
+ l.insert(1,5)
+ assert l == [0,5,1,2]
+
+ def test_reverse(self):
+ l = range(3)
+ l.reverse()
+ assert l == [2,1,0]
+
+
class AppTestWithoutStrategies(object):
spaceconfig = {"objspace.std.withliststrategies": False}
diff --git a/rpython/annotator/binaryop.py b/rpython/annotator/binaryop.py
--- a/rpython/annotator/binaryop.py
+++ b/rpython/annotator/binaryop.py
@@ -412,10 +412,7 @@
return SomeByteArray(can_be_None=can_be_None)
def add((b1, b2)):
- result = SomeByteArray()
- if b1.is_immutable_constant() and b2.is_immutable_constant():
- result.const = b1.const + b2.const
- return result
+ return SomeByteArray()
class __extend__(pairtype(SomeByteArray, SomeInteger)):
def getitem((s_b, s_i)):
@@ -429,10 +426,7 @@
pairtype(SomeChar, SomeByteArray),
pairtype(SomeByteArray, SomeChar)):
def add((b1, b2)):
- result = SomeByteArray()
- if b1.is_immutable_constant() and b2.is_immutable_constant():
- result.const = b1.const + b2.const
- return result
+ return SomeByteArray()
class __extend__(pairtype(SomeChar, SomeChar)):
diff --git a/rpython/annotator/builtin.py b/rpython/annotator/builtin.py
--- a/rpython/annotator/builtin.py
+++ b/rpython/annotator/builtin.py
@@ -122,7 +122,7 @@
return constpropagate(unicode, [s_unicode], SomeUnicodeString())
def builtin_bytearray(s_str):
- return constpropagate(bytearray, [s_str], SomeByteArray())
+ return SomeByteArray()
def our_issubclass(cls1, cls2):
""" we're going to try to be less silly in the face of old-style classes"""
diff --git a/rpython/annotator/model.py b/rpython/annotator/model.py
--- a/rpython/annotator/model.py
+++ b/rpython/annotator/model.py
@@ -215,7 +215,8 @@
class SomeStringOrUnicode(SomeObject):
- """Base class for shared implementation of SomeString and SomeUnicodeString.
+ """Base class for shared implementation of SomeString,
+ SomeUnicodeString and SomeByteArray.
Cannot be an annotation."""
@@ -228,6 +229,7 @@
if can_be_None:
self.can_be_None = True
if no_nul:
+ assert self.immutable #'no_nul' cannot be used with SomeByteArray
self.no_nul = True
def can_be_none(self):
@@ -263,6 +265,7 @@
class SomeByteArray(SomeStringOrUnicode):
+ immutable = False
knowntype = bytearray
diff --git a/rpython/annotator/test/test_annrpython.py b/rpython/annotator/test/test_annrpython.py
--- a/rpython/annotator/test/test_annrpython.py
+++ b/rpython/annotator/test/test_annrpython.py
@@ -3987,7 +3987,9 @@
return bytearray("xyz")
a = self.RPythonAnnotator()
- assert isinstance(a.build_types(f, []), annmodel.SomeByteArray)
+ s = a.build_types(f, [])
+ assert isinstance(s, annmodel.SomeByteArray)
+ assert not s.is_constant() # never a constant!
def test_bytearray_add(self):
def f(a):
diff --git a/rpython/jit/backend/llgraph/runner.py b/rpython/jit/backend/llgraph/runner.py
--- a/rpython/jit/backend/llgraph/runner.py
+++ b/rpython/jit/backend/llgraph/runner.py
@@ -125,10 +125,12 @@
class ArrayDescr(AbstractDescr):
def __init__(self, A):
- self.A = A
+ self.A = self.OUTERA = A
+ if isinstance(A, lltype.Struct):
+ self.A = A._flds[A._arrayfld]
def __repr__(self):
- return 'ArrayDescr(%r)' % (self.A,)
+ return 'ArrayDescr(%r)' % (self.OUTERA,)
def is_array_of_pointers(self):
return getkind(self.A.OF) == 'ref'
@@ -424,6 +426,8 @@
def bh_arraylen_gc(self, a, descr):
array = a._obj.container
+ if descr.A is not descr.OUTERA:
+ array = getattr(array, descr.OUTERA._arrayfld)
return array.getlength()
def bh_getarrayitem_gc(self, a, index, descr):
diff --git a/rpython/jit/backend/llsupport/test/test_descr.py b/rpython/jit/backend/llsupport/test/test_descr.py
--- a/rpython/jit/backend/llsupport/test/test_descr.py
+++ b/rpython/jit/backend/llsupport/test/test_descr.py
@@ -424,3 +424,11 @@
" <Array of Char > > >")
# caching:
assert fielddescr is get_field_arraylen_descr(c0, rstr.STR)
+
+def test_bytearray_descr():
+ c0 = GcCache(False)
+ descr = get_array_descr(c0, rstr.STR) # for bytearray
+ assert descr.flag == FLAG_UNSIGNED
+ assert descr.basesize == struct.calcsize("PP") # hash, length
+ assert descr.lendescr.offset == struct.calcsize("P") # hash
+ assert not descr.is_array_of_pointers()
diff --git a/rpython/jit/codewriter/jtransform.py b/rpython/jit/codewriter/jtransform.py
--- a/rpython/jit/codewriter/jtransform.py
+++ b/rpython/jit/codewriter/jtransform.py
@@ -13,6 +13,7 @@
from rpython.rlib.jit import _we_are_jitted
from rpython.rlib.rgc import lltype_is_gc
from rpython.rtyper.lltypesystem import lltype, llmemory, rstr, rclass, rffi
+from rpython.rtyper.lltypesystem import rbytearray
from rpython.rtyper.rclass import IR_QUASIIMMUTABLE, IR_QUASIIMMUTABLE_ARRAY
from rpython.translator.unsimplify import varoftype
@@ -643,6 +644,12 @@
return SpaceOperation('arraylen_gc', [op.args[0], arraydescr],
op.result)
+ def rewrite_op_getarraysubstruct(self, op):
+ ARRAY = op.args[0].concretetype.TO
+ assert ARRAY._gckind == 'raw'
+ assert ARRAY._hints.get('nolength') is True
+ return self.rewrite_op_direct_ptradd(op)
+
def _array_of_voids(self, ARRAY):
return ARRAY.OF == lltype.Void
@@ -836,9 +843,14 @@
optype = op.args[0].concretetype
if optype == lltype.Ptr(rstr.STR):
opname = "strlen"
+ elif optype == lltype.Ptr(rstr.UNICODE):
+ opname = "unicodelen"
+ elif optype == lltype.Ptr(rbytearray.BYTEARRAY):
+ bytearraydescr = self.cpu.arraydescrof(rbytearray.BYTEARRAY)
+ return SpaceOperation('arraylen_gc', [op.args[0], bytearraydescr],
+ op.result)
else:
- assert optype == lltype.Ptr(rstr.UNICODE)
- opname = "unicodelen"
+ assert 0, "supported type %r" % (optype,)
return SpaceOperation(opname, [op.args[0]], op.result)
def rewrite_op_getinteriorfield(self, op):
@@ -850,6 +862,12 @@
elif optype == lltype.Ptr(rstr.UNICODE):
opname = "unicodegetitem"
return SpaceOperation(opname, [op.args[0], op.args[2]], op.result)
+ elif optype == lltype.Ptr(rbytearray.BYTEARRAY):
+ bytearraydescr = self.cpu.arraydescrof(rbytearray.BYTEARRAY)
+ v_index = op.args[2]
+ return SpaceOperation('getarrayitem_gc_i',
+ [op.args[0], v_index, bytearraydescr],
+ op.result)
else:
v_inst, v_index, c_field = op.args
if op.result.concretetype is lltype.Void:
@@ -876,6 +894,11 @@
opname = "unicodesetitem"
return SpaceOperation(opname, [op.args[0], op.args[2], op.args[3]],
op.result)
+ elif optype == lltype.Ptr(rbytearray.BYTEARRAY):
+ bytearraydescr = self.cpu.arraydescrof(rbytearray.BYTEARRAY)
+ opname = "setarrayitem_gc_i"
+ return SpaceOperation(opname, [op.args[0], op.args[2], op.args[3],
+ bytearraydescr], op.result)
else:
v_inst, v_index, c_field, v_value = op.args
if v_value.concretetype is lltype.Void:
@@ -1709,6 +1732,8 @@
"stroruni.copy_string_to_raw": EffectInfo.OS_UNI_COPY_TO_RAW
}
CHR = lltype.UniChar
+ elif SoU.TO == rbytearray.BYTEARRAY:
+ raise NotSupported("bytearray operation")
else:
assert 0, "args[0].concretetype must be STR or UNICODE"
#
diff --git a/rpython/jit/codewriter/support.py b/rpython/jit/codewriter/support.py
--- a/rpython/jit/codewriter/support.py
+++ b/rpython/jit/codewriter/support.py
@@ -14,6 +14,7 @@
from rpython.rtyper.extregistry import ExtRegistryEntry
from rpython.rtyper.llinterp import LLInterpreter
from rpython.rtyper.lltypesystem import lltype, rclass, rffi, llmemory, rstr as ll_rstr, rdict as ll_rdict
+from rpython.rtyper.lltypesystem import rordereddict
from rpython.rtyper.lltypesystem.lloperation import llop
from rpython.rtyper.lltypesystem.module import ll_math
from rpython.translator.translator import TranslationContext
@@ -492,11 +493,6 @@
# ---------- dict ----------
- def _ll_0_newdict(DICT):
- return ll_rdict.ll_newdict(DICT)
- _ll_0_newdict.need_result_type = True
-
- _ll_2_dict_delitem = ll_rdict.ll_dict_delitem
_ll_1_dict_copy = ll_rdict.ll_copy
_ll_1_dict_clear = ll_rdict.ll_clear
_ll_2_dict_update = ll_rdict.ll_update
@@ -524,6 +520,33 @@
_ll_1_dict_resize = ll_rdict.ll_dict_resize
+ # ---------- ordered dict ----------
+
+ _ll_1_odict_copy = rordereddict.ll_dict_copy
+ _ll_1_odict_clear = rordereddict.ll_dict_clear
+ _ll_2_odict_update = rordereddict.ll_dict_update
+
+ _ll_1_odict_keys = rordereddict.ll_dict_keys
+ _ll_1_odict_values = rordereddict.ll_dict_values
+ _ll_1_odict_items = rordereddict.ll_dict_items
+ _ll_1_odict_keys .need_result_type = True
+ _ll_1_odict_values.need_result_type = True
+ _ll_1_odict_items .need_result_type = True
+
+ _odictnext_keys = staticmethod(rordereddict.ll_dictnext_group['keys'])
+ _odictnext_values = staticmethod(rordereddict.ll_dictnext_group['values'])
+ _odictnext_items = staticmethod(rordereddict.ll_dictnext_group['items'])
+
+ def _ll_1_odictiter_nextkeys(iter):
+ return LLtypeHelpers._odictnext_keys(None, iter)
+ def _ll_1_odictiter_nextvalues(iter):
+ return LLtypeHelpers._odictnext_values(None, iter)
+ def _ll_1_odictiter_nextitems(RES, iter):
+ return LLtypeHelpers._odictnext_items(lltype.Ptr(RES), iter)
+ _ll_1_odictiter_nextitems.need_result_type = True
+
+ _ll_1_odict_resize = rordereddict.ll_dict_resize
+
# ---------- strings and unicode ----------
_ll_1_str_str2unicode = ll_rstr.LLHelpers.ll_str2unicode
diff --git a/rpython/jit/metainterp/test/test_bytearray.py b/rpython/jit/metainterp/test/test_bytearray.py
new file mode 100644
--- /dev/null
+++ b/rpython/jit/metainterp/test/test_bytearray.py
@@ -0,0 +1,82 @@
+import py
+from rpython.jit.metainterp.test.support import LLJitMixin
+from rpython.rlib.jit import JitDriver, dont_look_inside
+
+class TestByteArray(LLJitMixin):
+
+ def test_getitem(self):
+ x = bytearray("foobar")
+ def fn(n):
+ assert n >= 0
+ return x[n]
+ res = self.interp_operations(fn, [3])
+ assert res == ord('b')
+
+ def test_getitem_negative(self):
+ x = bytearray("foobar")
+ def fn(n):
+ return x[n]
+ res = self.interp_operations(fn, [-2])
+ assert res == ord('a')
+
+ def test_len(self):
+ x = bytearray("foobar")
+ def fn(n):
+ return len(x)
+ res = self.interp_operations(fn, [3])
+ assert res == 6
+
+ def test_setitem(self):
+ @dont_look_inside
+ def make_me():
+ return bytearray("foobar")
+ def fn(n):
+ assert n >= 0
+ x = make_me()
+ x[n] = 3
+ return x[3] + 1000 * x[4]
+
+ res = self.interp_operations(fn, [3])
+ assert res == 3 + 1000 * ord('a')
+
+ def test_setitem_negative(self):
+ @dont_look_inside
+ def make_me():
+ return bytearray("foobar")
+ def fn(n):
+ x = make_me()
+ x[n] = 3
+ return x[3] + 1000 * x[4]
+
+ res = self.interp_operations(fn, [-2])
+ assert res == ord('b') + 1000 * 3
+
+ def test_new_bytearray(self):
+ def fn(n, m):
+ x = bytearray(str(n))
+ x[m] = 0x34
+ return int(str(x))
+
More information about the pypy-commit
mailing list