Source: libgpuarray Version: 0.7.6-11 Severity: serious X-Debbugs-CC: nu...@packages.debian.org Tags: sid bookworm User: debian...@lists.debian.org Usertags: needs-update Control: affects -1 src:numpy
Dear maintainer(s),With a recent upload of numpy the autopkgtest of libgpuarray fails in testing when that autopkgtest is run with the binary packages of numpy from unstable. It passes when run with only packages from testing. In tabular form:
pass fail
numpy from testing 1:1.23.5-2
libgpuarray from testing 0.7.6-11
all others from testing from testing
I copied some of the output at the bottom of this report.
Currently this regression is blocking the migration of numpy to testing
[1]. Of course, numpy shouldn't just break your autopkgtest (or even
worse, your package), but it seems to me that the change in numpy was
intended and your package needs to update to the new situation.
If this is a real problem in your package (and not only in your autopkgtest), the right binary package(s) from numpy should really add a versioned Breaks on the unfixed version of (one of your) package(s). Note: the Breaks is nice even if the issue is only in the autopkgtest as it helps the migration software to figure out the right versions to combine in the tests.
More information about this bug and the reason for filing it can be found on https://wiki.debian.org/ContinuousIntegration/RegressionEmailInformation Paul [1] https://qa.debian.org/excuses.php?package=numpy https://ci.debian.net/data/autopkgtest/testing/amd64/libg/libgpuarray/29465793/log.gz=================================== FAILURES =================================== __________________________________ test_zeros __________________________________
def test_zeros():
for shp in [(), (0,), (5,),
(0, 0), (1, 0), (0, 1), (6, 7),
(0, 0, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1),
(4, 8, 9), (1, 8, 9)]:
for order in ["C", "F"]:
for dtype in dtypes_all:
zeros(shp, order, dtype)
/usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:224: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3/dist-packages/pygpu/tests/support.py:44: in f
func(*args, **kwargs)
/usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:231: in zeros
check_all(x, y)
/usr/lib/python3/dist-packages/pygpu/tests/support.py:108: in check_all
check_meta(x, y)
/usr/lib/python3/dist-packages/pygpu/tests/support.py:104: in check_meta
check_flags(x, y)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_ _ _ _
x = gpuarray.array(0., dtype=float32), y = array(0., dtype=float32)
def check_flags(x, y):
assert isinstance(x, gpuarray.GpuArray)
if y.size == 0 and y.flags["C_CONTIGUOUS"] and
y.flags["F_CONTIGUOUS"]:
# Different numpy version have different value for
# C_CONTIGUOUS in that case.
pass
elif x.flags["C_CONTIGUOUS"] != y.flags["C_CONTIGUOUS"]:
# Numpy 1.10 can set c/f contiguous more frequently by
# ignoring strides on dimensions of size 1.
assert x.flags["C_CONTIGUOUS"] is True, (x.flags, y.flags)
assert x.flags["F_CONTIGUOUS"] is False, (x.flags, y.flags)
assert y.flags["C_CONTIGUOUS"] is False, (x.flags, y.flags)
# That depend of numpy version.
# assert y.flags["F_CONTIGUOUS"] is True, (x.flags, y.flags)
else:
if not (skip_single_f and x.shape == ()):
# Numpy below 1.6.0 does not have a consistent handling of
# f-contiguous for 0-d arrays
if not any([s == 1 for s in x.shape]):
# Numpy 1.10 can set f contiguous more frequently by
# ignoring strides on dimensions of size 1.
assert x.flags["F_CONTIGUOUS"] ==
y.flags["F_CONTIGUOUS"], (
x.flags, y.flags)
else:
assert x.flags["F_CONTIGUOUS"]
assert x.flags["WRITEABLE"] == y.flags["WRITEABLE"], (x.flags,
y.flags)
# Don't check for OWNDATA since it is always true for a GpuArray
assert x.flags["ALIGNED"] == y.flags["ALIGNED"], (x.flags, y.flags)
assert x.flags["UPDATEIFCOPY"] == y.flags["UPDATEIFCOPY"], (x.flags,
y.flags) E KeyError: 'Unknown flag' /usr/lib/python3/dist-packages/pygpu/tests/support.py:85: KeyError_____________________________ test_zeros_no_dtype ______________________________
def test_zeros_no_dtype():
# no dtype and order param
x = pygpu.zeros((), context=ctx)
y = numpy.zeros(())
check_meta(x, y)
/usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:238: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3/dist-packages/pygpu/tests/support.py:104: in check_meta
check_flags(x, y)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_ _ _ _
x = gpuarray.array(0.), y = array(0.)
def check_flags(x, y):
assert isinstance(x, gpuarray.GpuArray)
if y.size == 0 and y.flags["C_CONTIGUOUS"] and
y.flags["F_CONTIGUOUS"]:
# Different numpy version have different value for
# C_CONTIGUOUS in that case.
pass
elif x.flags["C_CONTIGUOUS"] != y.flags["C_CONTIGUOUS"]:
# Numpy 1.10 can set c/f contiguous more frequently by
# ignoring strides on dimensions of size 1.
assert x.flags["C_CONTIGUOUS"] is True, (x.flags, y.flags)
assert x.flags["F_CONTIGUOUS"] is False, (x.flags, y.flags)
assert y.flags["C_CONTIGUOUS"] is False, (x.flags, y.flags)
# That depend of numpy version.
# assert y.flags["F_CONTIGUOUS"] is True, (x.flags, y.flags)
else:
if not (skip_single_f and x.shape == ()):
# Numpy below 1.6.0 does not have a consistent handling of
# f-contiguous for 0-d arrays
if not any([s == 1 for s in x.shape]):
# Numpy 1.10 can set f contiguous more frequently by
# ignoring strides on dimensions of size 1.
assert x.flags["F_CONTIGUOUS"] ==
y.flags["F_CONTIGUOUS"], (
x.flags, y.flags)
else:
assert x.flags["F_CONTIGUOUS"]
assert x.flags["WRITEABLE"] == y.flags["WRITEABLE"], (x.flags,
y.flags)
# Don't check for OWNDATA since it is always true for a GpuArray
assert x.flags["ALIGNED"] == y.flags["ALIGNED"], (x.flags, y.flags)
assert x.flags["UPDATEIFCOPY"] == y.flags["UPDATEIFCOPY"], (x.flags,
y.flags) E KeyError: 'Unknown flag' /usr/lib/python3/dist-packages/pygpu/tests/support.py:85: KeyError__________________________________ test_empty __________________________________
def test_empty():
for shp in [(), (0,), (5,),
(0, 0), (1, 0), (0, 1), (6, 7),
(0, 0, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1),
(4, 8, 9), (1, 8, 9)]:
for order in ["C", "F"]:
for dtype in dtypes_all:
empty(shp, order, dtype)
/usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:256: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:262: in empty
check_meta(x, y)
/usr/lib/python3/dist-packages/pygpu/tests/support.py:104: in check_meta
check_flags(x, y)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_ _ _ _
x = gpuarray.array(6.9469713e+22, dtype=float32), y = array(0.,
dtype=float32)
def check_flags(x, y):
assert isinstance(x, gpuarray.GpuArray)
if y.size == 0 and y.flags["C_CONTIGUOUS"] and
y.flags["F_CONTIGUOUS"]:
# Different numpy version have different value for
# C_CONTIGUOUS in that case.
pass
elif x.flags["C_CONTIGUOUS"] != y.flags["C_CONTIGUOUS"]:
# Numpy 1.10 can set c/f contiguous more frequently by
# ignoring strides on dimensions of size 1.
assert x.flags["C_CONTIGUOUS"] is True, (x.flags, y.flags)
assert x.flags["F_CONTIGUOUS"] is False, (x.flags, y.flags)
assert y.flags["C_CONTIGUOUS"] is False, (x.flags, y.flags)
# That depend of numpy version.
# assert y.flags["F_CONTIGUOUS"] is True, (x.flags, y.flags)
else:
if not (skip_single_f and x.shape == ()):
# Numpy below 1.6.0 does not have a consistent handling of
# f-contiguous for 0-d arrays
if not any([s == 1 for s in x.shape]):
# Numpy 1.10 can set f contiguous more frequently by
# ignoring strides on dimensions of size 1.
assert x.flags["F_CONTIGUOUS"] ==
y.flags["F_CONTIGUOUS"], (
x.flags, y.flags)
else:
assert x.flags["F_CONTIGUOUS"]
assert x.flags["WRITEABLE"] == y.flags["WRITEABLE"], (x.flags,
y.flags)
# Don't check for OWNDATA since it is always true for a GpuArray
assert x.flags["ALIGNED"] == y.flags["ALIGNED"], (x.flags, y.flags)
assert x.flags["UPDATEIFCOPY"] == y.flags["UPDATEIFCOPY"], (x.flags,
y.flags) E KeyError: 'Unknown flag' /usr/lib/python3/dist-packages/pygpu/tests/support.py:85: KeyError_____________________________ test_empty_no_dtype ______________________________
def test_empty_no_dtype():
x = pygpu.empty((), context=ctx) # no dtype and order param
y = numpy.empty(())
check_meta(x, y)
/usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:268: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3/dist-packages/pygpu/tests/support.py:104: in check_meta
check_flags(x, y)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_ _ _ _
x = gpuarray.array(6.92047276e-310), y = array(0.)
def check_flags(x, y):
assert isinstance(x, gpuarray.GpuArray)
if y.size == 0 and y.flags["C_CONTIGUOUS"] and
y.flags["F_CONTIGUOUS"]:
# Different numpy version have different value for
# C_CONTIGUOUS in that case.
pass
elif x.flags["C_CONTIGUOUS"] != y.flags["C_CONTIGUOUS"]:
# Numpy 1.10 can set c/f contiguous more frequently by
# ignoring strides on dimensions of size 1.
assert x.flags["C_CONTIGUOUS"] is True, (x.flags, y.flags)
assert x.flags["F_CONTIGUOUS"] is False, (x.flags, y.flags)
assert y.flags["C_CONTIGUOUS"] is False, (x.flags, y.flags)
# That depend of numpy version.
# assert y.flags["F_CONTIGUOUS"] is True, (x.flags, y.flags)
else:
if not (skip_single_f and x.shape == ()):
# Numpy below 1.6.0 does not have a consistent handling of
# f-contiguous for 0-d arrays
if not any([s == 1 for s in x.shape]):
# Numpy 1.10 can set f contiguous more frequently by
# ignoring strides on dimensions of size 1.
assert x.flags["F_CONTIGUOUS"] ==
y.flags["F_CONTIGUOUS"], (
x.flags, y.flags)
else:
assert x.flags["F_CONTIGUOUS"]
assert x.flags["WRITEABLE"] == y.flags["WRITEABLE"], (x.flags,
y.flags)
# Don't check for OWNDATA since it is always true for a GpuArray
assert x.flags["ALIGNED"] == y.flags["ALIGNED"], (x.flags, y.flags)
assert x.flags["UPDATEIFCOPY"] == y.flags["UPDATEIFCOPY"], (x.flags,
y.flags) E KeyError: 'Unknown flag' /usr/lib/python3/dist-packages/pygpu/tests/support.py:85: KeyError________________________________ test_copy_view ________________________________
def test_copy_view():
for shp in [(5,), (6, 7), (4, 8, 9), (1, 8, 9)]:
for dtype in dtypes_all:
for offseted in [False, True]:
# order1 is the order of the original data
for order1 in ['c', 'f']:
# order2 is the order wanted after copy
for order2 in ['c', 'f']:
copy_view(shp, dtype, offseted, order1, order2)
/usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:418: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3/dist-packages/pygpu/tests/support.py:44: in f
func(*args, **kwargs)
/usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:432: in
copy_view
check_flags(b, a)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_ _ _ _
x = gpuarray.array([6.577139 , 9.87112 , 2.1727731, 2.7597797, 5.5552626],
dtype=float32)
y = array([6.577139 , 9.87112 , 2.1727731, 2.7597797, 5.5552626],
dtype=float32)
def check_flags(x, y):
assert isinstance(x, gpuarray.GpuArray)
if y.size == 0 and y.flags["C_CONTIGUOUS"] and
y.flags["F_CONTIGUOUS"]:
# Different numpy version have different value for
# C_CONTIGUOUS in that case.
pass
elif x.flags["C_CONTIGUOUS"] != y.flags["C_CONTIGUOUS"]:
# Numpy 1.10 can set c/f contiguous more frequently by
# ignoring strides on dimensions of size 1.
assert x.flags["C_CONTIGUOUS"] is True, (x.flags, y.flags)
assert x.flags["F_CONTIGUOUS"] is False, (x.flags, y.flags)
assert y.flags["C_CONTIGUOUS"] is False, (x.flags, y.flags)
# That depend of numpy version.
# assert y.flags["F_CONTIGUOUS"] is True, (x.flags, y.flags)
else:
if not (skip_single_f and x.shape == ()):
# Numpy below 1.6.0 does not have a consistent handling of
# f-contiguous for 0-d arrays
if not any([s == 1 for s in x.shape]):
# Numpy 1.10 can set f contiguous more frequently by
# ignoring strides on dimensions of size 1.
assert x.flags["F_CONTIGUOUS"] ==
y.flags["F_CONTIGUOUS"], (
x.flags, y.flags)
else:
assert x.flags["F_CONTIGUOUS"]
assert x.flags["WRITEABLE"] == y.flags["WRITEABLE"], (x.flags,
y.flags)
# Don't check for OWNDATA since it is always true for a GpuArray
assert x.flags["ALIGNED"] == y.flags["ALIGNED"], (x.flags, y.flags)
assert x.flags["UPDATEIFCOPY"] == y.flags["UPDATEIFCOPY"], (x.flags,
y.flags) E KeyError: 'Unknown flag' /usr/lib/python3/dist-packages/pygpu/tests/support.py:85: KeyError_________________________________ test_strides _________________________________
def test_strides():
strides_((4, 4), 'c', 1, (4, 4))
/usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:501: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:523: in strides_
check_flags(ag, ac)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_ _ _ _
x = gpuarray.array([[6.5308642, 2.6379592, 4.781131 , 8.922989 ],
[2.6379592, 4.781131 , 8.922989 , 4.7629447],
[4.781131 , 8.922989 , 4.7629447, 4.8445716],
[8.922989 , 4.7629447, 4.8445716, 3.7906039]], dtype=float32)
y = array([[6.5308642, 2.6379592, 4.781131 , 8.922989 ],
[2.6379592, 4.781131 , 8.922989 , 4.7629447],
[4.781131 , 8.922989 , 4.7629447, 4.8445716],
[8.922989 , 4.7629447, 4.8445716, 3.7906039]], dtype=float32)
def check_flags(x, y):
assert isinstance(x, gpuarray.GpuArray)
if y.size == 0 and y.flags["C_CONTIGUOUS"] and
y.flags["F_CONTIGUOUS"]:
# Different numpy version have different value for
# C_CONTIGUOUS in that case.
pass
elif x.flags["C_CONTIGUOUS"] != y.flags["C_CONTIGUOUS"]:
# Numpy 1.10 can set c/f contiguous more frequently by
# ignoring strides on dimensions of size 1.
assert x.flags["C_CONTIGUOUS"] is True, (x.flags, y.flags)
assert x.flags["F_CONTIGUOUS"] is False, (x.flags, y.flags)
assert y.flags["C_CONTIGUOUS"] is False, (x.flags, y.flags)
# That depend of numpy version.
# assert y.flags["F_CONTIGUOUS"] is True, (x.flags, y.flags)
else:
if not (skip_single_f and x.shape == ()):
# Numpy below 1.6.0 does not have a consistent handling of
# f-contiguous for 0-d arrays
if not any([s == 1 for s in x.shape]):
# Numpy 1.10 can set f contiguous more frequently by
# ignoring strides on dimensions of size 1.
assert x.flags["F_CONTIGUOUS"] ==
y.flags["F_CONTIGUOUS"], (
x.flags, y.flags)
else:
assert x.flags["F_CONTIGUOUS"]
assert x.flags["WRITEABLE"] == y.flags["WRITEABLE"], (x.flags,
y.flags)
# Don't check for OWNDATA since it is always true for a GpuArray
assert x.flags["ALIGNED"] == y.flags["ALIGNED"], (x.flags, y.flags)
assert x.flags["UPDATEIFCOPY"] == y.flags["UPDATEIFCOPY"], (x.flags,
y.flags) E KeyError: 'Unknown flag' /usr/lib/python3/dist-packages/pygpu/tests/support.py:85: KeyError________________________________ test_transpose ________________________________
def test_transpose():
for shp in [(2, 3), (4, 8, 9), (1, 2, 3, 4)]:
for offseted in [True, False]:
for order in ['c', 'f']:
for sliced in [1, 2, -2, -1]:
transpose(shp, offseted, sliced, order)
/usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:532: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:544: in transpose
check_all(rg, rc)
/usr/lib/python3/dist-packages/pygpu/tests/support.py:108: in check_all
check_meta(x, y)
/usr/lib/python3/dist-packages/pygpu/tests/support.py:104: in check_meta
check_flags(x, y)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_ _ _ _
x = gpuarray.array([[9.744236 , 5.750002 ],
[5.644133 , 6.0290747],
[9.816432 , 0.9953682]], dtype=float32)
y = array([[9.744236 , 5.750002 ],
[5.644133 , 6.0290747],
[9.816432 , 0.9953682]], dtype=float32)
def check_flags(x, y):
assert isinstance(x, gpuarray.GpuArray)
if y.size == 0 and y.flags["C_CONTIGUOUS"] and
y.flags["F_CONTIGUOUS"]:
# Different numpy version have different value for
# C_CONTIGUOUS in that case.
pass
elif x.flags["C_CONTIGUOUS"] != y.flags["C_CONTIGUOUS"]:
# Numpy 1.10 can set c/f contiguous more frequently by
# ignoring strides on dimensions of size 1.
assert x.flags["C_CONTIGUOUS"] is True, (x.flags, y.flags)
assert x.flags["F_CONTIGUOUS"] is False, (x.flags, y.flags)
assert y.flags["C_CONTIGUOUS"] is False, (x.flags, y.flags)
# That depend of numpy version.
# assert y.flags["F_CONTIGUOUS"] is True, (x.flags, y.flags)
else:
if not (skip_single_f and x.shape == ()):
# Numpy below 1.6.0 does not have a consistent handling of
# f-contiguous for 0-d arrays
if not any([s == 1 for s in x.shape]):
# Numpy 1.10 can set f contiguous more frequently by
# ignoring strides on dimensions of size 1.
assert x.flags["F_CONTIGUOUS"] ==
y.flags["F_CONTIGUOUS"], (
x.flags, y.flags)
else:
assert x.flags["F_CONTIGUOUS"]
assert x.flags["WRITEABLE"] == y.flags["WRITEABLE"], (x.flags,
y.flags)
# Don't check for OWNDATA since it is always true for a GpuArray
assert x.flags["ALIGNED"] == y.flags["ALIGNED"], (x.flags, y.flags)
assert x.flags["UPDATEIFCOPY"] == y.flags["UPDATEIFCOPY"], (x.flags,
y.flags) E KeyError: 'Unknown flag' /usr/lib/python3/dist-packages/pygpu/tests/support.py:85: KeyError_____________________________ test_transpose_args ______________________________
def test_transpose_args():
ac, ag = gen_gpuarray((4, 3, 2), 'float32', ctx=ctx)
rc = ac.transpose(0, 2, 1)
rg = ag.transpose(0, 2, 1)
> check_all(rg, rc)
/usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:578: _ _
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_ _ /usr/lib/python3/dist-packages/pygpu/tests/support.py:108: in check_all
check_meta(x, y)
/usr/lib/python3/dist-packages/pygpu/tests/support.py:104: in check_meta
check_flags(x, y)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_ _ _ _
x = gpuarray.array([[[7.601046 , 6.2143316 , 9.204033 ],
[5.3891606 , 8.564767 , 1.0428411 ]],
[[0.5313...72122 ]],
[[5.6488976 , 5.199228 , 4.652574 ],
[6.455862 , 2.148168 , 3.5855646 ]]], dtype=float32)
y = array([[[7.601046 , 6.2143316 , 9.204033 ],
[5.3891606 , 8.564767 , 1.0428411 ]],
[[0.53139365, 4.3...72122 ]],
[[5.6488976 , 5.199228 , 4.652574 ],
[6.455862 , 2.148168 , 3.5855646 ]]], dtype=float32)
def check_flags(x, y):
assert isinstance(x, gpuarray.GpuArray)
if y.size == 0 and y.flags["C_CONTIGUOUS"] and
y.flags["F_CONTIGUOUS"]:
# Different numpy version have different value for
# C_CONTIGUOUS in that case.
pass
elif x.flags["C_CONTIGUOUS"] != y.flags["C_CONTIGUOUS"]:
# Numpy 1.10 can set c/f contiguous more frequently by
# ignoring strides on dimensions of size 1.
assert x.flags["C_CONTIGUOUS"] is True, (x.flags, y.flags)
assert x.flags["F_CONTIGUOUS"] is False, (x.flags, y.flags)
assert y.flags["C_CONTIGUOUS"] is False, (x.flags, y.flags)
# That depend of numpy version.
# assert y.flags["F_CONTIGUOUS"] is True, (x.flags, y.flags)
else:
if not (skip_single_f and x.shape == ()):
# Numpy below 1.6.0 does not have a consistent handling of
# f-contiguous for 0-d arrays
if not any([s == 1 for s in x.shape]):
# Numpy 1.10 can set f contiguous more frequently by
# ignoring strides on dimensions of size 1.
assert x.flags["F_CONTIGUOUS"] ==
y.flags["F_CONTIGUOUS"], (
x.flags, y.flags)
else:
assert x.flags["F_CONTIGUOUS"]
assert x.flags["WRITEABLE"] == y.flags["WRITEABLE"], (x.flags,
y.flags)
# Don't check for OWNDATA since it is always true for a GpuArray
assert x.flags["ALIGNED"] == y.flags["ALIGNED"], (x.flags, y.flags)
assert x.flags["UPDATEIFCOPY"] == y.flags["UPDATEIFCOPY"], (x.flags,
y.flags) E KeyError: 'Unknown flag' /usr/lib/python3/dist-packages/pygpu/tests/support.py:85: KeyError__________________________ test_mapping_getitem_w_int __________________________
def test_mapping_getitem_w_int():
for dtype in dtypes_all:
for offseted in [True, False]:
mapping_getitem_w_int(dtype, offseted)
/usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:598: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3/dist-packages/pygpu/tests/support.py:44: in f
func(*args, **kwargs)
/usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:607: in
mapping_getitem_w_int
_cmp(_a[...], a[...])
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_ _ _ _
x = gpuarray.array([2.8419876, 7.712318 ], dtype=float32)
y = array([2.8419876, 7.712318 ], dtype=float32)
def _cmp(x, y):
assert isinstance(x, GpuArray)
assert x.shape == y.shape
assert x.dtype == y.dtype
assert x.strides == y.strides
assert x.flags["C_CONTIGUOUS"] == y.flags["C_CONTIGUOUS"],
(x.flags,
y.flags)
if y.size == 0:
# F_CONTIGUOUS flags change definition with different numpy
version
# TODO: ideally, we should be F_CONTIGUOUS in that case.
pass
elif not (skip_single_f and y.shape == ()):
assert x.flags["F_CONTIGUOUS"] == y.flags["F_CONTIGUOUS"],
(x.flags,
y.flags)
else:
assert x.flags["F_CONTIGUOUS"]
# GpuArrays always own their data so don't check that flag.
if x.flags["WRITEABLE"] != y.flags["WRITEABLE"]:
assert x.ndim == 0
assert x.flags["ALIGNED"] == y.flags["ALIGNED"], (x.flags, y.flags)
assert x.flags["UPDATEIFCOPY"] == y.flags["UPDATEIFCOPY"], (x.flags,
y.flags) E KeyError: 'Unknown flag' /usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:688: KeyError__________________________________ test_flags __________________________________
def test_flags():
for fl in ['C', 'F', 'W', 'B', 'O', 'A', 'U', 'CA', 'FA',
'FNC', 'FORC',
'CARRAY', 'FARRAY', 'FORTRAN', 'BEHAVED', 'OWNDATA',
'ALIGNED',
'WRITEABLE', 'CONTIGUOUS', 'UPDATEIFCOPY',
'C_CONTIGUOUS',
'F_CONTIGUOUS']:
flag_dict(fl)
/usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:763: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
fl = 'U'
def flag_dict(fl):
c2, g2 = gen_gpuarray((2, 3), dtype='float32', ctx=ctx, order='c')
c3, g3 = gen_gpuarray((2, 3), dtype='float32', ctx=ctx, order='f')
> assert c2.flags[fl] == g2.flags[fl]
E KeyError: 'Unknown flag'
/usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:774: KeyError
=============================== warnings summary
===============================
../../../../usr/lib/python3/dist-packages/pygpu/dtypes.py:74/usr/lib/python3/dist-packages/pygpu/dtypes.py:74: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here. Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations
register_dtype(np.bool, ["ga_bool", "bool"])
test_gpu_ndarray.py::test_bool
test_gpu_ndarray.py::test_bool
/usr/lib/python3/dist-packages/pygpu/tests/test_gpu_ndarray.py:52:
DeprecationWarning: The truth value of an empty array is ambiguous.
Returning False, but in future this will result in an error. Use
`array.size > 0` to check that an array is not empty.
assert (bool(pygpu.asarray(data, context=ctx)) ==
-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
=========================== short test summary info
============================
FAILED test_gpu_ndarray.py::test_zeros - KeyError: 'Unknown flag' FAILED test_gpu_ndarray.py::test_zeros_no_dtype - KeyError: 'Unknown flag' FAILED test_gpu_ndarray.py::test_empty - KeyError: 'Unknown flag' FAILED test_gpu_ndarray.py::test_empty_no_dtype - KeyError: 'Unknown flag' FAILED test_gpu_ndarray.py::test_copy_view - KeyError: 'Unknown flag' FAILED test_gpu_ndarray.py::test_strides - KeyError: 'Unknown flag' FAILED test_gpu_ndarray.py::test_transpose - KeyError: 'Unknown flag' FAILED test_gpu_ndarray.py::test_transpose_args - KeyError: 'Unknown flag'FAILED test_gpu_ndarray.py::test_mapping_getitem_w_int - KeyError: 'Unknown f...
FAILED test_gpu_ndarray.py::test_flags - KeyError: 'Unknown flag'====== 10 failed, 62 passed, 11 skipped, 3 warnings in 270.42s (0:04:30) =======
autopkgtest [09:28:34]: test upstreamtests
OpenPGP_signature
Description: OpenPGP digital signature
