promote consistency among type typetesting routines

now all are is_*

Author: jreback

pandas/core/categorical.py

@@ -78,10 +78,6 @@ def f(self, other):
 
     return f
 
-def _is_categorical(array):
-    """ return if we are a categorical possibility """
-    return isinstance(array, Categorical) or isinstance(array.dtype, CategoricalDtype)
-
 def _maybe_to_categorical(array):
     """ coerce to a categorical if a series is given """
     if isinstance(array, ABCSeries):

pandas/core/common.py

@@ -368,7 +368,7 @@ def notnull(obj):
         return not res
     return ~res
 
-def _is_null_datelike_scalar(other):
+def is_null_datelike_scalar(other):
     """ test whether the object is a null datelike, e.g. Nat
     but guard against passing a non-scalar """
     if other is pd.NaT or other is None:
@@ -2084,7 +2084,7 @@ def _try_timedelta(v):
     return value
 
 
-def _is_bool_indexer(key):
+def is_bool_indexer(key):
     if isinstance(key, (ABCSeries, np.ndarray)):
         if key.dtype == np.object_:
             key = np.asarray(_values_from_object(key))
@@ -2363,6 +2363,9 @@ def _maybe_make_list(obj):
         return [obj]
     return obj
 
+########################
+##### TYPE TESTING #####
+########################
 
 is_bool = lib.is_bool
 
@@ -2431,7 +2434,7 @@ def _get_dtype_type(arr_or_dtype):
     return arr_or_dtype.dtype.type
 
 
-def _is_any_int_dtype(arr_or_dtype):
+def is_any_int_dtype(arr_or_dtype):
     tipo = _get_dtype_type(arr_or_dtype)
     return issubclass(tipo, np.integer)
 
@@ -2442,7 +2445,7 @@ def is_integer_dtype(arr_or_dtype):
             not issubclass(tipo, (np.datetime64, np.timedelta64)))
 
 
-def _is_int_or_datetime_dtype(arr_or_dtype):
+def is_int_or_datetime_dtype(arr_or_dtype):
     tipo = _get_dtype_type(arr_or_dtype)
     return (issubclass(tipo, np.integer) or
             issubclass(tipo, (np.datetime64, np.timedelta64)))
@@ -2467,12 +2470,12 @@ def is_timedelta64_ns_dtype(arr_or_dtype):
     return tipo == _TD_DTYPE
 
 
-def _is_datetime_or_timedelta_dtype(arr_or_dtype):
+def is_datetime_or_timedelta_dtype(arr_or_dtype):
     tipo = _get_dtype_type(arr_or_dtype)
     return issubclass(tipo, (np.datetime64, np.timedelta64))
 
 
-needs_i8_conversion = _is_datetime_or_timedelta_dtype
+needs_i8_conversion = is_datetime_or_timedelta_dtype
 
 def i8_boxer(arr_or_dtype):
     """ return the scalar boxer for the dtype """
@@ -2493,7 +2496,7 @@ def is_float_dtype(arr_or_dtype):
     return issubclass(tipo, np.floating)
 
 
-def _is_floating_dtype(arr_or_dtype):
+def is_floating_dtype(arr_or_dtype):
     tipo = _get_dtype_type(arr_or_dtype)
     return isinstance(tipo, np.floating)
 
@@ -2502,6 +2505,10 @@ def is_bool_dtype(arr_or_dtype):
     tipo = _get_dtype_type(arr_or_dtype)
     return issubclass(tipo, np.bool_)
 
+def is_categorical(array):
+    """ return if we are a categorical possibility """
+    return isinstance(array, ABCCategorical) or isinstance(array.dtype, CategoricalDtype)
+
 def is_categorical_dtype(arr_or_dtype):
     if hasattr(arr_or_dtype,'dtype'):
         arr_or_dtype = arr_or_dtype.dtype

pandas/core/frame.py

@@ -1798,7 +1798,7 @@ def _getitem_slice(self, key):
 
     def _getitem_array(self, key):
         # also raises Exception if object array with NA values
