fix comments

Author: vlad-perevezentsev

dpctl/__init__.pxd

@@ -29,4 +29,4 @@
 
 from dpctl._sycl_core cimport *
 from dpctl._memory import *
-from dparray import *
+from .dparray import *

dpctl/dparray.py

@@ -3,47 +3,55 @@
 from numbers import Number
 from types import FunctionType as ftype, BuiltinFunctionType as bftype
 import sys
-#import importlib
-#import functools
 import inspect
+import dpctl
+from dpctl.memory import MemoryUSMShared
 
 debug = False
 
+
 def dprint(*args):
     if debug:
         print(*args)
         sys.stdout.flush()
 
-import dpctl
-from dpctl.memory import MemoryUSMShared
 
 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])]
 
 array_interface_property = "__array_interface__"
+
+
 def has_array_interface(x):
     return hasattr(x, array_interface_property)
 
+
 class ndarray(np.ndarray):
     """
     numpy.ndarray subclass whose underlying memory buffer is allocated
     with a foreign allocator.
     """
-    def __new__(subtype, shape,
-                dtype=float, buffer=None, offset=0,
-                strides=None, order=None):
+
+    def __new__(
+        subtype, shape, dtype=float, buffer=None, offset=0, strides=None, order=None
+    ):
         # Create a new array.
         if buffer is None:
             dprint("dparray::ndarray __new__ buffer None")
             nelems = np.prod(shape)
             dt = np.dtype(dtype)
             isz = dt.itemsize
-            nbytes = int(isz*max(1, nelems))
+            nbytes = int(isz * max(1, nelems))
             buf = MemoryUSMShared(nbytes)
             new_obj = np.ndarray.__new__(
-                subtype, shape, dtype=dt,
-                buffer=buf, offset=0,
-                strides=strides, order=order)
+                subtype,
+                shape,
+                dtype=dt,
+                buffer=buf,
+                offset=0,
+                strides=strides,
+                order=order,
+            )
             if hasattr(new_obj, array_interface_property):
                 dprint("buffer None new_obj already has sycl_usm")
             else:
@@ -55,9 +63,14 @@ def __new__(subtype, shape,
             dprint("dparray::ndarray __new__ buffer", array_interface_property)
             # also check for array interface
             new_obj = np.ndarray.__new__(
-                subtype, shape, dtype=dtype,
-                buffer=buffer, offset=offset,
-                strides=strides, order=order)
+                subtype,
+                shape,
+                dtype=dtype,
+                buffer=buffer,
+                offset=offset,
+                strides=strides,
+                order=order,
+            )
             if hasattr(new_obj, array_interface_property):
                 dprint("buffer None new_obj already has sycl_usm")
             else:
@@ -68,17 +81,26 @@ def __new__(subtype, shape,
             dprint("dparray::ndarray __new__ buffer not None and not sycl_usm")
             nelems = np.prod(shape)
             # must copy
-            ar = np.ndarray(shape,
-                            dtype=dtype, buffer=buffer,
-                            offset=offset, strides=strides,
-                            order=order)
+            ar = np.ndarray(
+                shape,
+                dtype=dtype,
+                buffer=buffer,
+                offset=offset,
+                strides=strides,
+                order=order,
+            )
             nbytes = int(ar.nbytes)
             buf = MemoryUSMShared(nbytes)
             new_obj = np.ndarray.__new__(
-                subtype, shape, dtype=dtype,
-                buffer=buf, offset=0,
-                strides=strides, order=order)
-            np.copyto(new_obj, ar, casting='no')
+                subtype,
+                shape,
+                dtype=dtype,
+                buffer=buf,
+                offset=0,
+                strides=strides,
+                order=order,
+            )
+            np.copyto(new_obj, ar, casting="no")
             if hasattr(new_obj, array_interface_property):
                 dprint("buffer None new_obj already has sycl_usm")
             else:
