numpy · certik · Sep 16, 2012 · Jul 18, 2012 · Jul 29, 2012 · Jul 31, 2012
diff --git a/.travis-make-py24-virtualenv.sh b/.travis-make-py24-virtualenv.sh
@@ -15,4 +15,11 @@ EOF
 ./configure --prefix=$PWD/install
 make
 make install
-virtualenv -p install/bin/python2.4 --distribute $VIRTENV
+# This is the last version of virtualenv to support python 2.4:
+curl -O https://raw.github.com/pypa/virtualenv/1.7.2/virtualenv.py
+# And this is the last version of pip to support python 2.4. If
+# there's a file matching "^pip-.*(zip|tar.gz|tar.bz2|tgz|tbz)$" in
+# the current directory then virtualenv will take that as the pip
+# source distribution to install
+curl -O http://pypi.python.org/packages/source/p/pip/pip-1.1.tar.gz
+install/bin/python2.4 ./virtualenv.py --distribute $VIRTENV
diff --git a/bscript b/bscript
@@ -12,9 +12,6 @@ Caveats:
 import os
 import sys
 import subprocess
-import string
-
-import os.path as op
 
 # Ugly but necessary hack: import numpy here so that wscript in sub directories
 # will see this numpy and not an already installed one

diff --git a/numpy/build_utils/waf.py b/numpy/build_utils/waf.py
@@ -412,15 +412,15 @@ def check_ldouble_representation(conf, **kw):
 def post_check(self, *k, **kw):
     "set the variables after a test was run successfully"
 
-    is_success = 0
+    is_success = False
     if kw['execute']:
         if kw['success'] is not None:
-            is_success = kw['success']
+            if kw.get('define_ret', False):
+                is_success = kw['success']
+            else:
+                is_success = (kw['success'] == 0)
     else:
-        if kw["success"] == 0:
-            is_success = 1
-        else:
-            is_success = 0
+        is_success = (kw['success'] == 0)
 
     def define_or_stuff():
         nm = kw['define_name']
@@ -453,7 +453,7 @@ def define_or_stuff():
                 if isinstance(val, str):
                     val = val.rstrip(os.path.sep)
                 self.env.append_unique(k + '_' + kw['uselib_store'], val)
-	return is_success
+    return is_success
 
 @waflib.Configure.conf
 def define_with_comment(conf, define, value, comment=None, quote=True):

diff --git a/numpy/core/_internal.py b/numpy/core/_internal.py
@@ -133,7 +133,7 @@ def _reconstruct(subtype, shape, dtype):
 
 format_re = re.compile(asbytes(
                            r'(?P<order1>[<>|=]?)'
-                           r'(?P<repeats> *[(]?[ ,0-9]*[)]? *)'
+                           r'(?P<repeats> *[(]?[ ,0-9L]*[)]? *)'
                            r'(?P<order2>[<>|=]?)'
                            r'(?P<dtype>[A-Za-z0-9.]*(?:\[[a-zA-Z0-9,.]+\])?)'))
 sep_re = re.compile(asbytes(r'\s*,\s*'))
@@ -285,7 +285,7 @@ def _newnames(datatype, order):
 # Given an array with fields and a sequence of field names
 # construct a new array with just those fields copied over
 def _index_fields(ary, fields):
-    from multiarray import empty, dtype
+    from multiarray import empty, dtype, array
     dt = ary.dtype
 
     names = [name for name in fields if name in dt.names]
@@ -295,7 +295,10 @@ def _index_fields(ary, fields):
     view_dtype = {'names':names, 'formats':formats, 'offsets':offsets, 'itemsize':dt.itemsize}
     view = ary.view(dtype=view_dtype)
 
-    return view.copy()
+    # Return a copy for now until behavior is fully deprecated
+    # in favor of returning view
+    copy_dtype = {'names':view_dtype['names'], 'formats':view_dtype['formats']}
+    return array(view, dtype=copy_dtype, copy=True)
 
 # Given a string containing a PEP 3118 format specifier,
 # construct a Numpy dtype

diff --git a/numpy/core/bento.info b/numpy/core/bento.info
@@ -1,7 +1,7 @@
 HookFile: bscript
 
 Library:
-    CompiledLibrary: npymath
+    CompiledLibrary: lib/npymath
         Sources:
             src/npymath/_signbit.c,
             src/npymath/ieee754.c.src,
@@ -28,3 +28,6 @@ Library:
     Extension: scalarmath
         Sources:
             src/scalarmathmodule.c.src
+    Extension: _dotblas
+        Sources:
+            blasdot/_dotblas.c
diff --git a/numpy/core/bscript b/numpy/core/bscript
@@ -411,8 +411,7 @@ def pre_build(context):
     numpyconfig_h = context.local_node.declare(os.path.join("include", "numpy", "_numpyconfig.h"))
     context.register_outputs("numpy_gen_headers", "numpyconfig", [numpyconfig_h])
 