-        if com._is_bool_indexer(key):
+        if com.is_bool_indexer(key):
             # warning here just in case -- previously __setitem__ was
             # reindexing but __getitem__ was not; it seems more reasonable to
             # go with the __setitem__ behavior since that is more consistent
@@ -2115,7 +2115,7 @@ def _setitem_slice(self, key, value):
 
     def _setitem_array(self, key, value):
         # also raises Exception if object array with NA values
-        if com._is_bool_indexer(key):
+        if com.is_bool_indexer(key):
             if len(key) != len(self.index):
                 raise ValueError('Item wrong length %d instead of %d!' %
                                  (len(key), len(self.index)))

pandas/core/groupby.py

@@ -25,7 +25,7 @@
                                notnull, _DATELIKE_DTYPES, is_numeric_dtype,
                                is_timedelta64_dtype, is_datetime64_dtype,
                                is_categorical_dtype, _values_from_object,
-                               _is_datetime_or_timedelta_dtype, is_bool_dtype)
+                               is_datetime_or_timedelta_dtype, is_bool_dtype)
 from pandas.core.config import option_context
 import pandas.lib as lib
 from pandas.lib import Timestamp
@@ -1491,7 +1491,7 @@ def aggregate(self, values, how, axis=0):
 
         is_numeric = is_numeric_dtype(values.dtype)
 
-        if _is_datetime_or_timedelta_dtype(values.dtype):
+        if is_datetime_or_timedelta_dtype(values.dtype):
             values = values.view('int64')
         elif is_bool_dtype(values.dtype):
             values = _algos.ensure_float64(values)

pandas/core/index.py

@@ -19,7 +19,8 @@
 from pandas.core.common import isnull, array_equivalent
 import pandas.core.common as com
 from pandas.core.common import (_values_from_object, is_float, is_integer,
-                                ABCSeries, _ensure_object, _ensure_int64)
+                                ABCSeries, _ensure_object, _ensure_int64, is_bool_indexer,
+                                is_list_like, is_bool_dtype, is_integer_dtype)
 from pandas.core.config import get_option
 from pandas.io.common import PerformanceWarning
 
@@ -55,7 +56,7 @@ def wrapper(self, other):
 
         # technically we could support bool dtyped Index
         # for now just return the indexing array directly
-        if com.is_bool_dtype(result):
+        if is_bool_dtype(result):
             return result
         try:
             return Index(result)
