--- Begin Message ---
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
--- End Message ---