-    context.tweak_library("npymath",
-                          includes=["src/private", "src/npymath", "include"])
+    context.tweak_library("lib/npymath", includes=["src/private", "src/npymath", "include"])
 
     context.tweak_library("npysort",
                           includes=[".", "src/private", "src/npysort"],
@@ -501,11 +500,11 @@ def pre_build(context):
                                        use="npymath")
     context.register_builder("umath", build_ufunc)
 
-    context.tweak_extension("scalarmath", use="npymath")
+    context.tweak_extension("scalarmath", use="npymath", includes=["src/private"])
     context.tweak_extension("multiarray_tests", use="npymath", includes=["src/private"])
     context.tweak_extension("umath_tests", use="npymath", includes=["src/private"])
 
     def build_dotblas(extension):
         if bld.env.HAS_CBLAS:
-            return context.default_builder(extension, use="CBLAS")
+            return context.default_builder(extension, use="CBLAS", includes=["src/private"])
     context.register_builder("_dotblas", build_dotblas)
diff --git a/numpy/core/src/multiarray/calculation.c b/numpy/core/src/multiarray/calculation.c
@@ -895,7 +895,7 @@ PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *o
     PyArrayObject *maxa = NULL;
     PyArrayObject *mina = NULL;
     PyArrayObject *newout = NULL, *newin = NULL;
-    PyArray_Descr *indescr, *newdescr;
+    PyArray_Descr *indescr = NULL, *newdescr = NULL;
     char *max_data, *min_data;
     PyObject *zero;
 
@@ -922,23 +922,24 @@ PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *o
     /* Use the fast scalar clip function */
 
     /* First we need to figure out the correct type */
-    indescr = NULL;
     if (min != NULL) {
         indescr = PyArray_DescrFromObject(min, NULL);
         if (indescr == NULL) {
-            return NULL;
+            goto fail;
         }
     }
     if (max != NULL) {
         newdescr = PyArray_DescrFromObject(max, indescr);
         Py_XDECREF(indescr);
+        indescr = NULL;
         if (newdescr == NULL) {
-            return NULL;
+            goto fail;
         }
     }
     else {
         /* Steal the reference */
         newdescr = indescr;
+        indescr = NULL;
     }
 
 
@@ -950,8 +951,12 @@ PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *o
     if (PyArray_ScalarKind(newdescr->type_num, NULL) >
         PyArray_ScalarKind(PyArray_DESCR(self)->type_num, NULL)) {
         indescr = PyArray_PromoteTypes(newdescr, PyArray_DESCR(self));
+        if (indescr == NULL) {
+            goto fail;
+        }
         func = indescr->f->fastclip;
         if (func == NULL) {
+            Py_DECREF(indescr);
             return _slow_array_clip(self, min, max, out);
         }
     }
@@ -960,11 +965,13 @@ PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *o
         Py_INCREF(indescr);
     }
     Py_DECREF(newdescr);