@@ -160,7 +161,7 @@ def __new__(cls, data=None, dtype=None, copy=False, name=None, fastpath=False,
                 return Int64Index(data, copy=copy, dtype=dtype, name=name)
             elif issubclass(data.dtype.type, np.floating):
                 return Float64Index(data, copy=copy, dtype=dtype, name=name)
-            elif issubclass(data.dtype.type, np.bool) or com.is_bool_dtype(data):
+            elif issubclass(data.dtype.type, np.bool) or is_bool_dtype(data):
                 subarr = data.astype('object')
             else:
                 subarr = com._asarray_tuplesafe(data, dtype=object)
@@ -510,15 +511,15 @@ def set_names(self, names, level=None, inplace=False):
         if level is not None and self.nlevels == 1:
             raise ValueError('Level must be None for non-MultiIndex')
 
-        if level is not None and not com.is_list_like(level) and com.is_list_like(names):
+        if level is not None and not is_list_like(level) and is_list_like(names):
             raise TypeError("Names must be a string")
 
-        if not com.is_list_like(names) and level is None and self.nlevels > 1:
+        if not is_list_like(names) and level is None and self.nlevels > 1:
             raise TypeError("Must pass list-like as `names`.")
 
-        if not com.is_list_like(names):
+        if not is_list_like(names):
             names = [names]
-        if level is not None and not com.is_list_like(level):
+        if level is not None and not is_list_like(level):
             level = [level]
 
         if inplace:
@@ -768,7 +769,7 @@ def _convert_list_indexer_for_mixed(self, keyarr, typ=None):
             and we have a mixed index (e.g. number/labels). figure out
             the indexer. return None if we can't help
         """
-        if (typ is None or typ in ['iloc','ix']) and (com.is_integer_dtype(keyarr) and not self.is_floating()):
+        if (typ is None or typ in ['iloc','ix']) and (is_integer_dtype(keyarr) and not self.is_floating()):
             if self.inferred_type != 'integer':
                 keyarr = np.where(keyarr < 0,
                                   len(self) + keyarr, keyarr)
@@ -929,7 +930,7 @@ def __getitem__(self, key):
             # pessimization of basic indexing.
             return promote(getitem(key))
 
-        if com._is_bool_indexer(key):
+        if is_bool_indexer(key):
             key = np.asarray(key)
 
         key = _values_from_object(key)
@@ -2104,7 +2105,7 @@ def get_slice_bound(self, label, side):
         if isinstance(slc, np.ndarray):
             # get_loc may return a boolean array or an array of indices, which
             # is OK as long as they are representable by a slice.
-            if com.is_bool_dtype(slc):
+            if is_bool_dtype(slc):
                 slc = lib.maybe_booleans_to_slice(slc.view('u1'))
             else:
                 slc = lib.maybe_indices_to_slice(slc.astype('i8'))
@@ -2882,15 +2883,15 @@ def set_levels(self, levels, level=None, inplace=False, verify_integrity=True):
                    labels=[[0, 0, 1, 1], [0, 1, 0, 1]],
                    names=[u'foo', u'bar'])
         """
-        if level is not None and not com.is_list_like(level):
-            if not com.is_list_like(levels):
+        if level is not None and not is_list_like(level):
+            if not is_list_like(levels):
                 raise TypeError("Levels must be list-like")
-            if com.is_list_like(levels[0]):
+            if is_list_like(levels[0]):
                 raise TypeError("Levels must be list-like")
             level = [level]
             levels = [levels]
-        elif level is None or com.is_list_like(level):
-            if not com.is_list_like(levels) or not com.is_list_like(levels[0]):
+        elif level is None or is_list_like(level):
+            if not is_list_like(levels) or not is_list_like(levels[0]):
                 raise TypeError("Levels must be list of lists-like")
 
         if inplace:
@@ -2980,15 +2981,15 @@ def set_labels(self, labels, level=None, inplace=False, verify_integrity=True):
                    labels=[[1, 0, 1, 0], [0, 0, 1, 1]],
                    names=[u'foo', u'bar'])
         """
-        if level is not None and not com.is_list_like(level):
-            if not com.is_list_like(labels):
+        if level is not None and not is_list_like(level):
+            if not is_list_like(labels):
                 raise TypeError("Labels must be list-like")
-            if com.is_list_like(labels[0]):
+            if is_list_like(labels[0]):
                 raise TypeError("Labels must be list-like")
             level = [level]
             labels = [labels]
-        elif level is None or com.is_list_like(level):
-            if not com.is_list_like(labels) or not com.is_list_like(labels[0]):
+        elif level is None or is_list_like(level):
+            if not is_list_like(labels) or not is_list_like(labels[0]):
                 raise TypeError("Labels must be list of lists-like")
 
         if inplace:
@@ -3642,7 +3643,7 @@ def __getitem__(self, key):
 
             return tuple(retval)
         else:
-            if com._is_bool_indexer(key):
+            if is_bool_indexer(key):
                 key = np.asarray(key)
                 sortorder = self.sortorder
             else:
@@ -4404,14 +4405,14 @@ def _convert_indexer(r):
         ranges = []
         for i,k in enumerate(tup):
 
-            if com._is_bool_indexer(k):
+            if is_bool_indexer(k):
                 # a boolean indexer, must be the same length!
                 k = np.asarray(k)
                 if len(k) != len(self):
                     raise ValueError("cannot index with a boolean indexer that is"
                                      " not the same length as the index")
                 ranges.append(k)
-            elif com.is_list_like(k):
+            elif is_list_like(k):
                 # a collection of labels to include from this level (these are or'd)
                 indexers = []
                 for x in k: