[pypy-commit] pypy numppy-flatitter: merge with default
mattip
noreply at buildbot.pypy.org
Thu Jan 26 22:47:13 CET 2012
Author: mattip
Branch: numppy-flatitter
Changeset: r51827:4bd2c28ea1e4
Date: 2012-01-19 07:50 +0200
http://bitbucket.org/pypy/pypy/changeset/4bd2c28ea1e4/
Log: merge with default
diff --git a/pypy/bin/py.py b/pypy/bin/py.py
--- a/pypy/bin/py.py
+++ b/pypy/bin/py.py
@@ -76,6 +76,8 @@
config.objspace.suggest(allworkingmodules=False)
if config.objspace.allworkingmodules:
pypyoption.enable_allworkingmodules(config)
+ if config.objspace.usemodules._continuation:
+ config.translation.continuation = True
if config.objspace.usemodules.thread:
config.translation.thread = True
diff --git a/pypy/doc/getting-started.rst b/pypy/doc/getting-started.rst
--- a/pypy/doc/getting-started.rst
+++ b/pypy/doc/getting-started.rst
@@ -53,11 +53,11 @@
PyPy is ready to be executed as soon as you unpack the tarball or the zip
file, with no need to install it in any specific location::
- $ tar xf pypy-1.6-linux.tar.bz2
+ $ tar xf pypy-1.7-linux.tar.bz2
- $ ./pypy-1.6/bin/pypy
+ $ ./pypy-1.7/bin/pypy
Python 2.7.1 (?, Apr 27 2011, 12:44:21)
- [PyPy 1.6.0 with GCC 4.4.3] on linux2
+ [PyPy 1.7.0 with GCC 4.4.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
And now for something completely different: ``implementing LOGO in LOGO:
"turtles all the way down"''
@@ -75,14 +75,14 @@
$ curl -O https://raw.github.com/pypa/pip/master/contrib/get-pip.py
- $ ./pypy-1.6/bin/pypy distribute_setup.py
+ $ ./pypy-1.7/bin/pypy distribute_setup.py
- $ ./pypy-1.6/bin/pypy get-pip.py
+ $ ./pypy-1.7/bin/pypy get-pip.py
- $ ./pypy-1.6/bin/pip install pygments # for example
+ $ ./pypy-1.7/bin/pip install pygments # for example
-3rd party libraries will be installed in ``pypy-1.6/site-packages``, and
-the scripts in ``pypy-1.6/bin``.
+3rd party libraries will be installed in ``pypy-1.7/site-packages``, and
+the scripts in ``pypy-1.7/bin``.
Installing using virtualenv
---------------------------
diff --git a/pypy/module/_io/interp_fileio.py b/pypy/module/_io/interp_fileio.py
--- a/pypy/module/_io/interp_fileio.py
+++ b/pypy/module/_io/interp_fileio.py
@@ -349,6 +349,8 @@
try:
s = os.read(self.fd, size)
except OSError, e:
+ if e.errno == errno.EAGAIN:
+ return space.w_None
raise wrap_oserror(space, e,
exception_name='w_IOError')
@@ -362,6 +364,8 @@
try:
buf = os.read(self.fd, length)
except OSError, e:
+ if e.errno == errno.EAGAIN:
+ return space.w_None
raise wrap_oserror(space, e,
exception_name='w_IOError')
rwbuffer.setslice(0, buf)
diff --git a/pypy/module/_io/test/test_fileio.py b/pypy/module/_io/test/test_fileio.py
--- a/pypy/module/_io/test/test_fileio.py
+++ b/pypy/module/_io/test/test_fileio.py
@@ -133,6 +133,19 @@
f.close()
assert a == 'a\nbxxxxxxx'
+ def test_nonblocking_read(self):
+ import os, fcntl
+ r_fd, w_fd = os.pipe()
+ # set nonblocking
+ fcntl.fcntl(r_fd, fcntl.F_SETFL, os.O_NONBLOCK)
+ import _io
+ f = _io.FileIO(r_fd, 'r')
+ # Read from stream sould return None
+ assert f.read() is None
+ assert f.read(10) is None
+ a = bytearray('x' * 10)
+ assert f.readinto(a) is None
+
def test_repr(self):
import _io
f = _io.FileIO(self.tmpfile, 'r')
diff --git a/pypy/module/_socket/interp_socket.py b/pypy/module/_socket/interp_socket.py
--- a/pypy/module/_socket/interp_socket.py
+++ b/pypy/module/_socket/interp_socket.py
@@ -67,9 +67,6 @@
self.connect(self.addr_from_object(space, w_addr))
except SocketError, e:
raise converted_error(space, e)
- except TypeError, e:
- raise OperationError(space.w_TypeError,
- space.wrap(str(e)))
def connect_ex_w(self, space, w_addr):
"""connect_ex(address) -> errno
diff --git a/pypy/module/_socket/test/test_sock_app.py b/pypy/module/_socket/test/test_sock_app.py
--- a/pypy/module/_socket/test/test_sock_app.py
+++ b/pypy/module/_socket/test/test_sock_app.py
@@ -529,26 +529,31 @@
import _socket, os
if not hasattr(_socket, 'AF_UNIX'):
skip('AF_UNIX not supported.')
- sockpath = os.path.join(self.udir, 'app_test_unix_socket_connect')
+ oldcwd = os.getcwd()
+ os.chdir(self.udir)
+ try:
+ sockpath = 'app_test_unix_socket_connect'
- serversock = _socket.socket(_socket.AF_UNIX)
- serversock.bind(sockpath)
- serversock.listen(1)
+ serversock = _socket.socket(_socket.AF_UNIX)
+ serversock.bind(sockpath)
+ serversock.listen(1)
- clientsock = _socket.socket(_socket.AF_UNIX)
- clientsock.connect(sockpath)
- s, addr = serversock.accept()
- assert not addr
+ clientsock = _socket.socket(_socket.AF_UNIX)
+ clientsock.connect(sockpath)
+ s, addr = serversock.accept()
+ assert not addr
- s.send('X')
- data = clientsock.recv(100)
- assert data == 'X'
- clientsock.send('Y')
- data = s.recv(100)
- assert data == 'Y'
+ s.send('X')
+ data = clientsock.recv(100)
+ assert data == 'X'
+ clientsock.send('Y')
+ data = s.recv(100)
+ assert data == 'Y'
- clientsock.close()
- s.close()
+ clientsock.close()
+ s.close()
+ finally:
+ os.chdir(oldcwd)
class AppTestSocketTCP:
diff --git a/pypy/module/_ssl/test/test_ssl.py b/pypy/module/_ssl/test/test_ssl.py
--- a/pypy/module/_ssl/test/test_ssl.py
+++ b/pypy/module/_ssl/test/test_ssl.py
@@ -64,8 +64,8 @@
def test_sslwrap(self):
import _ssl, _socket, sys, gc
- if sys.platform == 'darwin':
- skip("hangs indefinitely on OSX (also on CPython)")
+ if sys.platform == 'darwin' or 'freebsd' in sys.platform:
+ skip("hangs indefinitely on OSX & FreeBSD (also on CPython)")
s = _socket.socket()
ss = _ssl.sslwrap(s, 0)
exc = raises(_socket.error, ss.do_handshake)
diff --git a/pypy/module/fcntl/test/test_fcntl.py b/pypy/module/fcntl/test/test_fcntl.py
--- a/pypy/module/fcntl/test/test_fcntl.py
+++ b/pypy/module/fcntl/test/test_fcntl.py
@@ -42,13 +42,9 @@
else:
start_len = "qq"
- if sys.platform in ('netbsd1', 'netbsd2', 'netbsd3',
- 'Darwin1.2', 'darwin',
- 'freebsd2', 'freebsd3', 'freebsd4', 'freebsd5',
- 'freebsd6', 'freebsd7', 'freebsd8', 'freebsd9',
- 'bsdos2', 'bsdos3', 'bsdos4',
- 'openbsd', 'openbsd2', 'openbsd3', 'openbsd4',
- 'openbsd5'):
+ if any(substring in sys.platform.lower()
+ for substring in ('netbsd', 'darwin', 'freebsd', 'bsdos',
+ 'openbsd')):
if struct.calcsize('l') == 8:
off_t = 'l'
pid_t = 'i'
@@ -182,7 +178,8 @@
def test_large_flag(self):
import sys
- if sys.platform == "darwin" or sys.platform.startswith("openbsd"):
+ if any(plat in sys.platform
+ for plat in ('darwin', 'openbsd', 'freebsd')):
skip("Mac OS doesn't have any large flag in fcntl.h")
import fcntl, sys
if sys.maxint == 2147483647:
diff --git a/pypy/module/micronumpy/__init__.py b/pypy/module/micronumpy/__init__.py
--- a/pypy/module/micronumpy/__init__.py
+++ b/pypy/module/micronumpy/__init__.py
@@ -27,6 +27,8 @@
'dot': 'interp_numarray.dot',
'fromstring': 'interp_support.fromstring',
'flatiter': 'interp_numarray.W_FlatIterator',
+ 'isna': 'interp_numarray.isna',
+ 'concatenate': 'interp_numarray.concatenate',
'True_': 'types.Bool.True',
'False_': 'types.Bool.False',
diff --git a/pypy/module/micronumpy/app_numpy.py b/pypy/module/micronumpy/app_numpy.py
--- a/pypy/module/micronumpy/app_numpy.py
+++ b/pypy/module/micronumpy/app_numpy.py
@@ -59,7 +59,7 @@
if not hasattr(a, "max"):
a = _numpypy.array(a)
return a.max(axis)
-
+
def arange(start, stop=None, step=1, dtype=None):
'''arange([start], stop[, step], dtype=None)
Generate values in the half-interval [start, stop).
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
@@ -9,6 +9,7 @@
MIXIN_64 = (int_typedef,) if LONG_BIT == 64 else ()
+MIXIN_32 = () if LONG_BIT == 64 else (int_typedef,)
def new_dtype_getter(name):
def get_dtype(space):
@@ -231,7 +232,7 @@
__new__ = interp2app(W_UInt16Box.descr__new__.im_func),
)
-W_Int32Box.typedef = TypeDef("int32", W_SignedIntegerBox.typedef,
+W_Int32Box.typedef = TypeDef("int32", (W_SignedIntegerBox.typedef,) + MIXIN_32,
__module__ = "numpypy",
__new__ = interp2app(W_Int32Box.descr__new__.im_func),
)
@@ -241,24 +242,18 @@
__new__ = interp2app(W_UInt32Box.descr__new__.im_func),
)
-if LONG_BIT == 32:
- long_name = "int32"
-elif LONG_BIT == 64:
- long_name = "int64"
-W_LongBox.typedef = TypeDef(long_name, (W_SignedIntegerBox.typedef, int_typedef,),
- __module__ = "numpypy",
- __new__ = interp2app(W_LongBox.descr__new__.im_func),
-)
-
-W_ULongBox.typedef = TypeDef("u" + long_name, W_UnsignedIntegerBox.typedef,
- __module__ = "numpypy",
-)
-
W_Int64Box.typedef = TypeDef("int64", (W_SignedIntegerBox.typedef,) + MIXIN_64,
__module__ = "numpypy",
__new__ = interp2app(W_Int64Box.descr__new__.im_func),
)
+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__ = "numpypy",
__new__ = interp2app(W_UInt64Box.descr__new__.im_func),
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
@@ -89,6 +89,19 @@
def descr_get_shape(self, space):
return space.newtuple([])
+ def eq(self, space, w_other):
+ if space.is_w(self, w_other):
+ return True
+ if space.isinstance_w(w_other, space.w_str):
+ return self.name == space.str_w(w_other)
+ return False
+
+ def descr_eq(self, space, w_other):
+ return space.wrap(self.eq(space, w_other))
+
+ def descr_ne(self, space, w_other):
+ return space.wrap(not self.eq(space, w_other))
+
def is_int_type(self):
return self.kind == SIGNEDLTR or self.kind == UNSIGNEDLTR
@@ -101,6 +114,8 @@
__str__= interp2app(W_Dtype.descr_str),
__repr__ = interp2app(W_Dtype.descr_repr),
+ __eq__ = interp2app(W_Dtype.descr_eq),
+ __ne__ = interp2app(W_Dtype.descr_ne),
num = interp_attrproperty("num", cls=W_Dtype),
kind = interp_attrproperty("kind", cls=W_Dtype),
diff --git a/pypy/module/micronumpy/interp_iter.py b/pypy/module/micronumpy/interp_iter.py
--- a/pypy/module/micronumpy/interp_iter.py
+++ b/pypy/module/micronumpy/interp_iter.py
@@ -17,6 +17,10 @@
if self.step != 0:
shape.append(self.lgt)
+ def __repr__(self):
+ return 'Chunk(%d, %d, %d, %d)' % (self.start, self.stop, self.step,
+ self.lgt)
+
class BaseTransform(object):
pass
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
@@ -1,6 +1,6 @@
from pypy.interpreter.baseobjspace import Wrappable
from pypy.interpreter.error import OperationError, operationerrfmt
-from pypy.interpreter.gateway import interp2app, NoneNotWrapped
+from pypy.interpreter.gateway import interp2app, NoneNotWrapped, unwrap_spec
from pypy.interpreter.typedef import TypeDef, GetSetProperty
from pypy.module.micronumpy import interp_ufuncs, interp_dtype, signature,\
interp_boxes
@@ -436,6 +436,13 @@
def copy(self, space):
return self.get_concrete().copy(space)
+ def empty_copy(self, space, dtype):
+ shape = self.shape
+ size = 1
+ for elem in shape:
+ size *= elem
+ return W_NDimArray(size, shape[:], dtype, 'C')
+
def flatten(self, space):
return self.get_concrete().flatten(space)
@@ -1334,6 +1341,42 @@
return convert_to_array(space, w_obj2).descr_dot(space, w_arr)
return w_arr.descr_dot(space, w_obj2)
+ at unwrap_spec(axis=int)
+def concatenate(space, w_args, axis=0):
+ args_w = space.listview(w_args)
+ if len(args_w) == 0:
+ raise OperationError(space.w_ValueError, space.wrap("concatenation of zero-length sequences is impossible"))
+ args_w = [convert_to_array(space, w_arg) for w_arg in args_w]
+ dtype = args_w[0].find_dtype()
+ shape = args_w[0].shape[:]
+ if len(shape) <= axis:
+ raise OperationError(space.w_ValueError,
+ space.wrap("bad axis argument"))
+ for arr in args_w[1:]:
+ dtype = interp_ufuncs.find_binop_result_dtype(space, dtype,
+ arr.find_dtype())
+ if len(arr.shape) <= axis:
+ raise OperationError(space.w_ValueError,
+ space.wrap("bad axis argument"))
+ for i, axis_size in enumerate(arr.shape):
+ if len(arr.shape) != len(shape) or (i != axis and axis_size != shape[i]):
+ raise OperationError(space.w_ValueError, space.wrap(
+ "array dimensions must agree except for axis being concatenated"))
+ elif i == axis:
+ shape[i] += axis_size
+ size = 1
+ for elem in shape:
+ size *= elem
+ res = W_NDimArray(size, shape, dtype, 'C')
+ chunks = [Chunk(0, i, 1, i) for i in shape]
+ axis_start = 0
+ for arr in args_w:
+ chunks[axis] = Chunk(axis_start, axis_start + arr.shape[axis], 1,
+ arr.shape[axis])
+ res.create_slice(chunks).setslice(space, arr)
+ axis_start += arr.shape[axis]
+ return res
+
BaseArray.typedef = TypeDef(
'ndarray',
__module__ = "numpypy",
@@ -1536,3 +1579,11 @@
)
W_FlatIterator.acceptable_as_base_class = False
+
+def isna(space, w_obj):
+ if isinstance(w_obj, BaseArray):
+ arr = w_obj.empty_copy(space,
+ interp_dtype.get_dtype_cache(space).w_booldtype)
+ arr.fill(space, space.wrap(False))
+ return arr
+ return space.wrap(False)
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
@@ -1,4 +1,5 @@
from pypy.rlib import jit
+from pypy.interpreter.error import OperationError
@jit.look_inside_iff(lambda shape, start, strides, backstrides, chunks:
@@ -37,3 +38,27 @@
rstrides = [0] * (len(res_shape) - len(orig_shape)) + rstrides
rbackstrides = [0] * (len(res_shape) - len(orig_shape)) + rbackstrides
return rstrides, rbackstrides
+
+def to_coords(space, shape, size, order, w_item_or_slice):
+ '''Returns a start coord, step, and length.
+ '''
+ start = lngth = step = 0
+ if not (space.isinstance_w(w_item_or_slice, space.w_int) or
+ space.isinstance_w(w_item_or_slice, space.w_slice)):
+ raise OperationError(space.w_IndexError,
+ space.wrap('unsupported iterator index'))
+
+ start, stop, step, lngth = space.decode_index4(w_item_or_slice, size)
+
+ coords = [0] * len(shape)
+ i = start
+ if order == 'C':
+ for s in range(len(shape) -1, -1, -1):
+ coords[s] = i % shape[s]
+ i //= shape[s]
+ else:
+ for s in range(len(shape)):
+ coords[s] = i % shape[s]
+ i //= shape[s]
+
+ return coords, step, lngth
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
@@ -9,6 +9,9 @@
assert d.num == 0
assert d.kind == 'b'
assert dtype('int8').num == 1
+ assert dtype('int8') == 'int8'
+ assert 'int8' == dtype('int8')
+ assert dtype('int8') != 3
assert dtype(d) is d
assert dtype(None) is dtype(float)
raises(TypeError, dtype, 1042)
@@ -376,3 +379,14 @@
b = X(10)
assert type(b) is X
assert b.m() == 12
+
+ def test_int(self):
+ import sys
+ from _numpypy import int32, int64, int_
+ assert issubclass(int_, int)
+ if sys.maxint == (1<<31) - 1:
+ assert issubclass(int32, int)
+ assert int_ is int32
+ else:
+ assert issubclass(int64, int)
+ assert int_ is int64
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
@@ -167,6 +167,24 @@
assert calc_new_strides([1, 1, 105, 1, 1], [7, 15], [1, 7],'F') == \
[1, 1, 1, 105, 105]
+ def test_to_coords(self):
+ from pypy.module.micronumpy.strides import to_coords
+
+ def _to_coords(index, order):
+ return to_coords(self.space, [2, 3, 4], 24, order,
+ self.space.wrap(index))[0]
+
+ assert _to_coords(0, 'C') == [0, 0, 0]
+ assert _to_coords(1, 'C') == [0, 0, 1]
+ assert _to_coords(-1, 'C') == [1, 2, 3]
+ assert _to_coords(5, 'C') == [0, 1, 1]
+ assert _to_coords(13, 'C') == [1, 0, 1]
+ assert _to_coords(0, 'F') == [0, 0, 0]
+ assert _to_coords(1, 'F') == [1, 0, 0]
+ assert _to_coords(-1, 'F') == [1, 2, 3]
+ assert _to_coords(5, 'F') == [1, 2, 0]
+ assert _to_coords(13, 'F') == [1, 0, 2]
+
class AppTestNumArray(BaseNumpyAppTest):
def test_ndarray(self):
@@ -1045,6 +1063,40 @@
#assert (a.var(0) == [8, 8]).all()
#assert (a.var(1) == [.25] * 5).all()
+ def test_concatenate(self):
+ from numpypy import array, concatenate, dtype
+ a1 = array([0,1,2])
+ a2 = array([3,4,5])
+ a = concatenate((a1, a2))
+ assert len(a) == 6
+ assert (a == [0,1,2,3,4,5]).all()
+ assert a.dtype is dtype(int)
+ b1 = array([[1, 2], [3, 4]])
+ b2 = array([[5, 6]])
+ b = concatenate((b1, b2), axis=0)
+ assert (b == [[1, 2],[3, 4],[5, 6]]).all()
+ c = concatenate((b1, b2.T), axis=1)
+ assert (c == [[1, 2, 5],[3, 4, 6]]).all()
+ d = concatenate(([0],[1]))
+ assert (d == [0,1]).all()
+ e1 = array([[0,1],[2,3]])
+ e = concatenate(e1)
+ assert (e == [0,1,2,3]).all()
+ f1 = array([0,1])
+ f = concatenate((f1, [2], f1, [7]))
+ assert (f == [0,1,2,0,1,7]).all()
+
+ bad_axis = raises(ValueError, concatenate, (a1,a2), axis=1)
+ assert str(bad_axis.value) == "bad axis argument"
+
+ concat_zero = raises(ValueError, concatenate, ())
+ assert str(concat_zero.value) == \
+ "concatenation of zero-length sequences is impossible"
+
+ dims_disagree = raises(ValueError, concatenate, (a1, b1), axis=0)
+ assert str(dims_disagree.value) == \
+ "array dimensions must agree except for axis being concatenated"
+
def test_std(self):
from _numpypy import array
a = array(range(10))
@@ -1068,7 +1120,6 @@
a = array([[1, 2], [3, 4]])
assert (a.T.flatten() == [1, 3, 2, 4]).all()
-
class AppTestMultiDim(BaseNumpyAppTest):
def test_init(self):
import _numpypy
@@ -1455,6 +1506,11 @@
a[a & 1 == 1] = array([8, 9, 10])
assert (a == [[0, 8], [2, 9], [4, 10]]).all()
+ def test_isna(self):
+ from _numpypy import isna, array
+ # XXX for now
+ assert not isna(3)
+ assert (isna(array([1, 2, 3, 4])) == [False, False, False, False]).all()
class AppTestSupport(BaseNumpyAppTest):
diff --git a/pypy/module/micronumpy/tool/numready/__init__.py b/pypy/module/micronumpy/tool/numready/__init__.py
new file mode 100644
diff --git a/pypy/module/micronumpy/tool/numready/__main__.py b/pypy/module/micronumpy/tool/numready/__main__.py
new file mode 100644
--- /dev/null
+++ b/pypy/module/micronumpy/tool/numready/__main__.py
@@ -0,0 +1,6 @@
+import sys
+
+from .main import main
+
+
+main(sys.argv)
diff --git a/pypy/module/micronumpy/tool/numready/kinds.py b/pypy/module/micronumpy/tool/numready/kinds.py
new file mode 100644
--- /dev/null
+++ b/pypy/module/micronumpy/tool/numready/kinds.py
@@ -0,0 +1,4 @@
+KINDS = {
+ "UNKNOWN": "U",
+ "TYPE": "T",
+}
diff --git a/pypy/module/micronumpy/tool/numready/main.py b/pypy/module/micronumpy/tool/numready/main.py
new file mode 100644
--- /dev/null
+++ b/pypy/module/micronumpy/tool/numready/main.py
@@ -0,0 +1,119 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+This should be run under PyPy.
+"""
+
+import os
+import platform
+import subprocess
+import tempfile
+import webbrowser
+from collections import OrderedDict
+
+import jinja2
+
+from .kinds import KINDS
+
+
+class SearchableSet(object):
+ def __init__(self, items=()):
+ self._items = {}
+ for item in items:
+ self.add(item)
+
+ def __iter__(self):
+ return iter(self._items)
+
+ def __contains__(self, other):
+ return other in self._items
+
+ def __getitem__(self, idx):
+ return self._items[idx]
+
+ def add(self, item):
+ self._items[item] = item
+
+ def __len__(self):
+ return len(self._items)
+
+class Item(object):
+ def __init__(self, name, kind, subitems=None):
+ self.name = name
+ self.kind = kind
+ self.subitems = subitems
+
+ def __hash__(self):
+ return hash(self.name)
+
+ def __eq__(self, other):
+ if isinstance(other, str):
+ return self.name == other
+ return self.name == other.name
+
+
+class ItemStatus(object):
+ def __init__(self, name, pypy_exists):
+ self.name = name
+ self.cls = 'exists' if pypy_exists else ''
+ self.symbol = u"✔" if pypy_exists else u'✖'
+
+ def __lt__(self, other):
+ return self.name < other.name
+
+def find_numpy_items(python, modname="numpy", attr=None):
+ args = [
+ python, os.path.join(os.path.dirname(__file__), "search.py"), modname
+ ]
+ if attr is not None:
+ args.append(attr)
+ lines = subprocess.check_output(args).splitlines()
+ items = SearchableSet()
+ for line in lines:
+ kind, name = line.split(" : ", 1)
+ subitems = None
+ if kind == KINDS["TYPE"]:
+ if name in ['ndarray', 'dtype']:
+ subitems = find_numpy_items(python, modname, name)
+ items.add(Item(name, kind, subitems))
+ return items
+
+def split(lst):
+ SPLIT = 5
+ lgt = len(lst) // SPLIT + 1
+ l = [[] for i in range(lgt)]
+ for i in range(lgt):
+ for k in range(SPLIT):
+ if k * lgt + i < len(lst):
+ l[i].append(lst[k * lgt + i])
+ return l
+
+def main(argv):
+ cpy_items = find_numpy_items("/usr/bin/python")
+ pypy_items = find_numpy_items(argv[1], "numpypy")
+ all_items = []
+
+ msg = '%d/%d names, %d/%d ndarray attributes, %d/%d dtype attributes' % (
+ len(pypy_items), len(cpy_items), len(pypy_items['ndarray'].subitems),
+ len(cpy_items['ndarray'].subitems), len(pypy_items['dtype'].subitems),
+ len(cpy_items['dtype'].subitems))
+ for item in cpy_items:
+ pypy_exists = item in pypy_items
+ if item.subitems:
+ for sub in item.subitems:
+ all_items.append(
+ ItemStatus(item.name + "." + sub.name, pypy_exists=pypy_exists and pypy_items[item].subitems and sub in pypy_items[item].subitems)
+ )
+ all_items.append(ItemStatus(item.name, pypy_exists=item in pypy_items))
+ env = jinja2.Environment(
+ loader=jinja2.FileSystemLoader(os.path.dirname(__file__))
+ )
+ html = env.get_template("page.html").render(all_items=split(sorted(all_items)), msg=msg)
+ if len(argv) > 2:
+ with open(argv[2], 'w') as f:
+ f.write(html.encode("utf-8"))
+ else:
+ with tempfile.NamedTemporaryFile(delete=False) as f:
+ f.write(html.encode("utf-8"))
+ print "Saved in: %s" % f.name
diff --git a/pypy/module/micronumpy/tool/numready/page.html b/pypy/module/micronumpy/tool/numready/page.html
new file mode 100644
--- /dev/null
+++ b/pypy/module/micronumpy/tool/numready/page.html
@@ -0,0 +1,65 @@
+<!DOCTYPE html>
+<html lang="en">
+ <head>
+ <title>NumPyPy Status</title>
+ <meta http-equiv="content-type" content="text/html; charset=utf-8">
+ <style type="text/css">
+ body {
+ font-family: 'Consolas', 'Bitstream Vera Sans Mono', monospace;
+ }
+ h1 {
+ text-align: center;
+ }
+ h3 {
+ text-align: center;
+ }
+ table {
+ border: 8px solid #DFDECB;
+ margin: 30px auto;
+ font-size: 12px;
+ }
+ table th {
+ text-align: left;
+ }
+ table td {
+ padding: 4px 10px;
+ text-align: center;
+ }
+ .exists {
+ background-color: #337792;
+ color: white;
+ border: 1px solid #234F61;
+ }
+ </style>
+ </head>
+ <body>
+ <h1>NumPyPy Status</h1>
+ <h3>Overall: {{ msg }}</h3>
+ <table>
+ <thead>
+ <tr>
+ <th></th>
+ <th>PyPy</th>
+ <th></th>
+ <th>PyPy</th>
+ <th></th>
+ <th>PyPy</th>
+ <th></th>
+ <th>PyPy</th>
+ <th></th>
+ <th>PyPy</th>
+ </tr>
+ </thead>
+ <tbody>
+ {% for chunk in all_items %}
+ <tr>
+ {% for item in chunk %}
+ <th class='{{ item.cls }}'>{{ item.name }}</th>
+ <td class='{{ item.cls }}'>{{ item.symbol }}</td>
+ {% endfor %}
+ </tr>
+ {% endfor %}
+ </tbody>
+ </table>
+ </body>
+</html>
diff --git a/pypy/module/micronumpy/tool/numready/search.py b/pypy/module/micronumpy/tool/numready/search.py
new file mode 100644
--- /dev/null
+++ b/pypy/module/micronumpy/tool/numready/search.py
@@ -0,0 +1,33 @@
+import sys
+import types
+
+# Evil implicit relative import.
+from kinds import KINDS
+
+
+def main(argv):
+ if len(argv) == 2:
+ [_, modname] = argv
+ attr = None
+ elif len(argv) == 3:
+ [_, modname, attr] = argv
+ else:
+ sys.exit("Wrong number of args")
+ __import__(modname)
+ obj = sys.modules[modname]
+
+ if attr is not None:
+ obj = getattr(obj, attr)
+
+ for name in dir(obj):
+ if attr is None and name.startswith("_"):
+ continue
+ subobj = getattr(obj, name)
+ if isinstance(subobj, types.TypeType):
+ kind = KINDS["TYPE"]
+ else:
+ kind = KINDS["UNKNOWN"]
+ print kind, ":", name
+
+if __name__ == "__main__":
+ main(sys.argv)
\ No newline at end of file
diff --git a/pypy/module/posix/test/test_posix2.py b/pypy/module/posix/test/test_posix2.py
--- a/pypy/module/posix/test/test_posix2.py
+++ b/pypy/module/posix/test/test_posix2.py
@@ -371,6 +371,8 @@
if hasattr(__import__(os.name), "forkpty"):
def test_forkpty(self):
import sys
+ if 'freebsd' in sys.platform:
+ skip("hangs indifinitly on FreeBSD (also on CPython).")
os = self.posix
childpid, master_fd = os.forkpty()
assert isinstance(childpid, int)
diff --git a/pypy/module/thread/ll_thread.py b/pypy/module/thread/ll_thread.py
--- a/pypy/module/thread/ll_thread.py
+++ b/pypy/module/thread/ll_thread.py
@@ -4,7 +4,7 @@
import py
from pypy.rlib import jit, rgc
from pypy.rlib.debug import ll_assert
-from pypy.rlib.objectmodel import we_are_translated
+from pypy.rlib.objectmodel import we_are_translated, specialize
from pypy.rpython.lltypesystem.lloperation import llop
from pypy.rpython.tool import rffi_platform
from pypy.tool import autopath
@@ -85,6 +85,7 @@
def allocate_lock():
return Lock(allocate_ll_lock())
+ at specialize.arg(0)
def ll_start_new_thread(func):
ident = c_thread_start(func)
if ident == -1:
@@ -97,6 +98,7 @@
def get_ident():
return rffi.cast(lltype.Signed, c_thread_get_ident())
+ at specialize.arg(0)
def start_new_thread(x, y):
"""In RPython, no argument can be passed. You have to use global
variables to pass information to the new thread. That's not very
diff --git a/pypy/module/thread/test/test_ll_thread.py b/pypy/module/thread/test/test_ll_thread.py
--- a/pypy/module/thread/test/test_ll_thread.py
+++ b/pypy/module/thread/test/test_ll_thread.py
@@ -34,72 +34,34 @@
use_threads = True
def test_start_new_thread(self):
- py.test.skip("xxx ideally, investigate why it fails randomly")
- # xxx but in practice start_new_thread() is also tested by the
- # next test, and it's a mess to test start_new_thread() without
- # the proper GIL to protect the GC
import time
class State:
pass
state = State()
- class Z:
- def __init__(self, value):
- self.value = value
- def __del__(self):
- state.freed_counter += 1
-
- def bootstrap():
- state.my_thread_ident = state.z.ident = get_ident()
- assert state.my_thread_ident == get_ident()
- assert get_ident() == state.z.ident
- state.seen_value = state.z.value
- state.z = None
- # I think that we would need here a memory barrier in order
- # to make the test pass reliably. The issue is that the
- # main thread may see 'state.done = 1' before seeing the
- # effect of the other assignments done above. For now let's
- # emulate the write barrier by doing a system call and
- # waiting a bit...
- time.sleep(0.012)
- state.done = 1
-
- def g(i):
- state.z = Z(i)
- return start_new_thread(bootstrap, ())
- g._dont_inline_ = True
+ def bootstrap1():
+ state.my_thread_ident1 = get_ident()
+ def bootstrap2():
+ state.my_thread_ident2 = get_ident()
def f():
- main_ident = get_ident()
- assert main_ident == get_ident()
- state.freed_counter = 0
- for i in range(50):
- state.done = 0
- state.seen_value = 0
- ident = g(i)
- gc.collect()
- willing_to_wait_more = 1000
- while not state.done:
- willing_to_wait_more -= 1
- if not willing_to_wait_more:
- raise Exception("thread didn't start?")
- time.sleep(0.01)
- assert state.my_thread_ident != main_ident
- assert state.my_thread_ident == ident
- assert state.seen_value == i
- # try to force Boehm to do some freeing
- for i in range(3):
- gc.collect()
- return state.freed_counter
+ state.my_thread_ident1 = get_ident()
+ state.my_thread_ident2 = get_ident()
+ start_new_thread(bootstrap1, ())
+ start_new_thread(bootstrap2, ())
+ willing_to_wait_more = 1000
+ while (state.my_thread_ident1 == get_ident() or
+ state.my_thread_ident2 == get_ident()):
+ willing_to_wait_more -= 1
+ if not willing_to_wait_more:
+ raise Exception("thread didn't start?")
+ time.sleep(0.01)
+ return 42
fn = self.getcompiled(f, [])
- freed_counter = fn()
- print freed_counter
- if self.gcpolicy == 'boehm':
- assert freed_counter > 0
- else:
- assert freed_counter == 50
+ res = fn()
+ assert res == 42
def test_gc_locking(self):
import time
@@ -202,6 +164,9 @@
def getcompiled(self, f, argtypes):
return f
+ def test_start_new_thread(self):
+ py.test.skip("deadlocks occasionally -- why???")
+
class TestUsingBoehm(AbstractThreadTests):
gcpolicy = 'boehm'
diff --git a/pypy/rlib/objectmodel.py b/pypy/rlib/objectmodel.py
--- a/pypy/rlib/objectmodel.py
+++ b/pypy/rlib/objectmodel.py
@@ -130,19 +130,29 @@
if self is other:
return 0
else:
- raise TypeError("Symbolics can not be compared!")
+ raise TypeError("Symbolics can not be compared! (%r, %r)"
+ % (self, other))
def __hash__(self):
- raise TypeError("Symbolics are not hashable!")
+ raise TypeError("Symbolics are not hashable! %r" % (self,))
def __nonzero__(self):
- raise TypeError("Symbolics are not comparable")
+ raise TypeError("Symbolics are not comparable! %r" % (self,))
class ComputedIntSymbolic(Symbolic):
def __init__(self, compute_fn):
self.compute_fn = compute_fn
+ def __repr__(self):
+ # repr(self.compute_fn) can arrive back here in an
+ # infinite recursion
+ try:
+ name = self.compute_fn.__name__
+ except (AttributeError, TypeError):
+ name = hex(id(self.compute_fn))
+ return '%s(%r)' % (self.__class__.__name__, name)
+
def annotation(self):
from pypy.annotation import model
return model.SomeInteger()
@@ -157,6 +167,9 @@
self.expr = expr
self.default = default
+ def __repr__(self):
+ return '%s(%r)' % (self.__class__.__name__, self.expr)
+
def annotation(self):
from pypy.annotation import model
return model.SomeInteger()
diff --git a/pypy/rlib/rdynload.py b/pypy/rlib/rdynload.py
--- a/pypy/rlib/rdynload.py
+++ b/pypy/rlib/rdynload.py
@@ -14,7 +14,7 @@
_MINGW = platform.name == "mingw32"
_WIN32 = _MSVC or _MINGW
_MAC_OS = platform.name == "darwin"
-_FREEBSD = platform.name == "freebsd"
+_FREEBSD = sys.platform.startswith("freebsd")
if _WIN32:
from pypy.rlib import rwin32
diff --git a/pypy/rlib/rsocket.py b/pypy/rlib/rsocket.py
--- a/pypy/rlib/rsocket.py
+++ b/pypy/rlib/rsocket.py
@@ -310,10 +310,7 @@
def from_object(space, w_address):
# Parse an app-level object representing an AF_INET address
- try:
- w_host, w_port = space.unpackiterable(w_address, 2)
- except ValueError:
- raise TypeError("AF_INET address must be a tuple of length 2")
+ w_host, w_port = space.unpackiterable(w_address, 2)
host = space.str_w(w_host)
port = space.int_w(w_port)
port = Address.make_ushort_port(space, port)
@@ -544,10 +541,7 @@
space.wrap(self.get_groups())])
def from_object(space, w_address):
- try:
- w_pid, w_groups = space.unpackiterable(w_address, 2)
- except ValueError:
- raise TypeError("AF_NETLINK address must be a tuple of length 2")
+ w_pid, w_groups = space.unpackiterable(w_address, 2)
return NETLINKAddress(space.uint_w(w_pid), space.uint_w(w_groups))
from_object = staticmethod(from_object)
diff --git a/pypy/rpython/lltypesystem/ll2ctypes.py b/pypy/rpython/lltypesystem/ll2ctypes.py
--- a/pypy/rpython/lltypesystem/ll2ctypes.py
+++ b/pypy/rpython/lltypesystem/ll2ctypes.py
@@ -1390,7 +1390,8 @@
def _where_is_errno():
return standard_c_lib.__errno_location()
- elif sys.platform in ('darwin', 'freebsd7', 'freebsd8', 'freebsd9'):
+ elif any(plat in sys.platform
+ for plat in ('darwin', 'freebsd7', 'freebsd8', 'freebsd9')):
standard_c_lib.__error.restype = ctypes.POINTER(ctypes.c_int)
def _where_is_errno():
return standard_c_lib.__error()
diff --git a/pypy/rpython/lltypesystem/llgroup.py b/pypy/rpython/lltypesystem/llgroup.py
--- a/pypy/rpython/lltypesystem/llgroup.py
+++ b/pypy/rpython/lltypesystem/llgroup.py
@@ -76,6 +76,10 @@
self.index = memberindex
self.member = grp.members[memberindex]._as_ptr()
+ def __repr__(self):
+ return '%s(%s, %s)' % (self.__class__.__name__,
+ self.grpptr, self.index)
+
def __nonzero__(self):
return True
diff --git a/pypy/rpython/lltypesystem/rffi.py b/pypy/rpython/lltypesystem/rffi.py
--- a/pypy/rpython/lltypesystem/rffi.py
+++ b/pypy/rpython/lltypesystem/rffi.py
@@ -27,6 +27,10 @@
self.c_name = c_name
self.TP = TP
+ def __repr__(self):
+ return '%s(%r, %s)' % (self.__class__.__name__,
+ self.c_name, self.TP)
+
def annotation(self):
return lltype_to_annotation(self.TP)
diff --git a/pypy/rpython/memory/gc/env.py b/pypy/rpython/memory/gc/env.py
--- a/pypy/rpython/memory/gc/env.py
+++ b/pypy/rpython/memory/gc/env.py
@@ -116,7 +116,7 @@
def get_total_memory():
return get_total_memory_darwin(get_darwin_sysctl_signed('hw.memsize'))
-elif sys.platform.startswith('freebsd'):
+elif 'freebsd' in sys.platform:
def get_total_memory():
return get_total_memory_darwin(get_darwin_sysctl_signed('hw.usermem'))
diff --git a/pypy/rpython/module/ll_time.py b/pypy/rpython/module/ll_time.py
--- a/pypy/rpython/module/ll_time.py
+++ b/pypy/rpython/module/ll_time.py
@@ -41,7 +41,7 @@
RUSAGE = platform.Struct('struct rusage', [('ru_utime', TIMEVAL),
('ru_stime', TIMEVAL)])
-if "freebsd" in sys.platform:
+if sys.platform.startswith('freebsd'):
libraries = ['compat']
else:
libraries = []
diff --git a/pypy/translator/platform/freebsd.py b/pypy/translator/platform/freebsd.py
--- a/pypy/translator/platform/freebsd.py
+++ b/pypy/translator/platform/freebsd.py
@@ -18,8 +18,9 @@
class Freebsd(posix.BasePosix):
name = "freebsd"
- link_flags = get_env_vector("LDFLAGS", '-pthread')
- cflags = get_env_vector("CFLAGS", "-O3 -pthread -fomit-frame-pointer")
+ link_flags = ['-pthread'] + get_env_vector('LDFLAGS', '')
+ cflags = ['-O3', '-pthread', '-fomit-frame-pointer'
+ ] + get_env_vector('CFLAGS', '')
standalone_only = []
shared_only = []
so_ext = 'so'
diff --git a/pypy/translator/platform/linux.py b/pypy/translator/platform/linux.py
--- a/pypy/translator/platform/linux.py
+++ b/pypy/translator/platform/linux.py
@@ -1,15 +1,20 @@
"""Support for Linux."""
+import os
import sys
from pypy.translator.platform.posix import BasePosix
class BaseLinux(BasePosix):
name = "linux"
- link_flags = ('-pthread',)
+ link_flags = tuple(
+ ['-pthread',]
+ + os.environ.get('LDFLAGS', '').split())
extra_libs = ('-lrt',)
- cflags = ('-O3', '-pthread', '-fomit-frame-pointer',
- '-Wall', '-Wno-unused')
+ cflags = tuple(
+ ['-O3', '-pthread', '-fomit-frame-pointer',
+ '-Wall', '-Wno-unused']
+ + os.environ.get('CFLAGS', '').split())
standalone_only = ()
shared_only = ('-fPIC',)
so_ext = 'so'
More information about the pypy-commit
mailing list