API: remove ndarray.base

Base is tracked via `self._tensor._base`. Use `a.get()._base is b.get()` instead
of numpy's `a.base is b`.

Author: ev-br

torch_np/_dtypes.py

@@ -49,7 +49,7 @@ def __new__(self, value):
         # and here we follow the second approach and create a new object
         # *for all inputs*.
         #
-        return _ndarray.ndarray._from_tensor_and_base(tensor, None)
+        return _ndarray.ndarray._from_tensor(tensor)
 
 
 ##### these are abstract types

torch_np/_helpers.py

@@ -87,8 +87,7 @@ def result_or_out(result_tensor, out_array=None, promote_scalar=False):
 def array_from(tensor, base=None):
     from ._ndarray import ndarray
 
-    base = base if isinstance(base, ndarray) else None
-    return ndarray._from_tensor_and_base(tensor, base)  # XXX: nuke .base
+    return ndarray._from_tensor(tensor)
 
 
 def tuple_arrays_from(result):

torch_np/_ndarray.py

@@ -64,13 +64,11 @@ def __getitem__(self, key):
 class ndarray:
     def __init__(self):
         self._tensor = torch.Tensor()
-        self._base = None
 
     @classmethod
-    def _from_tensor_and_base(cls, tensor, base):
+    def _from_tensor(cls, tensor):
         self = cls()
         self._tensor = tensor
-        self._base = base
         return self
 
     def get(self):
@@ -101,10 +99,6 @@ def strides(self):
     def itemsize(self):
         return self._tensor.element_size()
 
-    @property
-    def base(self):
-        return self._base
-
     @property
     def flags(self):
         # Note contiguous in torch is assumed C-style
@@ -158,7 +152,7 @@ def copy(self, order="C"):
         if order != "C":
             raise NotImplementedError
         tensor = self._tensor.clone()
-        return ndarray._from_tensor_and_base(tensor, None)
+        return ndarray._from_tensor(tensor)
 
     def tolist(self):
         return self._tensor.tolist()
@@ -398,7 +392,7 @@ def _upcast_int_indices(index):
     def __getitem__(self, index):
         index = _helpers.ndarrays_to_tensors(index)
         index = ndarray._upcast_int_indices(index)
-        return ndarray._from_tensor_and_base(self._tensor.__getitem__(index), self)
+        return ndarray._from_tensor(self._tensor.__getitem__(index))
 
     def __setitem__(self, index, value):
         index = _helpers.ndarrays_to_tensors(index)
@@ -432,19 +426,16 @@ def array(obj, dtype=None, *, copy=True, order="K", subok=False, ndmin=0, like=N
         obj = a1
 
     # is obj an ndarray already?
-    base = None
     if isinstance(obj, ndarray):
-        obj = obj._tensor
-        base = obj
+        obj = obj.get()
 
     # is a specific dtype requrested?
     torch_dtype = None
     if dtype is not None:
         torch_dtype = _dtypes.dtype(dtype).torch_dtype
-        base = None
 
     tensor = _util._coerce_to_tensor(obj, torch_dtype, copy, ndmin)
-    return ndarray._from_tensor_and_base(tensor, base)
+    return ndarray._from_tensor(tensor)
 
 
 def asarray(a, dtype=None, order=None, *, like=None):
@@ -453,10 +444,6 @@ def asarray(a, dtype=None, order=None, *, like=None):
     return array(a, dtype=dtype, order=order, like=like, copy=False, ndmin=0)
 
 
-def maybe_set_base(tensor, base):
-    return ndarray._from_tensor_and_base(tensor, base)
-
-
 ###### dtype routines
 
 

torch_np/_wrapper.py

@@ -8,10 +8,10 @@
 
 import torch
 
-from . import _decorators, _dtypes, _funcs, _helpers
+from . import _funcs, _helpers
 from ._detail import _dtypes_impl, _flips, _reductions, _util
 from ._detail import implementations as _impl
-from ._ndarray import array, asarray, maybe_set_base, ndarray
+from ._ndarray import asarray
 from ._normalizations import (
     ArrayLike,
     DTypeLike,
@@ -176,39 +176,34 @@ def stack(
     return _helpers.result_or_out(result, out)
 
 
-def array_split(ary, indices_or_sections, axis=0):
-    tensor = asarray(ary).get()
-    base = ary if isinstance(ary, ndarray) else None
-    result = _impl.split_helper(tensor, indices_or_sections, axis)
-    return tuple(maybe_set_base(x, base) for x in result)
+@normalizer
+def array_split(ary: ArrayLike, indices_or_sections, axis=0):
+    result = _impl.split_helper(ary, indices_or_sections, axis)
+    return _helpers.tuple_arrays_from(result)
 
 
-def split(ary, indices_or_sections, axis=0):
-    tensor = asarray(ary).get()
-    base = ary if isinstance(ary, ndarray) else None
-    result = _impl.split_helper(tensor, indices_or_sections, axis, strict=True)
-    return tuple(maybe_set_base(x, base) for x in result)
+@normalizer
+def split(ary: ArrayLike, indices_or_sections, axis=0):
+    result = _impl.split_helper(ary, indices_or_sections, axis, strict=True)
+    return _helpers.tuple_arrays_from(result)
 
 
-def hsplit(ary, indices_or_sections):
-    tensor = asarray(ary).get()
-    base = ary if isinstance(ary, ndarray) else None
-    result = _impl.hsplit(tensor, indices_or_sections)
-    return tuple(maybe_set_base(x, base) for x in result)
+@normalizer
+def hsplit(ary: ArrayLike, indices_or_sections):
+    result = _impl.hsplit(ary, indices_or_sections)
+    return _helpers.tuple_arrays_from(result)
 
 
-def vsplit(ary, indices_or_sections):
-    tensor = asarray(ary).get()
-    base = ary if isinstance(ary, ndarray) else None
-    result = _impl.vsplit(tensor, indices_or_sections)
-    return tuple(maybe_set_base(x, base) for x in result)
+@normalizer
+def vsplit(ary: ArrayLike, indices_or_sections):
+    result = _impl.vsplit(ary, indices_or_sections)
+    return _helpers.tuple_arrays_from(result)
 
 
-def dsplit(ary, indices_or_sections):
-    tensor = asarray(ary).get()
-    base = ary if isinstance(ary, ndarray) else None
-    result = _impl.dsplit(tensor, indices_or_sections)
-    return tuple(maybe_set_base(x, base) for x in result)
+@normalizer
+def dsplit(ary: ArrayLike, indices_or_sections):
+    result = _impl.dsplit(ary, indices_or_sections)
+    return _helpers.tuple_arrays_from(result)
 
 
 @normalizer

torch_np/tests/numpy_tests/core/test_indexing.py

@@ -115,7 +115,7 @@ def test_empty_tuple_index(self):
         # Empty tuple index creates a view
         a = np.array([1, 2, 3])
         assert_equal(a[()], a)
-        assert_(a[()].base is a)
+        assert_(a[()].get()._base is a.get())
         a = np.array(0)
         pytest.skip(
             "torch doesn't have scalar types with distinct instancing behaviours"
@@ -164,7 +164,7 @@ def test_ellipsis_index(self):
         assert_(a[...] is not a)
         assert_equal(a[...], a)
         # `a[...]` was `a` in numpy <1.9.
-        assert_(a[...].base is a)
+        assert_(a[...].get()._base is a.get())
 
         # Slicing with ellipsis can skip an
         # arbitrary number of dimensions