C++ refactoring: Content classes

src/awkward/_v2/__init__.py

@@ -4,3 +4,6 @@
 
 import awkward._v2.index  # noqa: F401
 import awkward._v2.identifier  # noqa: F401
+import awkward._v2.array  # noqa: F401
+import awkward._v2.content  # noqa: F401
+import awkward._v2.record  # noqa: F401

src/awkward/_v2/array/__init__.py

@@ -0,0 +1,20 @@
+# BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
+
+from __future__ import absolute_import
+
+import awkward._v2.content  # noqa: F401
+import awkward._v2.index  # noqa: F401
+import awkward._v2.record  # noqa: F401
+
+import awkward._v2.array.emptyarray  # noqa: F401
+import awkward._v2.array.numpyarray  # noqa: F401
+import awkward._v2.array.regulararray  # noqa: F401
+import awkward._v2.array.listarray  # noqa: F401
+import awkward._v2.array.listoffsetarray  # noqa: F401
+import awkward._v2.array.recordarray  # noqa: F401
+import awkward._v2.array.indexedarray  # noqa: F401
+import awkward._v2.array.indexedoptionarray  # noqa: F401
+import awkward._v2.array.bytemaskedarray  # noqa: F401
+import awkward._v2.array.bitmaskedarray  # noqa: F401
+import awkward._v2.array.unmaskedarray  # noqa: F401
+import awkward._v2.array.unionarray  # noqa: F401

src/awkward/_v2/array/bitmaskedarray.py

