Adding __array_function__ so that Numpy calls with dparrays work. (#261)

* Calling numpy.sum with a dparray should work now.  __array_function__ is now implemented.  I changed the way that we determine if a class or function is defined in this file from using eval to getting the module from sys.modules[__name__] and then using hasattr on the module.

* Efficiency improvements

1. Create class_list, function_list in one pass over members of np module
2. Renamed isdef into _isdef, since it is an internal function
3. Create certain objects in __array_function__ only if we intend to use
   them.

* Darkened numpy_with_usm_shared.py with black

* account of C-API defined functions of NumPy

* Don't need atypes since that just verified it was the same as the types argument.  Don't need fatypes since it wasn't being used.

* black changes

* Don't need explicit if debug once we get rid of atypes calculation.  That allows dprint to move left and back to one line.

Co-authored-by: Oleksandr Pavlyk <oleksandr.pavlyk@intel.com>

Author: DrTodd13

dpctl/dptensor/numpy_usm_shared.py

@@ -35,6 +35,7 @@
 import inspect
 import dpctl
 from dpctl.memory import MemoryUSMShared
+import builtins
 
 debug = False
 
@@ -45,8 +46,15 @@ def dprint(*args):
         sys.stdout.flush()
 
 
-functions_list = [o[0] for o in getmembers(np) if isfunction(o[1]) or isbuiltin(o[1])]
-class_list = [o for o in getmembers(np) if isclass(o[1])]
+functions_list = []
+class_list = []
+for o in getmembers(np):
+    s = o[1]
+    if isfunction(s) or isbuiltin(s):
+        functions_list.append(o[0])
+    elif isclass(s):
+        class_list.append(o)
+
 
 array_interface_property = "__sycl_usm_array_interface__"
 
@@ -90,7 +98,9 @@ def __new__(
             nelems = np.prod(shape)
             dt = np.dtype(dtype)
             isz = dt.itemsize
-            nbytes = int(isz * max(1, nelems))
+            # Have to use builtins.max explicitly since this module will
+            # import numpy's max function.
+            nbytes = int(isz * builtins.max(1, nelems))
             buf = MemoryUSMShared(nbytes)
             new_obj = np.ndarray.__new__(
                 subtype,
@@ -224,7 +234,7 @@ def __array_finalize__(self, obj):
 
     # Convert to a NumPy ndarray.
     def as_ndarray(self):
-        return np.copy(self)
+        return np.copy(np.ndarray(self.shape, self.dtype, self))
 
     def __array__(self):
         return self
@@ -277,18 +287,26 @@ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
         else:
             return NotImplemented
 
+    def __array_function__(self, func, types, args, kwargs):
+        fname = func.__name__
+        has_func = _isdef(fname)
+        dprint("__array_function__:", func, fname, type(func), types, has_func)
+        if has_func:
+            cm = sys.modules[__name__]
+            affunc = getattr(cm, fname)
+            fargs = [x.view(np.ndarray) if isinstance(x, ndarray) else x for x in args]
+            return affunc(*fargs, **kwargs)
+        return NotImplemented
 
-def isdef(x):
-    try:
-        eval(x)
-        return True
-    except NameError:
-        return False
+
+def _isdef(x):
+    cm = sys.modules[__name__]
+    return hasattr(cm, x)
 
 
 for c in class_list:
     cname = c[0]
-    if isdef(cname):
+    if _isdef(cname):
         continue
     # For now we do the simple thing and copy the types from NumPy module
     # into numpy_usm_shared module.
@@ -305,7 +323,7 @@ def isdef(x):
 # instead.  This is a stop-gap.  We should eventually find a
 # way to do the allocation correct to start with.
 for fname in functions_list:
-    if isdef(fname):
+    if _isdef(fname):
         continue
     new_func = "def %s(*args, **kwargs):\n" % fname
     new_func += "    ret = np.%s(*args, **kwargs)\n" % fname
@@ -321,4 +339,4 @@ def from_ndarray(x):
 
 
 def as_ndarray(x):
-    return np.copy(x)
+    return np.copy(np.ndarray(x.shape, x.dtype, x))

dpctl/tests/test_dparray.py

@@ -72,7 +72,6 @@ def test_numpy_ravel_with_dparray(self):
         res = numpy.ravel(self.X)
         self.assertEqual(res.shape, (1024,))
 
-    @unittest.expectedFailure
     def test_numpy_sum_with_dparray(self):
         res = numpy.sum(self.X)
         self.assertEqual(res, 1024.0)