Finish tests; add coverage for categorical; xfail where necessary

Author: h-vetinari

pandas/core/strings.py

@@ -2,7 +2,7 @@
 import numpy as np
 
 from pandas.compat import zip
-from pandas.core.dtypes.generic import ABCSeries, ABCIndex, ABCMultiIndex
+from pandas.core.dtypes.generic import ABCSeries, ABCIndexClass, ABCMultiIndex
 from pandas.core.dtypes.missing import isna
 from pandas.core.dtypes.common import (
     ensure_object,
@@ -942,7 +942,7 @@ def str_extractall(arr, pat, flags=0):
     if regex.groups == 0:
         raise ValueError("pattern contains no capture groups")
 
-    if isinstance(arr, ABCIndex):
+    if isinstance(arr, ABCIndexClass):
         arr = arr.to_series().reset_index(drop=True)
 
     names = dict(zip(regex.groupindex.values(), regex.groupindex.keys()))
@@ -1757,8 +1757,8 @@ def forbid_nonstring_types(forbidden, name=None):
     make it explicit which (inferred) types are disallowed by the method.
 
     :meth:`StringMethods.__init__` allows the *union* of types its different
-    methods allow (after skipping NaNs; see :meth:`StringMethods._validate`):
-    ['string', 'unicode', 'empty', 'bytes', 'mixed', 'mixed-integer'].
+    methods allow (after skipping NaNs; see :meth:`StringMethods._validate`),
+    namely: ['string', 'unicode', 'empty', 'bytes', 'mixed', 'mixed-integer'].
 
     The default string types ['string', 'unicode', 'empty'] are allowed for all
     methods. For the additional types ['bytes', 'mixed', 'mixed-integer'], each
@@ -1783,7 +1783,7 @@ def forbid_nonstring_types(forbidden, name=None):
 
     Raises
     ------
-    AttributeError
+    TypeError
         If the inferred type of the underlying data is in `forbidden`.
     """
 
@@ -1800,11 +1800,11 @@ def _forbid_nonstring_types(func):
 
         @wraps(func)
         def wrapper(self, *args, **kwargs):
-            if self._inferred_type not in allowed_types:
-                msg = ("Cannot use .str.{name} with values of inferred type "
-                       "{inf_type!r}.".format(name=func_name,
-                                              inf_type=self._inferred_type))
-                raise AttributeError(msg)
+            if self._inferred_dtype not in allowed_types:
+                msg = ('Cannot use .str.{name} with values of inferred dtype '
+                       '{inf_type!r}.'.format(name=func_name,
+                                              inf_type=self._inferred_dtype))
+                raise TypeError(msg)
             return func(self, *args, **kwargs)
         wrapper.__name__ = func_name
         return wrapper
@@ -1877,7 +1877,7 @@ class StringMethods(NoNewAttributesMixin):
     """
 
     def __init__(self, data):
-        self._inferred_type = self._validate(data)
+        self._inferred_dtype = self._validate(data)
         self._is_categorical = is_categorical_dtype(data)
 
         # .values.categories works for both Series/Index
@@ -1899,10 +1899,10 @@ def _validate(data):
         values = getattr(data, 'values', data)  # Series / Index
         values = getattr(values, 'categories', values)  # categorical / normal
 
-        # missing values obfuscates type inference -> skip
-        inferred_type = lib.infer_dtype(values, skipna=True)
+        # missing values obfuscate type inference -> skip
+        inferred_dtype = lib.infer_dtype(values, skipna=True)
 
-        if inferred_type not in allowed_types:
+        if inferred_dtype not in allowed_types:
             # this is a "first line of defence" and just checks that the type
             # is in the *union* of the allowed types over all methods below;
             # this restriction is then refined on a per-method basis using the
@@ -1913,7 +1913,7 @@ def _validate(data):
             # have a str dtype (GH 9343 / 13877)
             raise AttributeError("Can only use .str accessor with string "
                                  "values!")
-        return inferred_type
+        return inferred_dtype
 
     def __getitem__(self, key):
         if isinstance(key, slice):
@@ -1932,15 +1932,16 @@ def __iter__(self):
     def _wrap_result(self, result, use_codes=True,
                      name=None, expand=None):
 
-        from pandas.core.index import Index, MultiIndex
+        from pandas import Index, Series, MultiIndex
 
         # for category, we do the stuff on the categories, so blow it up
         # to the full series again
         # But for some operations, we have to do the stuff on the full values,
         # so make it possible to skip this step as the method already did this
         # before the transformation...
         if use_codes and self._is_categorical:
-            result = take_1d(result, self._orig.cat.codes)
+            # if self._orig is a CategoricalIndex, there is no .cat-accessor
+            result = take_1d(result, Series(self._orig).cat.codes)
 
         if not hasattr(result, 'ndim') or not hasattr(result, 'dtype'):
             return result