SparseArray is an ExtensionArray

pandas/core/sparse/array.py

@@ -659,6 +659,9 @@ def __getitem__(self, key):
                     key = np.asarray(key)
 
             if com.is_bool_indexer(key) and len(self) == len(key):
+                # TODO(numpy 1.11): Remove this asarray.
+                # Old NumPy didn't treat array-like as boolean masks.
+                key = np.asarray(key)
                 return self.take(np.arange(len(key), dtype=np.int32)[key])
             elif hasattr(key, '__len__'):
                 return self.take(key)

pandas/core/sparse/dtype.py

@@ -173,9 +173,10 @@ def construct_from_string(cls, string):
             'Sparse[int, 1]' SparseDtype[np.int64, 0]
             ================ ============================
 
-            Notice that any "fill value" in `string` is ignored. The
-            fill from from `construct_from_string` will always be
-            the default fill value for the dtype.
+            It is not possible to specify non-default fill values
+            with a string. An argument like ``'SparseDtype[int, 1]'``
+            will raise a ``TypeError`` because the default fill value
+            for integers is 0.
 
         Returns
         -------
@@ -184,10 +185,19 @@ def construct_from_string(cls, string):
         msg = "Could not construct SparseDtype from '{}'".format(string)
         if string.startswith("Sparse"):
             try:
-                sub_type = cls._parse_subtype(string)
-                return SparseDtype(sub_type)
+                sub_type, has_fill_value = cls._parse_subtype(string)
+                result = SparseDtype(sub_type)
             except Exception:
                 raise TypeError(msg)
+            else:
+                msg = ("Could not construct SparseDtype from '{}'.\n\nIt "
+                       "looks like the fill_value in the string is not "
+                       "the default for the dtype. Non-default fill_values "
+                       "are not supported. Use the 'SparseDtype()' "
+                       "constructor instead.")
+                if has_fill_value and str(result) != string:
+                    raise TypeError(msg.format(string))
+                return result
         else:
             raise TypeError(msg)
 
@@ -213,22 +223,26 @@ def _parse_subtype(dtype):
         ValueError
             When the subtype cannot be extracted.
         """
-        xpr = re.compile(r"Sparse\[(?P<subtype>[^,]*)(, )?(.*?)?\]$")
+        xpr = re.compile(
+            r"Sparse\[(?P<subtype>[^,]*)(, )?(?P<fill_value>.*?)?\]$"
+        )
         m = xpr.match(dtype)
+        has_fill_value = False
         if m:
             subtype = m.groupdict()['subtype']
+            has_fill_value = m.groupdict()['fill_value'] or has_fill_value
         elif dtype == "Sparse":
             subtype = 'float64'
         else:
             raise ValueError("Cannot parse {}".format(dtype))
-        return subtype
+        return subtype, has_fill_value
 
     @classmethod
     def is_dtype(cls, dtype):
         dtype = getattr(dtype, 'dtype', dtype)
         if (isinstance(dtype, compat.string_types) and
                 dtype.startswith("Sparse")):
-            sub_type = cls._parse_subtype(dtype)
+            sub_type, _ = cls._parse_subtype(dtype)
             dtype = np.dtype(sub_type)
         elif isinstance(dtype, cls):
             return True

pandas/tests/extension/arrow/bool.py

@@ -123,7 +123,10 @@ def _reduce(self, method, skipna=True, **kwargs):
         else:
             arr = self
 
-        op = getattr(arr, method)
+        try:
+            op = getattr(arr, method)
+        except AttributeError:
+            raise TypeError
         return op(**kwargs)
 
     def any(self, axis=0, out=None):

pandas/tests/extension/arrow/test_bool.py

@@ -45,6 +45,11 @@ def test_from_dtype(self, data):
 
 
 class TestReduce(base.BaseNoReduceTests):
+    def test_reduce_series_boolean(self):
+        pass
+
+
+class TestReduceBoolean(base.BaseBooleanReduceTests):
     pass
 
 

pandas/tests/sparse/test_array.py

@@ -568,6 +568,12 @@ def _checkit(i):
             _checkit(i)
             _checkit(-i)
 
+    def test_getitem_arraylike_mask(self):
+        arr = SparseArray([0, 1, 2])
+        result = arr[[True, False, True]]
+        expected = SparseArray([0, 2])
+        tm.assert_sp_array_equal(result, expected)
+
     def test_getslice(self):
         result = self.arr[:-3]
         exp = SparseArray(self.arr.values[:-3])

pandas/tests/sparse/test_dtype.py

@@ -2,6 +2,7 @@
 import numpy as np
 
 import pandas as pd
+import pandas.util.testing as tm
 from pandas.core.sparse.api import SparseDtype
 
 
@@ -127,5 +128,15 @@ def test_hash_equal(a, b, expected):
     ('Sparse[datetime64[ns], 0]', 'datetime64[ns]'),
 ])
 def test_parse_subtype(string, expected):
-    subtype = SparseDtype._parse_subtype(string)
+    subtype, _ = SparseDtype._parse_subtype(string)
     assert subtype == expected
+
+
+@pytest.mark.parametrize("string", [
+    "Sparse[int, 1]",
+    "Sparse[float, 0.0]",
+    "Sparse[bool, True]",
+])
+def test_construct_from_string_fill_value_raises(string):
+    with tm.assert_raises_regex(TypeError, 'fill_value in the string is not'):
+        SparseDtype.construct_from_string(string)