+    newdescr = NULL;
 
     if (!PyDataType_ISNOTSWAPPED(indescr)) {
         PyArray_Descr *descr2;
         descr2 = PyArray_DescrNewByteorder(indescr, '=');
         Py_DECREF(indescr);
+        indescr = NULL;
         if (descr2 == NULL) {
             goto fail;
         }
@@ -973,16 +980,13 @@ PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *o
 
     /* Convert max to an array */
     if (max != NULL) {
+        Py_INCREF(indescr);
         maxa = (PyArrayObject *)PyArray_FromAny(max, indescr, 0, 0,
                                  NPY_ARRAY_DEFAULT, NULL);
         if (maxa == NULL) {
-            return NULL;
+            goto fail;
         }
     }
-    else {
-        /* Side-effect of PyArray_FromAny */
-        Py_DECREF(indescr);
-    }
 
     /*
      * If we are unsigned, then make sure min is not < 0
@@ -1147,6 +1151,8 @@ PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *o
     func(PyArray_DATA(newin), PyArray_SIZE(newin), min_data, max_data, PyArray_DATA(newout));
 
     /* Clean up temporary variables */
+    Py_XDECREF(indescr);
+    Py_XDECREF(newdescr);
     Py_XDECREF(mina);
     Py_XDECREF(maxa);
     Py_DECREF(newin);
@@ -1155,6 +1161,8 @@ PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *o
     return (PyObject *)out;
 
  fail:
+    Py_XDECREF(indescr);
+    Py_XDECREF(newdescr);
     Py_XDECREF(maxa);
     Py_XDECREF(mina);
     Py_XDECREF(newin);

diff --git a/numpy/core/src/multiarray/mapping.c b/numpy/core/src/multiarray/mapping.c
@@ -6,6 +6,7 @@
 #define NPY_NO_DEPRECATED_API NPY_API_VERSION
 #define _MULTIARRAYMODULE
 #include "numpy/arrayobject.h"
+#include "arrayobject.h"
 
 #include "npy_config.h"
 

diff --git a/numpy/core/src/multiarray/methods.c b/numpy/core/src/multiarray/methods.c
@@ -1587,8 +1587,9 @@ array_setstate(PyArrayObject *self, PyObject *args)
         /* Check that the string is not interned */
         if (!_IsAligned(self) || swap || PyString_CHECK_INTERNED(rawdata)) {
 #else
-        /* Bytes are never interned */
-        if (!_IsAligned(self) || swap) {
+        /* Bytes should always be considered immutable, but we just grab the
+         * pointer if they are large, to save memory. */
+        if (!_IsAligned(self) || swap || (len <= 1000)) {
 #endif
             npy_intp num = PyArray_NBYTES(self);
             fa->data = PyDataMem_NEW(num);

diff --git a/numpy/core/src/multiarray/multiarraymodule.c b/numpy/core/src/multiarray/multiarraymodule.c
@@ -602,6 +602,7 @@ PyArray_Concatenate(PyObject *op, int axis)
     for (iarrays = 0; iarrays < narrays; ++iarrays) {
         Py_DECREF(arrays[iarrays]);
     }
+    PyArray_free(arrays);
 
     return (PyObject *)ret;
 
@@ -610,6 +611,7 @@ PyArray_Concatenate(PyObject *op, int axis)
     for (iarrays = 0; iarrays < narrays; ++iarrays) {
         Py_DECREF(arrays[iarrays]);
     }
+    PyArray_free(arrays);
 
     return NULL;
 }

diff --git a/numpy/core/src/multiarray/scalarapi.c b/numpy/core/src/multiarray/scalarapi.c
@@ -334,7 +334,7 @@ PyArray_FromScalar(PyObject *scalar, PyArray_Descr *outcode)
     if (outcode == NULL) {
         return (PyObject *)r;
     }
-    if (outcode->type_num == typecode->type_num) {
+    if (PyArray_EquivTypes(outcode, typecode)) {
         if (!PyTypeNum_ISEXTENDED(typecode->type_num)
                 || (outcode->elsize == typecode->elsize)) {
             Py_DECREF(outcode);
@@ -641,6 +641,35 @@ PyArray_Scalar(void *data, PyArray_Descr *descr, PyObject *base)
             itemsize = (((itemsize - 1) >> 2) + 1) << 2;
         }
     }
+#if PY_VERSION_HEX >= 0x03030000
+    if (type_num == NPY_UNICODE) {
+        PyObject *u, *args;
+        int byteorder;
+
+#if NPY_BYTE_ORDER == NPY_LITTLE_ENDIAN
+        byteorder = -1;
+#elif NPY_BYTE_ORDER == NPY_BIG_ENDIAN
+        byteorder = +1;
+#else
+        #error Endianness undefined ?
+#endif
+        if (swap) byteorder *= -1;
+
+        u = PyUnicode_DecodeUTF32(data, itemsize, NULL, &byteorder);
+        if (u == NULL) {
+            return NULL;
+        }
+        args = Py_BuildValue("(O)", u);
+        if (args == NULL) {
+            Py_DECREF(u);
+            return NULL;
+        }
+        obj = type->tp_new(type, args, NULL);
+        Py_DECREF(u);
+        Py_DECREF(args);
+        return obj;
+    }
+#endif
     if (type->tp_itemsize != 0) {
         /* String type */
         obj = type->tp_alloc(type, itemsize);
@@ -672,6 +701,7 @@ PyArray_Scalar(void *data, PyArray_Descr *descr, PyObject *base)
             memcpy(destptr, data, itemsize);
             return obj;
         }
+#if PY_VERSION_HEX < 0x03030000
         else if (type_num == NPY_UNICODE) {
             /* tp_alloc inherited from Python PyBaseObject_Type */
             PyUnicodeObject *uni = (PyUnicodeObject*)obj;
@@ -743,6 +773,7 @@ PyArray_Scalar(void *data, PyArray_Descr *descr, PyObject *base)
 #endif
             return obj;
         }
+#endif /* PY_VERSION_HEX < 0x03030000 */
         else {
             PyVoidScalarObject *vobj = (PyVoidScalarObject *)obj;
             vobj->base = NULL;

diff --git a/numpy/core/src/multiarray/scalartypes.c.src b/numpy/core/src/multiarray/scalartypes.c.src
@@ -2592,7 +2592,11 @@ finish:
     *((npy_@name@ *)dest) = *((npy_@name@ *)src);
 #elif @default@ == 1 /* unicode and strings */
     if (itemsize == 0) { /* unicode */
+#if PY_VERSION_HEX >= 0x03030000
+        itemsize = PyUnicode_GetLength(robj) * PyUnicode_KIND(robj);
+#else
         itemsize = ((PyUnicodeObject *)robj)->length * sizeof(Py_UNICODE);
+#endif
     }
     memcpy(dest, src, itemsize);
     /* @default@ == 2 won't get here */

diff --git a/numpy/core/tests/test_dtype.py b/numpy/core/tests/test_dtype.py
@@ -413,6 +413,11 @@ def test_complex_dtype_repr(self):
         assert_equal(repr(dt),
                     "dtype([('a', '<M8[D]'), ('b', '<m8[us]')])")
 
+    @dec.skipif(sys.version_info[0] > 2)
+    def test_dtype_str_with_long_in_shape(self):
+        # Pull request #376
+        dt = np.dtype('(1L,)i4')
+
 
 class TestDtypeAttributeDeletion(object):