pruned venvs
This commit is contained in:
d3m1g0d
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
@@ -1,275 +0,0 @@
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
import sys
|
||||
import pytest
|
||||
import weakref
|
||||
|
||||
import numpy as np
|
||||
from numpy.ctypeslib import ndpointer, load_library, as_array
|
||||
from numpy.distutils.misc_util import get_shared_lib_extension
|
||||
from numpy.testing import assert_, assert_array_equal, assert_raises, assert_equal
|
||||
|
||||
try:
|
||||
import ctypes
|
||||
except ImportError:
|
||||
ctypes = None
|
||||
else:
|
||||
cdll = None
|
||||
test_cdll = None
|
||||
if hasattr(sys, 'gettotalrefcount'):
|
||||
try:
|
||||
cdll = load_library('_multiarray_umath_d', np.core._multiarray_umath.__file__)
|
||||
except OSError:
|
||||
pass
|
||||
try:
|
||||
test_cdll = load_library('_multiarray_tests', np.core._multiarray_tests.__file__)
|
||||
except OSError:
|
||||
pass
|
||||
if cdll is None:
|
||||
cdll = load_library('_multiarray_umath', np.core._multiarray_umath.__file__)
|
||||
if test_cdll is None:
|
||||
test_cdll = load_library('_multiarray_tests', np.core._multiarray_tests.__file__)
|
||||
|
||||
c_forward_pointer = test_cdll.forward_pointer
|
||||
|
||||
|
||||
@pytest.mark.skipif(ctypes is None,
|
||||
reason="ctypes not available in this python")
|
||||
@pytest.mark.skipif(sys.platform == 'cygwin',
|
||||
reason="Known to fail on cygwin")
|
||||
class TestLoadLibrary(object):
|
||||
def test_basic(self):
|
||||
try:
|
||||
# Should succeed
|
||||
load_library('_multiarray_umath', np.core._multiarray_umath.__file__)
|
||||
except ImportError as e:
|
||||
msg = ("ctypes is not available on this python: skipping the test"
|
||||
" (import error was: %s)" % str(e))
|
||||
print(msg)
|
||||
|
||||
def test_basic2(self):
|
||||
# Regression for #801: load_library with a full library name
|
||||
# (including extension) does not work.
|
||||
try:
|
||||
try:
|
||||
so = get_shared_lib_extension(is_python_ext=True)
|
||||
# Should succeed
|
||||
load_library('_multiarray_umath%s' % so, np.core._multiarray_umath.__file__)
|
||||
except ImportError:
|
||||
print("No distutils available, skipping test.")
|
||||
except ImportError as e:
|
||||
msg = ("ctypes is not available on this python: skipping the test"
|
||||
" (import error was: %s)" % str(e))
|
||||
print(msg)
|
||||
|
||||
|
||||
class TestNdpointer(object):
|
||||
def test_dtype(self):
|
||||
dt = np.intc
|
||||
p = ndpointer(dtype=dt)
|
||||
assert_(p.from_param(np.array([1], dt)))
|
||||
dt = '<i4'
|
||||
p = ndpointer(dtype=dt)
|
||||
assert_(p.from_param(np.array([1], dt)))
|
||||
dt = np.dtype('>i4')
|
||||
p = ndpointer(dtype=dt)
|
||||
p.from_param(np.array([1], dt))
|
||||
assert_raises(TypeError, p.from_param,
|
||||
np.array([1], dt.newbyteorder('swap')))
|
||||
dtnames = ['x', 'y']
|
||||
dtformats = [np.intc, np.float64]
|
||||
dtdescr = {'names': dtnames, 'formats': dtformats}
|
||||
dt = np.dtype(dtdescr)
|
||||
p = ndpointer(dtype=dt)
|
||||
assert_(p.from_param(np.zeros((10,), dt)))
|
||||
samedt = np.dtype(dtdescr)
|
||||
p = ndpointer(dtype=samedt)
|
||||
assert_(p.from_param(np.zeros((10,), dt)))
|
||||
dt2 = np.dtype(dtdescr, align=True)
|
||||
if dt.itemsize != dt2.itemsize:
|
||||
assert_raises(TypeError, p.from_param, np.zeros((10,), dt2))
|
||||
else:
|
||||
assert_(p.from_param(np.zeros((10,), dt2)))
|
||||
|
||||
def test_ndim(self):
|
||||
p = ndpointer(ndim=0)
|
||||
assert_(p.from_param(np.array(1)))
|
||||
assert_raises(TypeError, p.from_param, np.array([1]))
|
||||
p = ndpointer(ndim=1)
|
||||
assert_raises(TypeError, p.from_param, np.array(1))
|
||||
assert_(p.from_param(np.array([1])))
|
||||
p = ndpointer(ndim=2)
|
||||
assert_(p.from_param(np.array([[1]])))
|
||||
|
||||
def test_shape(self):
|
||||
p = ndpointer(shape=(1, 2))
|
||||
assert_(p.from_param(np.array([[1, 2]])))
|
||||
assert_raises(TypeError, p.from_param, np.array([[1], [2]]))
|
||||
p = ndpointer(shape=())
|
||||
assert_(p.from_param(np.array(1)))
|
||||
|
||||
def test_flags(self):
|
||||
x = np.array([[1, 2], [3, 4]], order='F')
|
||||
p = ndpointer(flags='FORTRAN')
|
||||
assert_(p.from_param(x))
|
||||
p = ndpointer(flags='CONTIGUOUS')
|
||||
assert_raises(TypeError, p.from_param, x)
|
||||
p = ndpointer(flags=x.flags.num)
|
||||
assert_(p.from_param(x))
|
||||
assert_raises(TypeError, p.from_param, np.array([[1, 2], [3, 4]]))
|
||||
|
||||
def test_cache(self):
|
||||
assert_(ndpointer(dtype=np.float64) is ndpointer(dtype=np.float64))
|
||||
|
||||
# shapes are normalized
|
||||
assert_(ndpointer(shape=2) is ndpointer(shape=(2,)))
|
||||
|
||||
# 1.12 <= v < 1.16 had a bug that made these fail
|
||||
assert_(ndpointer(shape=2) is not ndpointer(ndim=2))
|
||||
assert_(ndpointer(ndim=2) is not ndpointer(shape=2))
|
||||
|
||||
@pytest.mark.skipif(ctypes is None,
|
||||
reason="ctypes not available on this python installation")
|
||||
class TestNdpointerCFunc(object):
|
||||
def test_arguments(self):
|
||||
""" Test that arguments are coerced from arrays """
|
||||
c_forward_pointer.restype = ctypes.c_void_p
|
||||
c_forward_pointer.argtypes = (ndpointer(ndim=2),)
|
||||
|
||||
c_forward_pointer(np.zeros((2, 3)))
|
||||
# too many dimensions
|
||||
assert_raises(
|
||||
ctypes.ArgumentError, c_forward_pointer, np.zeros((2, 3, 4)))
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
'dt', [
|
||||
float,
|
||||
np.dtype(dict(
|
||||
formats=['<i4', '<i4'],
|
||||
names=['a', 'b'],
|
||||
offsets=[0, 2],
|
||||
itemsize=6
|
||||
))
|
||||
], ids=[
|
||||
'float',
|
||||
'overlapping-fields'
|
||||
]
|
||||
)
|
||||
def test_return(self, dt):
|
||||
""" Test that return values are coerced to arrays """
|
||||
arr = np.zeros((2, 3), dt)
|
||||
ptr_type = ndpointer(shape=arr.shape, dtype=arr.dtype)
|
||||
|
||||
c_forward_pointer.restype = ptr_type
|
||||
c_forward_pointer.argtypes = (ptr_type,)
|
||||
|
||||
# check that the arrays are equivalent views on the same data
|
||||
arr2 = c_forward_pointer(arr)
|
||||
assert_equal(arr2.dtype, arr.dtype)
|
||||
assert_equal(arr2.shape, arr.shape)
|
||||
assert_equal(
|
||||
arr2.__array_interface__['data'],
|
||||
arr.__array_interface__['data']
|
||||
)
|
||||
|
||||
def test_vague_return_value(self):
|
||||
""" Test that vague ndpointer return values do not promote to arrays """
|
||||
arr = np.zeros((2, 3))
|
||||
ptr_type = ndpointer(dtype=arr.dtype)
|
||||
|
||||
c_forward_pointer.restype = ptr_type
|
||||
c_forward_pointer.argtypes = (ptr_type,)
|
||||
|
||||
ret = c_forward_pointer(arr)
|
||||
assert_(isinstance(ret, ptr_type))
|
||||
|
||||
|
||||
@pytest.mark.skipif(ctypes is None,
|
||||
reason="ctypes not available on this python installation")
|
||||
class TestAsArray(object):
|
||||
def test_array(self):
|
||||
from ctypes import c_int
|
||||
|
||||
pair_t = c_int * 2
|
||||
a = as_array(pair_t(1, 2))
|
||||
assert_equal(a.shape, (2,))
|
||||
assert_array_equal(a, np.array([1, 2]))
|
||||
a = as_array((pair_t * 3)(pair_t(1, 2), pair_t(3, 4), pair_t(5, 6)))
|
||||
assert_equal(a.shape, (3, 2))
|
||||
assert_array_equal(a, np.array([[1, 2], [3, 4], [5, 6]]))
|
||||
|
||||
def test_pointer(self):
|
||||
from ctypes import c_int, cast, POINTER
|
||||
|
||||
p = cast((c_int * 10)(*range(10)), POINTER(c_int))
|
||||
|
||||
a = as_array(p, shape=(10,))
|
||||
assert_equal(a.shape, (10,))
|
||||
assert_array_equal(a, np.arange(10))
|
||||
|
||||
a = as_array(p, shape=(2, 5))
|
||||
assert_equal(a.shape, (2, 5))
|
||||
assert_array_equal(a, np.arange(10).reshape((2, 5)))
|
||||
|
||||
# shape argument is required
|
||||
assert_raises(TypeError, as_array, p)
|
||||
|
||||
def test_struct_array_pointer(self):
|
||||
from ctypes import c_int16, Structure, pointer
|
||||
|
||||
class Struct(Structure):
|
||||
_fields_ = [('a', c_int16)]
|
||||
|
||||
Struct3 = 3 * Struct
|
||||
|
||||
c_array = (2 * Struct3)(
|
||||
Struct3(Struct(a=1), Struct(a=2), Struct(a=3)),
|
||||
Struct3(Struct(a=4), Struct(a=5), Struct(a=6))
|
||||
)
|
||||
|
||||
expected = np.array([
|
||||
[(1,), (2,), (3,)],
|
||||
[(4,), (5,), (6,)],
|
||||
], dtype=[('a', np.int16)])
|
||||
|
||||
def check(x):
|
||||
assert_equal(x.dtype, expected.dtype)
|
||||
assert_equal(x, expected)
|
||||
|
||||
# all of these should be equivalent
|
||||
check(as_array(c_array))
|
||||
check(as_array(pointer(c_array), shape=()))
|
||||
check(as_array(pointer(c_array[0]), shape=(2,)))
|
||||
check(as_array(pointer(c_array[0][0]), shape=(2, 3)))
|
||||
|
||||
def test_reference_cycles(self):
|
||||
# related to gh-6511
|
||||
import ctypes
|
||||
|
||||
# create array to work with
|
||||
# don't use int/long to avoid running into bpo-10746
|
||||
N = 100
|
||||
a = np.arange(N, dtype=np.short)
|
||||
|
||||
# get pointer to array
|
||||
pnt = np.ctypeslib.as_ctypes(a)
|
||||
|
||||
with np.testing.assert_no_gc_cycles():
|
||||
# decay the array above to a pointer to its first element
|
||||
newpnt = ctypes.cast(pnt, ctypes.POINTER(ctypes.c_short))
|
||||
# and construct an array using this data
|
||||
b = np.ctypeslib.as_array(newpnt, (N,))
|
||||
# now delete both, which should cleanup both objects
|
||||
del newpnt, b
|
||||
|
||||
def test_segmentation_fault(self):
|
||||
arr = np.zeros((224, 224, 3))
|
||||
c_arr = np.ctypeslib.as_ctypes(arr)
|
||||
arr_ref = weakref.ref(arr)
|
||||
del arr
|
||||
|
||||
# check the reference wasn't cleaned up
|
||||
assert_(arr_ref() is not None)
|
||||
|
||||
# check we avoid the segfault
|
||||
c_arr[0][0][0]
|
||||
@@ -1,68 +0,0 @@
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
# As we are testing matrices, we ignore its PendingDeprecationWarnings
|
||||
try:
|
||||
import pytest
|
||||
pytestmark = pytest.mark.filterwarnings(
|
||||
'ignore:the matrix subclass is not:PendingDeprecationWarning')
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
import numpy as np
|
||||
import numpy.matlib
|
||||
from numpy.testing import assert_array_equal, assert_
|
||||
|
||||
def test_empty():
|
||||
x = numpy.matlib.empty((2,))
|
||||
assert_(isinstance(x, np.matrix))
|
||||
assert_(x.shape, (1, 2))
|
||||
|
||||
def test_ones():
|
||||
assert_array_equal(numpy.matlib.ones((2, 3)),
|
||||
np.matrix([[ 1., 1., 1.],
|
||||
[ 1., 1., 1.]]))
|
||||
|
||||
assert_array_equal(numpy.matlib.ones(2), np.matrix([[ 1., 1.]]))
|
||||
|
||||
def test_zeros():
|
||||
assert_array_equal(numpy.matlib.zeros((2, 3)),
|
||||
np.matrix([[ 0., 0., 0.],
|
||||
[ 0., 0., 0.]]))
|
||||
|
||||
assert_array_equal(numpy.matlib.zeros(2), np.matrix([[ 0., 0.]]))
|
||||
|
||||
def test_identity():
|
||||
x = numpy.matlib.identity(2, dtype=int)
|
||||
assert_array_equal(x, np.matrix([[1, 0], [0, 1]]))
|
||||
|
||||
def test_eye():
|
||||
xc = numpy.matlib.eye(3, k=1, dtype=int)
|
||||
assert_array_equal(xc, np.matrix([[ 0, 1, 0],
|
||||
[ 0, 0, 1],
|
||||
[ 0, 0, 0]]))
|
||||
assert xc.flags.c_contiguous
|
||||
assert not xc.flags.f_contiguous
|
||||
|
||||
xf = numpy.matlib.eye(3, 4, dtype=int, order='F')
|
||||
assert_array_equal(xf, np.matrix([[ 1, 0, 0, 0],
|
||||
[ 0, 1, 0, 0],
|
||||
[ 0, 0, 1, 0]]))
|
||||
assert not xf.flags.c_contiguous
|
||||
assert xf.flags.f_contiguous
|
||||
|
||||
def test_rand():
|
||||
x = numpy.matlib.rand(3)
|
||||
# check matrix type, array would have shape (3,)
|
||||
assert_(x.ndim == 2)
|
||||
|
||||
def test_randn():
|
||||
x = np.matlib.randn(3)
|
||||
# check matrix type, array would have shape (3,)
|
||||
assert_(x.ndim == 2)
|
||||
|
||||
def test_repmat():
|
||||
a1 = np.arange(4)
|
||||
x = numpy.matlib.repmat(a1, 2, 2)
|
||||
y = np.array([[0, 1, 2, 3, 0, 1, 2, 3],
|
||||
[0, 1, 2, 3, 0, 1, 2, 3]])
|
||||
assert_array_equal(x, y)
|
||||
@@ -1,19 +0,0 @@
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
import re
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_
|
||||
|
||||
|
||||
def test_valid_numpy_version():
|
||||
# Verify that the numpy version is a valid one (no .post suffix or other
|
||||
# nonsense). See gh-6431 for an issue caused by an invalid version.
|
||||
version_pattern = r"^[0-9]+\.[0-9]+\.[0-9]+(|a[0-9]|b[0-9]|rc[0-9])"
|
||||
dev_suffix = r"(\.dev0\+([0-9a-f]{7}|Unknown))"
|
||||
if np.version.release:
|
||||
res = re.match(version_pattern, np.__version__)
|
||||
else:
|
||||
res = re.match(version_pattern + dev_suffix, np.__version__)
|
||||
|
||||
assert_(res is not None, np.__version__)
|
||||
@@ -1,89 +0,0 @@
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
import sys
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
try:
|
||||
import ctypes
|
||||
except ImportError:
|
||||
ctypes = None
|
||||
|
||||
def check_dir(module, module_name=None):
|
||||
"""Returns a mapping of all objects with the wrong __module__ attribute."""
|
||||
if module_name is None:
|
||||
module_name = module.__name__
|
||||
results = {}
|
||||
for name in dir(module):
|
||||
item = getattr(module, name)
|
||||
if (hasattr(item, '__module__') and hasattr(item, '__name__')
|
||||
and item.__module__ != module_name):
|
||||
results[name] = item.__module__ + '.' + item.__name__
|
||||
return results
|
||||
|
||||
|
||||
@pytest.mark.skipif(
|
||||
sys.version_info[0] < 3,
|
||||
reason="NumPy exposes slightly different functions on Python 2")
|
||||
def test_numpy_namespace():
|
||||
# None of these objects are publicly documented.
|
||||
undocumented = {
|
||||
'Tester': 'numpy.testing._private.nosetester.NoseTester',
|
||||
'_add_newdoc_ufunc': 'numpy.core._multiarray_umath._add_newdoc_ufunc',
|
||||
'add_docstring': 'numpy.core._multiarray_umath.add_docstring',
|
||||
'add_newdoc': 'numpy.core.function_base.add_newdoc',
|
||||
'add_newdoc_ufunc': 'numpy.core._multiarray_umath._add_newdoc_ufunc',
|
||||
'byte_bounds': 'numpy.lib.utils.byte_bounds',
|
||||
'compare_chararrays': 'numpy.core._multiarray_umath.compare_chararrays',
|
||||
'deprecate': 'numpy.lib.utils.deprecate',
|
||||
'deprecate_with_doc': 'numpy.lib.utils.<lambda>',
|
||||
'disp': 'numpy.lib.function_base.disp',
|
||||
'fastCopyAndTranspose': 'numpy.core._multiarray_umath._fastCopyAndTranspose',
|
||||
'get_array_wrap': 'numpy.lib.shape_base.get_array_wrap',
|
||||
'get_include': 'numpy.lib.utils.get_include',
|
||||
'int_asbuffer': 'numpy.core._multiarray_umath.int_asbuffer',
|
||||
'mafromtxt': 'numpy.lib.npyio.mafromtxt',
|
||||
'maximum_sctype': 'numpy.core.numerictypes.maximum_sctype',
|
||||
'ndfromtxt': 'numpy.lib.npyio.ndfromtxt',
|
||||
'recfromcsv': 'numpy.lib.npyio.recfromcsv',
|
||||
'recfromtxt': 'numpy.lib.npyio.recfromtxt',
|
||||
'safe_eval': 'numpy.lib.utils.safe_eval',
|
||||
'set_string_function': 'numpy.core.arrayprint.set_string_function',
|
||||
'show_config': 'numpy.__config__.show',
|
||||
'who': 'numpy.lib.utils.who',
|
||||
}
|
||||
# These built-in types are re-exported by numpy.
|
||||
builtins = {
|
||||
'bool': 'builtins.bool',
|
||||
'complex': 'builtins.complex',
|
||||
'float': 'builtins.float',
|
||||
'int': 'builtins.int',
|
||||
'long': 'builtins.int',
|
||||
'object': 'builtins.object',
|
||||
'str': 'builtins.str',
|
||||
'unicode': 'builtins.str',
|
||||
}
|
||||
whitelist = dict(undocumented, **builtins)
|
||||
bad_results = check_dir(np)
|
||||
# pytest gives better error messages with the builtin assert than with
|
||||
# assert_equal
|
||||
assert bad_results == whitelist
|
||||
|
||||
|
||||
def test_numpy_linalg():
|
||||
bad_results = check_dir(np.linalg)
|
||||
assert bad_results == {}
|
||||
|
||||
|
||||
def test_numpy_fft():
|
||||
bad_results = check_dir(np.fft)
|
||||
assert bad_results == {}
|
||||
|
||||
@pytest.mark.skipif(ctypes is None,
|
||||
reason="ctypes not available in this python")
|
||||
def test_NPY_NO_EXPORT():
|
||||
cdll = ctypes.CDLL(np.core._multiarray_tests.__file__)
|
||||
# Make sure an arbitrary NPY_NO_EXPORT function is actually hidden
|
||||
f = getattr(cdll, 'test_not_exported', None)
|
||||
assert f is None, ("'test_not_exported' is mistakenly exported, "
|
||||
"NPY_NO_EXPORT does not work")
|
||||
@@ -1,38 +0,0 @@
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
import sys
|
||||
|
||||
from numpy.testing import assert_raises, assert_, assert_equal
|
||||
from numpy.core.numeric import pickle
|
||||
|
||||
if sys.version_info[:2] >= (3, 4):
|
||||
from importlib import reload
|
||||
else:
|
||||
from imp import reload
|
||||
|
||||
def test_numpy_reloading():
|
||||
# gh-7844. Also check that relevant globals retain their identity.
|
||||
import numpy as np
|
||||
import numpy._globals
|
||||
|
||||
_NoValue = np._NoValue
|
||||
VisibleDeprecationWarning = np.VisibleDeprecationWarning
|
||||
ModuleDeprecationWarning = np.ModuleDeprecationWarning
|
||||
|
||||
reload(np)
|
||||
assert_(_NoValue is np._NoValue)
|
||||
assert_(ModuleDeprecationWarning is np.ModuleDeprecationWarning)
|
||||
assert_(VisibleDeprecationWarning is np.VisibleDeprecationWarning)
|
||||
|
||||
assert_raises(RuntimeError, reload, numpy._globals)
|
||||
reload(np)
|
||||
assert_(_NoValue is np._NoValue)
|
||||
assert_(ModuleDeprecationWarning is np.ModuleDeprecationWarning)
|
||||
assert_(VisibleDeprecationWarning is np.VisibleDeprecationWarning)
|
||||
|
||||
def test_novalue():
|
||||
import numpy as np
|
||||
for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
|
||||
assert_equal(repr(np._NoValue), '<no value>')
|
||||
assert_(pickle.loads(pickle.dumps(np._NoValue,
|
||||
protocol=proto)) is np._NoValue)
|
||||
@@ -1,99 +0,0 @@
|
||||
""" Test scripts
|
||||
|
||||
Test that we can run executable scripts that have been installed with numpy.
|
||||
"""
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import sys
|
||||
import os
|
||||
import pytest
|
||||
from os.path import join as pathjoin, isfile, dirname
|
||||
from subprocess import Popen, PIPE
|
||||
|
||||
import numpy as np
|
||||
from numpy.compat.py3k import basestring
|
||||
from numpy.testing import assert_, assert_equal
|
||||
|
||||
is_inplace = isfile(pathjoin(dirname(np.__file__), '..', 'setup.py'))
|
||||
|
||||
|
||||
def run_command(cmd, check_code=True):
|
||||
""" Run command sequence `cmd` returning exit code, stdout, stderr
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cmd : str or sequence
|
||||
string with command name or sequence of strings defining command
|
||||
check_code : {True, False}, optional
|
||||
If True, raise error for non-zero return code
|
||||
|
||||
Returns
|
||||
-------
|
||||
returncode : int
|
||||
return code from execution of `cmd`
|
||||
stdout : bytes (python 3) or str (python 2)
|
||||
stdout from `cmd`
|
||||
stderr : bytes (python 3) or str (python 2)
|
||||
stderr from `cmd`
|
||||
|
||||
Raises
|
||||
------
|
||||
RuntimeError
|
||||
If `check_code` is True, and return code !=0
|
||||
"""
|
||||
cmd = [cmd] if isinstance(cmd, basestring) else list(cmd)
|
||||
if os.name == 'nt':
|
||||
# Quote any arguments with spaces. The quotes delimit the arguments
|
||||
# on Windows, and the arguments might be file paths with spaces.
|
||||
# On Unix the list elements are each separate arguments.
|
||||
cmd = ['"{0}"'.format(c) if ' ' in c else c for c in cmd]
|
||||
proc = Popen(cmd, stdout=PIPE, stderr=PIPE)
|
||||
stdout, stderr = proc.communicate()
|
||||
if proc.poll() is None:
|
||||
proc.terminate()
|
||||
if check_code and proc.returncode != 0:
|
||||
raise RuntimeError('\n'.join(
|
||||
['Command "{0}" failed with',
|
||||
'stdout', '------', '{1}', '',
|
||||
'stderr', '------', '{2}']).format(cmd, stdout, stderr))
|
||||
return proc.returncode, stdout, stderr
|
||||
|
||||
|
||||
@pytest.mark.skipif(is_inplace, reason="Cannot test f2py command inplace")
|
||||
@pytest.mark.xfail(reason="Test is unreliable")
|
||||
def test_f2py():
|
||||
# test that we can run f2py script
|
||||
|
||||
def try_f2py_commands(cmds):
|
||||
success = 0
|
||||
for f2py_cmd in cmds:
|
||||
try:
|
||||
code, stdout, stderr = run_command([f2py_cmd, '-v'])
|
||||
assert_equal(stdout.strip(), b'2')
|
||||
success += 1
|
||||
except Exception:
|
||||
pass
|
||||
return success
|
||||
|
||||
if sys.platform == 'win32':
|
||||
# Only the single 'f2py' script is installed in windows.
|
||||
exe_dir = dirname(sys.executable)
|
||||
if exe_dir.endswith('Scripts'): # virtualenv
|
||||
f2py_cmds = [os.path.join(exe_dir, 'f2py')]
|
||||
else:
|
||||
f2py_cmds = [os.path.join(exe_dir, "Scripts", 'f2py')]
|
||||
success = try_f2py_commands(f2py_cmds)
|
||||
msg = "Warning: f2py not found in path"
|
||||
assert_(success == 1, msg)
|
||||
else:
|
||||
# Three scripts are installed in Unix-like systems:
|
||||
# 'f2py', 'f2py{major}', and 'f2py{major.minor}'. For example,
|
||||
# if installed with python3.7 the scripts would be named
|
||||
# 'f2py', 'f2py3', and 'f2py3.7'.
|
||||
version = sys.version_info
|
||||
major = str(version.major)
|
||||
minor = str(version.minor)
|
||||
f2py_cmds = ('f2py', 'f2py' + major, 'f2py' + major + '.' + minor)
|
||||
success = try_f2py_commands(f2py_cmds)
|
||||
msg = "Warning: not all of %s, %s, and %s are found in path" % f2py_cmds
|
||||
assert_(success == 3, msg)
|
||||
@@ -1,78 +0,0 @@
|
||||
"""
|
||||
Tests which scan for certain occurrences in the code, they may not find
|
||||
all of these occurrences but should catch almost all.
|
||||
"""
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
import sys
|
||||
import pytest
|
||||
|
||||
if sys.version_info >= (3, 4):
|
||||
from pathlib import Path
|
||||
import ast
|
||||
import tokenize
|
||||
import numpy
|
||||
|
||||
class ParseCall(ast.NodeVisitor):
|
||||
def __init__(self):
|
||||
self.ls = []
|
||||
|
||||
def visit_Attribute(self, node):
|
||||
ast.NodeVisitor.generic_visit(self, node)
|
||||
self.ls.append(node.attr)
|
||||
|
||||
def visit_Name(self, node):
|
||||
self.ls.append(node.id)
|
||||
|
||||
|
||||
class FindFuncs(ast.NodeVisitor):
|
||||
def __init__(self, filename):
|
||||
super().__init__()
|
||||
self.__filename = filename
|
||||
|
||||
def visit_Call(self, node):
|
||||
p = ParseCall()
|
||||
p.visit(node.func)
|
||||
ast.NodeVisitor.generic_visit(self, node)
|
||||
|
||||
if p.ls[-1] == 'simplefilter' or p.ls[-1] == 'filterwarnings':
|
||||
if node.args[0].s == "ignore":
|
||||
raise AssertionError(
|
||||
"ignore filter should not be used; found in "
|
||||
"{} on line {}".format(self.__filename, node.lineno))
|
||||
|
||||
if p.ls[-1] == 'warn' and (
|
||||
len(p.ls) == 1 or p.ls[-2] == 'warnings'):
|
||||
|
||||
if "testing/tests/test_warnings.py" is self.__filename:
|
||||
# This file
|
||||
return
|
||||
|
||||
# See if stacklevel exists:
|
||||
if len(node.args) == 3:
|
||||
return
|
||||
args = {kw.arg for kw in node.keywords}
|
||||
if "stacklevel" in args:
|
||||
return
|
||||
raise AssertionError(
|
||||
"warnings should have an appropriate stacklevel; found in "
|
||||
"{} on line {}".format(self.__filename, node.lineno))
|
||||
|
||||
|
||||
@pytest.mark.slow
|
||||
def test_warning_calls():
|
||||
# combined "ignore" and stacklevel error
|
||||
base = Path(numpy.__file__).parent
|
||||
|
||||
for path in base.rglob("*.py"):
|
||||
if base / "testing" in path.parents:
|
||||
continue
|
||||
if path == base / "__init__.py":
|
||||
continue
|
||||
if path == base / "random" / "__init__.py":
|
||||
continue
|
||||
# use tokenize to auto-detect encoding on systems where no
|
||||
# default encoding is defined (e.g. LANG='C')
|
||||
with tokenize.open(str(path)) as file:
|
||||
tree = ast.parse(file.read())
|
||||
FindFuncs(path).visit(tree)
|
||||
Reference in New Issue
Block a user