address more comments

Author: vtavana

dpnp/dpnp_iface_manipulation.py

@@ -1945,8 +1945,7 @@ def repeat(a, repeats, axis=None):
 
 def require(a, dtype=None, requirements=None, *, like=None):
     """
-    Return a :class:`dpnp.ndarray` of the provided type that satisfies
-    requirements.
+    Return an dpnp.ndarray of the provided type that satisfies requirements.
 
     This function is useful to be sure that an array with the correct flags
     is returned for passing to compiled code (perhaps through ctypes).
@@ -1957,9 +1956,11 @@ def require(a, dtype=None, requirements=None, *, like=None):
     ----------
     a : array_like
        The object to be converted to a type-and-requirement-satisfying array.
-    dtype : {None, data-type}, optional
-       The required data-type. If ``None`` preserve the current dtype.
-    requirements : {None, str, sequence of str}, optional
+    dtype : data-type, optional
+       The required data-type. If None preserve the current dtype. If your
+       application requires the data to be in native byteorder, include
+       a byteorder specification as a part of the dtype specification.
+    requirements : {str, sequence of str}, , optional
        The requirements list can be any of the following:
 
        * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array
@@ -1979,7 +1980,7 @@ def require(a, dtype=None, requirements=None, *, like=None):
     See Also
     --------
     :obj:`dpnp.asarray` : Convert input to an ndarray.
-    :obj:`dpnp.asanyarray` : Convert to an ndarray, but pass through
+    :obj:`dpnp.asanyarray ` : Convert to an ndarray, but pass through
                         ndarray subclasses.
     :obj:`dpnp.ascontiguousarray` : Convert input to a contiguous array.
     :obj:`dpnp.asfortranarray` : Convert input to an ndarray with
@@ -1995,7 +1996,7 @@ def require(a, dtype=None, requirements=None, *, like=None):
     Examples
     --------
     >>> import dpnp as np
-    >>> x = np.arange(6).reshape(2, 3)
+    >>> x = np.arange(6).reshape(2,3)
     >>> x.flags
       C_CONTIGUOUS : True
       F_CONTIGUOUS : False
@@ -2023,7 +2024,14 @@ def require(a, dtype=None, requirements=None, *, like=None):
     if not requirements:
         return dpnp.asanyarray(a, dtype=dtype)
 
-    requirements = {possible_flags[x.upper()] for x in requirements}
+    try:
+        requirements = {possible_flags[x.upper()] for x in requirements}
+    except KeyError as exc:
+        incorrect_flag = (set(requirements) - set(possible_flags.keys())).pop()
+        raise ValueError(
+            f"Incorrect flag {incorrect_flag} in requirements"
+        ) from exc
+
     order = "A"
     if requirements.issuperset({"C", "F"}):
         raise ValueError("Cannot specify both 'C' and 'F' order")

tests/test_manipulation.py

@@ -671,8 +671,8 @@ class TestRequire:
     flag_names = ["C", "C_CONTIGUOUS", "F", "F_CONTIGUOUS", "W"]
 
     def generate_all_false(self, dtype):
-        a_np = numpy.zeros((10, 10))
-        a_dp = dpnp.zeros((10, 10))
+        a_np = numpy.zeros((10, 10), dtype=dtype)
+        a_dp = dpnp.zeros((10, 10), dtype=dtype)
         a_np = a_np[::2, ::2]
         a_dp = a_dp[::2, ::2]
         a_np.flags["W"] = False
@@ -704,7 +704,7 @@ def test_require_each(self):
     @pytest.mark.parametrize("xp", [numpy, dpnp])
     def test_unknown_requirement(self, xp):
         a = self.generate_all_false("f4")
-        assert_raises(KeyError, xp.require, a, None, "Q")
+        assert_raises((KeyError, ValueError), xp.require, a, None, "Q")
 
     def test_non_array_input(self):
         expected = numpy.require([1, 2, 3, 4], "i4", ["C", "W"])

tests/third_party/cupy/manipulation_tests/test_kind.py

@@ -118,12 +118,11 @@ def test_require_C_and_F_flags(self, dtype):
         with pytest.raises(ValueError):
             cupy.require(x, dtype, ["C", "F"])
 
-    @pytest.mark.skip("dpnp.require() does support requirement ['W']")
     @testing.for_all_dtypes()
     def test_require_incorrect_requirments(self, dtype):
         x = cupy.zeros((2, 3, 4), dtype=dtype)
         with pytest.raises(ValueError):
-            cupy.require(x, dtype, ["W"])
+            cupy.require(x, dtype, ["O"])
 
     @testing.for_all_dtypes()
     def test_require_incorrect_dtype(self, dtype):