reorg

Author: jreback

pandas/core/arrays/_mask.py

@@ -19,7 +19,7 @@
 
 from pandas.core import nanops
 from pandas.core.arrays import ExtensionArray, ExtensionOpsMixin
-from pandas.core.arrays._mask import get_mask_array_type
+from pandas.core.arrays.mask import get_mask_array_type
 from pandas.core.tools.numeric import to_numeric
 
 

pandas/core/arrays/_numpy_bool.py

@@ -0,0 +1,30 @@
+_MaskArrayType = None
+
+
+def get_mask_array_type():
+    """Set the mask array type to use, we need to do
+    this after all modules are imported as the implementations
+    e.g. pyarrow depend on pandas being importable
+    """
+    global _MaskArrayType
+
+    if _MaskArrayType is not None:
+        return _MaskArrayType
+
+    # if ArrowBoolArray is available use it
+    # otherwise use the NumpyMask
+    try:
+        from pandas.core.arrays.mask._pyarrow_bool import ArrowBoolArray
+
+        MaskArray = ArrowBoolArray
+
+    except ImportError:
+        from pandas.core.arrays.mask._numpy_bool import NumpyBoolArray
+
+        MaskArray = NumpyBoolArray
+
+    _MaskArrayType = MaskArray
+    return _MaskArrayType
+
+
+__all__ = ['get_mask_array_type']

pandas/core/arrays/integer.py

@@ -0,0 +1,79 @@
+"""A boolean mask interace.
+
+This module provides an interface to a numpy / pyarrow boolean mask.
+This is limited as not all of the implementations can hold NA, so
+for consistency this is an internal.
+"""
+
+import copy
+import numpy as np
+from pandas.core.missing import isna
+from pandas.core.arrays.base import ExtensionArray
+
+
+class BoolArray(ExtensionArray):
+    """Common baseclass for both pyarrow and numpy masked arrays"""
+    _typ = "maskarray"
+
+    @classmethod
+    def _from_sequence(cls, scalars, dtype=None, copy=False):
+        return cls.from_scalars(scalars)
+
+    @property
+    def size(self):
+        return len(self)
+
+    def __eq__(self, other):
+        return np.array(self, copy=False) == np.array(other, copy=False)
+
+    def __len__(self):
+        return len(self._data)
+
+    def isna(self):
+        nas = isna(np.array(self._data, copy=False))
+        return type(self).from_scalars(nas)
+
+    def __invert__(self):
+        return type(self).from_scalars(
+            ~np.array(self._data, copy=False)
+        )
+
+    def __or__(self, other):
+        return type(self).from_scalars(np.array(
+            self, copy=False).__or__(np.array(other, copy=False)))
+
+    def __ior__(self, other):
+        return type(self).from_scalars(
+            np.array(self, copy=False) | np.array(other, copy=False))
+
+    def __and__(self, other):
+        return type(self).from_scalars(
+            np.array(self, copy=False).__and__(np.array(other, copy=False)))
+
+    def __iand__(self, other):
+        return type(self).from_scalars(
+            np.array(self, copy=False) & (np.array(other, copy=False)))
+
+    def view(self, dtype):
+        return np.array(self._data, copy=False).view(dtype)
+
+    def sum(self, axis=None):
+        return np.array(self, copy=False).sum()
+
+    def copy(self, deep=False):
+        if deep:
+            return type(self)(copy.deepcopy(self._data))
+        else:
+            return type(self)(copy.copy(self._data))
+
+    def _reduce(self, method, skipna=True, **kwargs):
+        if skipna:
+            arr = self[~self.isna()]
+        else:
+            arr = self
+
+        try:
+            op = getattr(arr, method)
+        except AttributeError:
+            raise TypeError
+        return op(**kwargs)

pandas/core/arrays/mask/__init__.py

@@ -0,0 +1,66 @@
+"""
+This module provide a numpy-boolean boolean array
+"""
+
+import numpy as np
+
+from pandas.core.arrays.mask._base import BoolArray
+
+
+class NumpyBoolArray(BoolArray):
+    """Generic class which can be used to represent missing data.
+    """
+
+    @property
+    def dtype(self):
+        return np.dtype('bool')
+
+    @classmethod
+    def from_scalars(cls, values):
+        arr = np.asarray(values).astype(np.bool_, copy=False)
+        return cls(arr, copy=False)
+
+    def __init__(self, mask, copy=True):
+        """
+        Parameters
+        ----------
+        mask : numpy array
+            Mask of missing values.
+        """
+        assert isinstance(mask, np.ndarray)
+        assert mask.dtype == np.bool_
+
+        if copy:
+            mask = mask.copy()
+        self._data = mask
+
+    def __getitem__(self, key):
+        return self._data[key]
+
+    def __setitem__(self, key, value):
+        self._data[key] = value
+
+    def __array__(self, dtype=None):
+        return self._data
+
+    def __iter__(self):
+        return iter(self._data)
+
+    @property
+    def nbytes(self):
+        return self._data.nbytes
+
+    def reshape(self, shape, **kwargs):
+        return np.array(self, copy=False).reshape(shape, **kwargs)
+
+    def astype(self, dtype, copy=False):
+        return np.array(self, copy=False).astype(dtype, copy=copy)
+
+    def any(self):
+        return self._data.any()
+
+    def all(self):
+        return self._data.all()
+
+    def take(self, indicies, **kwargs):
+        return np.array(self, copy=False).take(indicies)