@@ -0,0 +1,74 @@
+# BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
+
+from __future__ import absolute_import
+
+import numbers
+
+from awkward._v2.content import Content
+from awkward._v2.index import Index
+from awkward._v2.array.bytemaskedarray import ByteMaskedArray
+
+import numpy as np
+
+
+class BitMaskedArray(Content):
+    def __init__(self, mask, content, valid_when, length, lsb_order):
+        assert isinstance(mask, Index) and mask._T == np.uint8
+        assert isinstance(content, Content)
+        assert isinstance(valid_when, bool)
+        assert isinstance(length, numbers.Integral) and length >= 0
+        assert isinstance(lsb_order, bool)
+        assert len(mask) <= len(content)
+        self.mask = mask
+        self.content = content
+        self.valid_when = valid_when
+        self.length = length
+        self.lsb_order = lsb_order
+
+    def __len__(self):
+        return self.length
+
+    def _getitem_at(self, where):
+        if where < 0:
+            where += len(self)
+        if 0 > where or where >= len(self):
+            raise IndexError("array index out of bounds")
+        if self.lsb_order:
+            bit = bool(self.mask[where // 8] & (1 << (where % 8)))
+        else:
+            bit = bool(self.mask[where // 8] & (128 >> (where % 8)))
+        if bit == self.valid_when:
+            return self.content[where]
+        else:
+            return None
+
+    def _getitem_range(self, where):
+        # In general, slices must convert BitMaskedArray to ByteMaskedArray.
+        # FIXME this will return an array of bools, but now the first argument is of type Index and not List as before and Index doesn't have bool as an accepted data type
+        bytemask = np.unpackbits(
+            self.mask, bitorder=("little" if self.lsb_order else "big")
+        ).view(np.bool_)
+        start, stop, step = where.indices(len(self))
+        return ByteMaskedArray(
+            Index(bytemask[start:stop]),
+            self.content[start:stop],
+            valid_when=self.valid_when,
+        )
+
+    def _getitem_field(self, where):
+        return BitMaskedArray(
+            self.mask,
+            self.content[where],
+            valid_when=self.valid_when,
+            length=self.length,
+            lsb_order=self.lsb_order,
+        )
+
+    def _getitem_fields(self, where):
+        return BitMaskedArray(
+            self.mask,
+            self.content[where],
+            valid_when=self.valid_when,
+            length=self.length,
+            lsb_order=self.lsb_order,
+        )

src/awkward/_v2/array/bytemaskedarray.py

@@ -0,0 +1,62 @@
+# BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
+
+from __future__ import absolute_import
+
+import awkward as ak
+from awkward._v2.content import Content
+from awkward._v2.index import Index
+
+np = ak.nplike.NumpyMetadata.instance()
+
+
+class ByteMaskedArray(Content):
+    def __init__(self, mask, content, valid_when):
+        assert isinstance(mask, Index) and mask._T == np.int8
+        assert isinstance(content, Content)
+        assert isinstance(valid_when, bool)
+        assert len(mask) <= len(content)
+        self.mask = mask
+        self.content = content
+        self.valid_when = valid_when
+
+    def __len__(self):
+        return len(self.mask)
+
+    # def __repr__(self):
+    #     return (
+    #         "ByteMaskedArray("
+    #         + repr(self.mask)
+    #         + ", "
+    #         + repr(self.content)
+    #         + ", "
+    #         + repr(self.valid_when)
+    #         + ")"
+    #     )
+
+    def _getitem_at(self, where):
+        if where < 0:
+            where += len(self)
+        if 0 > where or where >= len(self):
+            raise IndexError("array index out of bounds")
+        if self.mask[where] == self.valid_when:
+            return self.content[where]
+        else:
+            return None
+
+    def _getitem_range(self, where):
+        start, stop, step = where.indices(len(self))
+        return ByteMaskedArray(
+            Index(self.mask[start:stop]),
+            self.content[start:stop],
+            valid_when=self.valid_when,
+        )
+
+    def _getitem_field(self, where):
+        return ByteMaskedArray(
+            self.mask, self.content[where], valid_when=self.valid_when
+        )
+
+    def _getitem_fields(self, where):
+        return ByteMaskedArray(
+            self.mask, self.content[where], valid_when=self.valid_when
+        )

src/awkward/_v2/array/emptyarray.py

@@ -0,0 +1,28 @@
+# BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
+
+from __future__ import absolute_import
+
+from awkward._v2.content import Content
+
+
+class EmptyArray(Content):
+    def __init__(self):
+        pass
+
+    def __repr__(self):
+        return "EmptyArray()"
+
+    def __len__(self):
+        return 0
+
+    def _getitem_at(self, where):
+        raise IndexError("array of type Empty has no index " + repr(where))
+
+    def _getitem_range(self, where):
+        return EmptyArray()
+
+    def _getitem_field(self, where):
+        raise IndexError("field " + repr(where) + " not found")
+
+    def _getitem_fields(self, where):
+        raise IndexError("fields " + repr(where) + " not found")

src/awkward/_v2/array/indexedarray.py

@@ -0,0 +1,39 @@
+# BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
+
+from __future__ import absolute_import
+
+import awkward as ak
+from awkward._v2.content import Content
+from awkward._v2.index import Index
+
+np = ak.nplike.NumpyMetadata.instance()
+
+
+class IndexedArray(Content):
+    def __init__(self, index, content):
+        assert isinstance(index, Index) and index._T in (np.int32, np.uint32, np.int64)
+        assert isinstance(content, Content)
+        self.index = index
+        self.content = content
+
+    def __len__(self):
+        return len(self.index)
+
+    def __repr__(self):
+        return "IndexedArray(" + repr(self.index) + ", " + repr(self.content) + ")"
+
+    def _getitem_at(self, where):
+        if where < 0:
+            where += len(self)
+        if 0 > where or where >= len(self):
+            raise IndexError("array index out of bounds")
+        return self.content[self.index[where]]
+
+    def _getitem_range(self, where):
+        return IndexedArray(Index(self.index[where.start : where.stop]), self.content)
+
+    def _getitem_field(self, where):
+        return IndexedArray(self.index, self.content[where])
+
+    def _getitem_fields(self, where):
+        return IndexedArray(self.index, self.content[where])

src/awkward/_v2/array/indexedoptionarray.py

@@ -0,0 +1,46 @@
+# BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
+
+from __future__ import absolute_import
+
+import awkward as ak
+from awkward._v2.content import Content
+from awkward._v2.index import Index
+
+np = ak.nplike.NumpyMetadata.instance()
+
+
+class IndexedOptionArray(Content):
+    def __init__(self, index, content):
+        assert isinstance(index, Index) and index._T in (np.int32, np.int64)
+        assert isinstance(content, Content)
+        self.index = index
+        self.content = content
+
+    def __len__(self):
+        return len(self.index)
+
+    def __repr__(self):
+        return (
+            "IndexedOptionArray(" + repr(self.index) + ", " + repr(self.content) + ")"
+        )
+
+    def _getitem_at(self, where):
+        if where < 0:
+            where += len(self)
+        if 0 > where or where >= len(self):
+            raise IndexError("array index out of bounds")
+        if self.index[where] < 0:
+            return None
+        else:
+            return self.content[self.index[where]]
+
+    def _getitem_range(self, where):
+        return IndexedOptionArray(
+            Index(self.index[where.start : where.stop]), self.content
+        )
+
+    def _getitem_field(self, where):
+        return IndexedOptionArray(self.index, self.content[where])
+
+    def _getitem_fields(self, where):
+        return IndexedOptionArray(self.index, self.content[where])

src/awkward/_v2/array/listarray.py

@@ -0,0 +1,57 @@
+# BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
+
+from __future__ import absolute_import
+
+import awkward as ak
+from awkward._v2.content import Content
+from awkward._v2.index import Index
+
+np = ak.nplike.NumpyMetadata.instance()
+
+
+class ListArray(Content):
+    def __init__(self, starts, stops, content):
+        assert isinstance(starts, Index) and starts._T in (
+            np.int32,
+            np.uint32,
+            np.int64,
+        )
+        assert isinstance(stops, Index) and starts._T == stops._T
+        assert isinstance(content, Content)
+        assert len(stops) >= len(starts)  # usually equal
+        self.starts = starts
+        self.stops = stops
+        self.content = content
+
+    def __len__(self):
+        return len(self.starts)
+
+    def __repr__(self):
+        return (
+            "ListArray("
+            + repr(self.starts)
+            + ", "
+            + repr(self.stops)
+            + ", "
+            + repr(self.content)
+            + ")"
+        )
+
+    def _getitem_at(self, where):
+        if where < 0:
+            where += len(self)
+        if 0 > where or where >= len(self):
+            raise IndexError("array index out of bounds")
+        return self.content[self.starts[where] : self.stops[where]]
+
+    def _getitem_range(self, where):
+        start, stop, step = where.indices(len(self))
+        starts = Index(self.starts[start:stop])
+        stops = Index(self.stops[start:stop])
+        return ListArray(starts, stops, self.content)
+
+    def _getitem_field(self, where):
+        return ListArray(self.starts, self.stops, self.content[where])
+
+    def _getitem_fields(self, where):
+        return ListArray(self.starts, self.stops, self.content[where])

src/awkward/_v2/array/listoffsetarray.py

@@ -0,0 +1,48 @@
+# BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
+
+from __future__ import absolute_import
+
+import awkward as ak
+from awkward._v2.content import Content
+from awkward._v2.index import Index
+
+np = ak.nplike.NumpyMetadata.instance()
+
+
+class ListOffsetArray(Content):
+    def __init__(self, offsets, content):
+        assert isinstance(offsets, Index) and offsets._T in (
+            np.int32,
+            np.uint32,
+            np.int64,
+        )
+        assert isinstance(content, Content)
+        assert len(offsets) != 0
+        self.offsets = offsets
+        self.content = content
+
+    def __len__(self):
+        return len(self.offsets) - 1
+
+    def __repr__(self):
+        return "ListOffsetArray(" + repr(self.offsets) + ", " + repr(self.content) + ")"
+
+    def _getitem_at(self, where):
+        if where < 0:
+            where += len(self)
+        if 0 > where or where >= len(self):
+            raise IndexError("array index out of bounds")
+        return self.content[self.offsets[where] : self.offsets[where + 1]]
+
+    def _getitem_range(self, where):
+        start, stop, step = where.indices(len(self))
+        offsets = self.offsets[start : stop + 1]
+        if len(offsets) == 0:
+            offsets = [0]
+        return ListOffsetArray(Index(offsets), self.content)
+
+    def _getitem_field(self, where):
+        return ListOffsetArray(self.offsets, self.content[where])
+
+    def _getitem_fields(self, where):
+        return ListOffsetArray(self.offsets, self.content[where])