@@ -89,7 +111,8 @@ def __new__(subtype, shape,
     def __array_finalize__(self, obj):
         dprint("__array_finalize__:", obj, hex(id(obj)), type(obj))
         # When called from the explicit constructor, obj is None
-        if obj is None: return
+        if obj is None:
+            return
         # When called in new-from-template, `obj` is another instance of our own
         # subclass, that we might use to update the new `self` instance.
         # However, when called from view casting, `obj` can be an instance of any
@@ -105,7 +128,11 @@ def __array_finalize__(self, obj):
                 dprint("external_allocator:", hex(ea), type(ea))
                 dprint("data:", hex(d), type(d))
                 dppl_rt_allocator = numba.dppl._dppl_rt.get_external_allocator()
-                dprint("dppl external_allocator:", hex(dppl_rt_allocator), type(dppl_rt_allocator))
+                dprint(
+                    "dppl external_allocator:",
+                    hex(dppl_rt_allocator),
+                    type(dppl_rt_allocator),
+                )
                 dprint(dir(mobj))
                 if ea == dppl_rt_allocator:
                     return
@@ -118,24 +145,26 @@ def __array_finalize__(self, obj):
                 if hasattr(obj, array_interface_property):
                     return
                 ob = ob.base
-    
+
         # Just raise an exception since __array_ufunc__ makes all reasonable cases not
         # need the code below.
-        raise ValueError("Non-USM allocated ndarray can not viewed as a USM-allocated one without a copy")
-      
+        raise ValueError(
+            "Non-USM allocated ndarray can not viewed as a USM-allocated one without a copy"
+        )
+
     # Tell Numba to not treat this type just like a NumPy ndarray but to propagate its type.
     # This way it will use the custom dparray allocator.
     __numba_no_subtype_ndarray__ = True
 
     # Convert to a NumPy ndarray.
     def as_ndarray(self):
-         return np.copy(self)
+        return np.copy(self)
 
     def __array__(self):
         return self
 
     def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
-        if method == '__call__':
+        if method == "__call__":
             N = None
             scalars = []
             typing = []
@@ -162,41 +191,43 @@ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
             # USM memory.  However, if kwarg has dparray-typed out then
             # array_ufunc is called recursively so we cast out as regular
             # NumPy ndarray (having a USM data pointer).
-            if kwargs.get('out', None) is None:
+            if kwargs.get("out", None) is None:
                 # maybe copy?
                 # deal with multiple returned arrays, so kwargs['out'] can be tuple
                 res_type = np.result_type(*typing)
                 out = empty(inputs[0].shape, dtype=res_type)
                 out_as_np = np.ndarray(out.shape, out.dtype, out)
-                kwargs['out'] = out_as_np
+                kwargs["out"] = out_as_np
             else:
                 # If they manually gave dparray as out kwarg then we have to also
                 # cast as regular NumPy ndarray to avoid recursion.
-                if isinstance(kwargs['out'], ndarray):
-                    out = kwargs['out']
-                    kwargs['out'] = np.ndarray(out.shape, out.dtype, out)
+                if isinstance(kwargs["out"], ndarray):
+                    out = kwargs["out"]
+                    kwargs["out"] = np.ndarray(out.shape, out.dtype, out)
                 else:
-                    out = kwargs['out']
+                    out = kwargs["out"]
             ret = ufunc(*scalars, **kwargs)
             return out
         else:
             return NotImplemented
 
+
 def isdef(x):
     try:
         eval(x)
         return True
     except NameError:
         return False
 
+
 for c in class_list:
     cname = c[0]
     if isdef(cname):
         continue
     # For now we do the simple thing and copy the types from NumPy module into dparray module.
     new_func = "%s = np.%s" % (cname, cname)
     try:
-        the_code = compile(new_func, '__init__', 'exec')
+        the_code = compile(new_func, "__init__", "exec")
         exec(the_code)
     except:
         print("Failed to exec type propagation", cname)
@@ -209,16 +240,18 @@ def isdef(x):
 for fname in functions_list:
     if isdef(fname):
         continue
-    new_func =  "def %s(*args, **kwargs):\n" % fname
+    new_func = "def %s(*args, **kwargs):\n" % fname
     new_func += "    ret = np.%s(*args, **kwargs)\n" % fname
     new_func += "    if type(ret) == np.ndarray:\n"
     new_func += "        ret = ndarray(ret.shape, ret.dtype, ret)\n"
     new_func += "    return ret\n"
-    the_code = compile(new_func, '__init__', 'exec')
+    the_code = compile(new_func, "__init__", "exec")
     exec(the_code)
 
+
 def from_ndarray(x):
     return copy(x)
 
+
 def as_ndarray(x):
-     return np.copy(x)
+    return np.copy(x)

dpctl/tests/test_dparray.py

@@ -3,19 +3,10 @@
 import numpy
 
 
-def func_operation_with_const(dpctl_array):
-    return dpctl_array * 2.0 + 13
-
-
-def multiply_func(np_array, dpcrtl_array):
-    return np_array * dpcrtl_array
-
-
 class TestOverloadList(unittest.TestCase):
-    maxDiff = None
-
-    X = dparray.ndarray((256, 4), dtype='d')
-    X.fill(1.0)
+    def setUp(self):
+        self.X = dparray.ndarray((256, 4), dtype="d")
+        self.X.fill(1.0)
 
     def test_dparray_type(self):
         self.assertIsInstance(self.X, dparray.ndarray)
@@ -38,13 +29,16 @@ def test_multiplication_dparray(self):
         self.assertIsInstance(C, dparray.ndarray)
 
     def test_dparray_through_python_func(self):
+        def func_operation_with_const(dpctl_array):
+            return dpctl_array * 2.0 + 13
+
         C = self.X * 5
         dp_func = func_operation_with_const(C)
         self.assertIsInstance(dp_func, dparray.ndarray)
 
     def test_dparray_mixing_dpctl_and_numpy(self):
-        dp_numpy = numpy.ones((256, 4), dtype='d')
-        res = multiply_func(dp_numpy, self.X)
+        dp_numpy = numpy.ones((256, 4), dtype="d")
+        res = dp_numpy * self.X
         self.assertIsInstance(res, dparray.ndarray)
 
     def test_dparray_shape(self):
@@ -55,6 +49,15 @@ def test_dparray_T(self):
         res = self.X.T
         self.assertEqual(res.shape, (4, 256))
 
+    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)
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

setup.py

@@ -148,9 +148,7 @@ def extensions():
         runtime_library_dirs = []
 
     extension_args = {
-        "depends": [
-            dppl_sycl_interface_include,
-        ],
+        "depends": [dppl_sycl_interface_include,],
         "include_dirs": [np.get_include(), dppl_sycl_interface_include],
         "extra_compile_args": eca
         + get_other_cxxflags()
@@ -165,16 +163,12 @@ def extensions():
     extensions = [
         Extension(
             "dpctl._sycl_core",
-            [
-                os.path.join("dpctl", "_sycl_core.pyx"),
-            ],
+            [os.path.join("dpctl", "_sycl_core.pyx"),],
             **extension_args
         ),
         Extension(
             "dpctl.memory._memory",
-            [
-                os.path.join("dpctl", "memory", "_memory.pyx"),
-            ],
+            [os.path.join("dpctl", "memory", "_memory.pyx"),],
             **extension_args
         ),
     ]
@@ -201,7 +195,6 @@ def _get_cmdclass():
     cmdclass["develop"] = develop
     return cmdclass
 
-print("packages:", find_packages(include=["*"]))
 
 setup(
     name="dpctl",