CLN: move ABC to types/generic.py

Author: jreback

pandas/core/common.py

@@ -18,7 +18,8 @@
 from pandas import compat
 from pandas.compat import (BytesIO, range, long, u, zip, map, string_types,
                            iteritems)
-from pandas.types.api import *
+from pandas.types import api as gt
+from pandas.types.api import *  # noqa
 from pandas.core.config import get_option
 
 
@@ -71,63 +72,6 @@ def __str__(self):
 _int64_max = np.iinfo(np.int64).max
 
 
-# define abstract base classes to enable isinstance type checking on our
-# objects
-def create_pandas_abc_type(name, attr, comp):
-    @classmethod
-    def _check(cls, inst):
-        return getattr(inst, attr, '_typ') in comp
-
-    dct = dict(__instancecheck__=_check, __subclasscheck__=_check)
-    meta = type("ABCBase", (type, ), dct)
-    return meta(name, tuple(), dct)
-
-
-ABCIndex = create_pandas_abc_type("ABCIndex", "_typ", ("index", ))
-ABCInt64Index = create_pandas_abc_type("ABCInt64Index", "_typ",
-                                       ("int64index", ))
-ABCRangeIndex = create_pandas_abc_type("ABCRangeIndex", "_typ",
-                                       ("rangeindex", ))
-ABCFloat64Index = create_pandas_abc_type("ABCFloat64Index", "_typ",
-                                         ("float64index", ))
-ABCMultiIndex = create_pandas_abc_type("ABCMultiIndex", "_typ",
-                                       ("multiindex", ))
-ABCDatetimeIndex = create_pandas_abc_type("ABCDatetimeIndex", "_typ",
-                                          ("datetimeindex", ))
-ABCTimedeltaIndex = create_pandas_abc_type("ABCTimedeltaIndex", "_typ",
-                                           ("timedeltaindex", ))
-ABCPeriodIndex = create_pandas_abc_type("ABCPeriodIndex", "_typ",
-                                        ("periodindex", ))
-ABCCategoricalIndex = create_pandas_abc_type("ABCCategoricalIndex", "_typ",
-                                             ("categoricalindex", ))
-ABCIndexClass = create_pandas_abc_type("ABCIndexClass", "_typ",
-                                       ("index", "int64index", "rangeindex",
-                                        "float64index",
-                                        "multiindex", "datetimeindex",
-                                        "timedeltaindex", "periodindex",
-                                        "categoricalindex"))
-
-ABCSeries = create_pandas_abc_type("ABCSeries", "_typ", ("series", ))
-ABCDataFrame = create_pandas_abc_type("ABCDataFrame", "_typ", ("dataframe", ))
-ABCPanel = create_pandas_abc_type("ABCPanel", "_typ", ("panel", ))
-ABCSparseSeries = create_pandas_abc_type("ABCSparseSeries", "_subtyp",
-                                         ('sparse_series',
-                                          'sparse_time_series'))
-ABCSparseArray = create_pandas_abc_type("ABCSparseArray", "_subtyp",
-                                        ('sparse_array', 'sparse_series'))
-ABCCategorical = create_pandas_abc_type("ABCCategorical", "_typ",
-                                        ("categorical"))
-ABCPeriod = create_pandas_abc_type("ABCPeriod", "_typ", ("period", ))
-
-
-class _ABCGeneric(type):
-    def __instancecheck__(cls, inst):
-        return hasattr(inst, "_data")
-
-
-ABCGeneric = _ABCGeneric("ABCGeneric", tuple(), {})
-
-
 def isnull(obj):
     """Detect missing values (NaN in numeric arrays, None/NaN in object arrays)
 
@@ -155,9 +99,9 @@ def _isnull_new(obj):
     # hack (for now) because MI registers as ndarray
     elif isinstance(obj, pd.MultiIndex):
         raise NotImplementedError("isnull is not defined for MultiIndex")
-    elif isinstance(obj, (ABCSeries, np.ndarray, pd.Index)):
+    elif isinstance(obj, (gt.ABCSeries, np.ndarray, pd.Index)):
         return _isnull_ndarraylike(obj)
-    elif isinstance(obj, ABCGeneric):
+    elif isinstance(obj, gt.ABCGeneric):
         return obj._constructor(obj._data.isnull(func=isnull))
     elif isinstance(obj, list) or hasattr(obj, '__array__'):
         return _isnull_ndarraylike(np.asarray(obj))
@@ -181,9 +125,9 @@ def _isnull_old(obj):
     # hack (for now) because MI registers as ndarray
     elif isinstance(obj, pd.MultiIndex):
         raise NotImplementedError("isnull is not defined for MultiIndex")
-    elif isinstance(obj, (ABCSeries, np.ndarray, pd.Index)):
+    elif isinstance(obj, (gt.ABCSeries, np.ndarray, pd.Index)):
         return _isnull_ndarraylike_old(obj)
-    elif isinstance(obj, ABCGeneric):
+    elif isinstance(obj, gt.ABCGeneric):
         return obj._constructor(obj._data.isnull(func=_isnull_old))
     elif isinstance(obj, list) or hasattr(obj, '__array__'):
         return _isnull_ndarraylike_old(np.asarray(obj))
@@ -250,7 +194,7 @@ def _isnull_ndarraylike(obj):
         result = np.isnan(values)
 
     # box
-    if isinstance(obj, ABCSeries):
+    if isinstance(obj, gt.ABCSeries):
         from pandas import Series
         result = Series(result, index=obj.index, name=obj.name, copy=False)
 
@@ -279,7 +223,7 @@ def _isnull_ndarraylike_old(obj):
         result = ~np.isfinite(values)
 
     # box
-    if isinstance(obj, ABCSeries):
+    if isinstance(obj, gt.ABCSeries):
         from pandas import Series
         result = Series(result, index=obj.index, name=obj.name, copy=False)
 
@@ -1687,10 +1631,10 @@ def _possibly_infer_to_datetimelike(value, convert_dates=False):
 
     """
 
-    if isinstance(value, (ABCDatetimeIndex, ABCPeriodIndex)):
+    if isinstance(value, (gt.ABCDatetimeIndex, gt.ABCPeriodIndex)):
         return value
-    elif isinstance(value, ABCSeries):
-        if isinstance(value._values, ABCDatetimeIndex):
+    elif isinstance(value, gt.ABCSeries):
+        if isinstance(value._values, gt.ABCDatetimeIndex):
             return value._values
 
     v = value
@@ -1760,7 +1704,7 @@ def _try_timedelta(v):
 
 
 def is_bool_indexer(key):
-    if isinstance(key, (ABCSeries, np.ndarray)):
+    if isinstance(key, (gt.ABCSeries, np.ndarray)):
         if key.dtype == np.object_:
             key = np.asarray(_values_from_object(key))
 
@@ -2088,22 +2032,23 @@ def is_period_arraylike(arr):
     """ return if we are period arraylike / PeriodIndex """
     if isinstance(arr, pd.PeriodIndex):
         return True
-    elif isinstance(arr, (np.ndarray, ABCSeries)):
+    elif isinstance(arr, (np.ndarray, gt.ABCSeries)):
         return arr.dtype == object and lib.infer_dtype(arr) == 'period'
     return getattr(arr, 'inferred_type', None) == 'period'
 
 
 def is_datetime_arraylike(arr):
     """ return if we are datetime arraylike / DatetimeIndex """
-    if isinstance(arr, ABCDatetimeIndex):
+    if isinstance(arr, gt.ABCDatetimeIndex):
         return True
-    elif isinstance(arr, (np.ndarray, ABCSeries)):
+    elif isinstance(arr, (np.ndarray, gt.ABCSeries)):
         return arr.dtype == object and lib.infer_dtype(arr) == 'datetime'
     return getattr(arr, 'inferred_type', None) == 'datetime'
 
 
 def is_datetimelike(arr):
-    return (arr.dtype in _DATELIKE_DTYPES or isinstance(arr, ABCPeriodIndex) or
+    return (arr.dtype in _DATELIKE_DTYPES or
+            isinstance(arr, gt.ABCPeriodIndex) or
             is_datetimetz(arr))
 
 
@@ -2334,12 +2279,12 @@ def is_bool_dtype(arr_or_dtype):
 
 def is_sparse(array):
     """ return if we are a sparse array """
-    return isinstance(array, (ABCSparseArray, ABCSparseSeries))
+    return isinstance(array, (gt.ABCSparseArray, gt.ABCSparseSeries))
 
 
 def is_datetimetz(array):
     """ return if we are a datetime with tz array """
-    return ((isinstance(array, ABCDatetimeIndex) and
+    return ((isinstance(array, gt.ABCDatetimeIndex) and
              getattr(array, 'tz', None) is not None) or
             is_datetime64tz_dtype(array))
 
@@ -2360,7 +2305,7 @@ def is_internal_type(value):
 
 def is_categorical(array):
     """ return if we are a categorical possibility """
-    return isinstance(array, ABCCategorical) or is_categorical_dtype(array)
+    return isinstance(array, gt.ABCCategorical) or is_categorical_dtype(array)
 
 
 def is_categorical_dtype(arr_or_dtype):

pandas/io/tests/test_pytables.py

@@ -16,6 +16,7 @@
                     isnull)
 
 from pandas.compat import is_platform_windows, PY3, PY35
+from pandas.formats.printing import pprint_thing
 from pandas.io.pytables import _tables, TableIterator
 try:
     _tables()
@@ -28,7 +29,6 @@
                                 AttributeConflictWarning, DuplicateWarning,
                                 PossibleDataLossError, ClosedFileError)
 from pandas.io import pytables as pytables
-import pandas.core.common as com
 import pandas.util.testing as tm
 from pandas.util.testing import (assert_panel4d_equal,
                                  assert_panel_equal,
@@ -3806,9 +3806,15 @@ def test_string_select(self):
                 expected = df[df.x != 'none']
                 assert_frame_equal(result, expected)
             except Exception as detail:
+<<<<<<< HEAD
                 com.pprint_thing("[{0}]".format(detail))
                 com.pprint_thing(store)
                 com.pprint_thing(expected)
+=======
+                pprint_thing("[{0}]".format(detail))
+                pprint_thing(store)
+                pprint_thing(expected)
+>>>>>>> e462ffe... wip
 
             df2 = df.copy()
             df2.loc[df2.x == '', 'x'] = np.nan

pandas/tests/series/test_misc_api.py

@@ -6,7 +6,6 @@
 
 from pandas import Index, Series, DataFrame, date_range
 from pandas.tseries.index import Timestamp
-import pandas.core.common as com
 
 from pandas.compat import range
 from pandas import compat

pandas/tests/test_common.py

@@ -11,7 +11,7 @@
 from pandas import (Series, DataFrame, date_range, DatetimeIndex,
                     TimedeltaIndex, Timestamp, Float64Index)
 from pandas import compat
-from pandas.compat import range, long, lrange, lmap, u
+from pandas.compat import range, lrange, lmap, u
 from pandas.core.common import notnull, isnull, array_equivalent
 import pandas.core.common as com
 import pandas.core.convert as convert
@@ -70,40 +70,6 @@ def __call__(self):
     assert getname(1) is None
 
 
-# Issue 10859
-class TestABCClasses(tm.TestCase):
-    tuples = [[1, 2, 2], ['red', 'blue', 'red']]
-    multi_index = pd.MultiIndex.from_arrays(tuples, names=('number', 'color'))
-    datetime_index = pd.to_datetime(['2000/1/1', '2010/1/1'])
-    timedelta_index = pd.to_timedelta(np.arange(5), unit='s')
-    period_index = pd.period_range('2000/1/1', '2010/1/1/', freq='M')
-    categorical = pd.Categorical([1, 2, 3], categories=[2, 3, 1])
-    categorical_df = pd.DataFrame({"values": [1, 2, 3]}, index=categorical)
-    df = pd.DataFrame({'names': ['a', 'b', 'c']}, index=multi_index)
-    sparse_series = pd.Series([1, 2, 3]).to_sparse()
-    sparse_array = pd.SparseArray(np.random.randn(10))
-
-    def test_abc_types(self):
-        self.assertIsInstance(pd.Index(['a', 'b', 'c']), com.ABCIndex)
-        self.assertIsInstance(pd.Int64Index([1, 2, 3]), com.ABCInt64Index)
-        self.assertIsInstance(pd.Float64Index([1, 2, 3]), com.ABCFloat64Index)
-        self.assertIsInstance(self.multi_index, com.ABCMultiIndex)
-        self.assertIsInstance(self.datetime_index, com.ABCDatetimeIndex)
-        self.assertIsInstance(self.timedelta_index, com.ABCTimedeltaIndex)
-        self.assertIsInstance(self.period_index, com.ABCPeriodIndex)
-        self.assertIsInstance(self.categorical_df.index,
-                              com.ABCCategoricalIndex)
-        self.assertIsInstance(pd.Index(['a', 'b', 'c']), com.ABCIndexClass)
-        self.assertIsInstance(pd.Int64Index([1, 2, 3]), com.ABCIndexClass)
-        self.assertIsInstance(pd.Series([1, 2, 3]), com.ABCSeries)
-        self.assertIsInstance(self.df, com.ABCDataFrame)
-        self.assertIsInstance(self.df.to_panel(), com.ABCPanel)
-        self.assertIsInstance(self.sparse_series, com.ABCSparseSeries)
-        self.assertIsInstance(self.sparse_array, com.ABCSparseArray)
-        self.assertIsInstance(self.categorical, com.ABCCategorical)
-        self.assertIsInstance(pd.Period('2012', freq='A-DEC'), com.ABCPeriod)
-
-
 class TestInferDtype(tm.TestCase):
 
     def test_infer_dtype_from_scalar(self):

pandas/types/api.py

@@ -1,2 +1,42 @@
-from pandas.types.dtypes import (CategoricalDtype, CategoricalDtypeType,
-                                 DatetimeTZDtype, DatetimeTZDtypeType) # noqa
+# flake8: noqa
+
+import numpy as np
+from pandas.compat import string_types
+
+from .dtypes import (CategoricalDtype, CategoricalDtypeType,
+                     DatetimeTZDtype, DatetimeTZDtypeType)
+from .generic import (ABCIndex, ABCInt64Index, ABCRangeIndex,
+                      ABCFloat64Index, ABCMultiIndex,
+                      ABCDatetimeIndex,
+                      ABCTimedeltaIndex, ABCPeriodIndex,
+                      ABCCategoricalIndex,
+                      ABCIndexClass,
+                      ABCSeries, ABCDataFrame, ABCPanel,
+                      ABCSparseSeries, ABCSparseArray,
+                      ABCCategorical, ABCPeriod,
+                      ABCGeneric)
+
+def pandas_dtype(dtype):
+    """
+    Converts input into a pandas only dtype object or a numpy dtype object.
+
+    Parameters
+    ----------
+    dtype : object to be converted
+
+    Returns
+    -------
+    np.dtype or a pandas dtype
+    """
+    if isinstance(dtype, string_types):
+        try:
+            return DatetimeTZDtype.construct_from_string(dtype)
+        except TypeError:
+            pass
+
+        try:
+            return CategoricalDtype.construct_from_string(dtype)
+        except TypeError:
+            pass
+
+    return np.dtype(dtype)

pandas/types/generic.py

@@ -0,0 +1,57 @@
+""" define generic base classes for pandas objects """
+
+
+# define abstract base classes to enable isinstance type checking on our
+# objects
+def create_pandas_abc_type(name, attr, comp):
+    @classmethod
+    def _check(cls, inst):
+        return getattr(inst, attr, '_typ') in comp
+
+    dct = dict(__instancecheck__=_check, __subclasscheck__=_check)
+    meta = type("ABCBase", (type, ), dct)
+    return meta(name, tuple(), dct)
+
+
+ABCIndex = create_pandas_abc_type("ABCIndex", "_typ", ("index", ))
+ABCInt64Index = create_pandas_abc_type("ABCInt64Index", "_typ",
+                                       ("int64index", ))
+ABCRangeIndex = create_pandas_abc_type("ABCRangeIndex", "_typ",
+                                       ("rangeindex", ))
+ABCFloat64Index = create_pandas_abc_type("ABCFloat64Index", "_typ",
+                                         ("float64index", ))
+ABCMultiIndex = create_pandas_abc_type("ABCMultiIndex", "_typ",
+                                       ("multiindex", ))
+ABCDatetimeIndex = create_pandas_abc_type("ABCDatetimeIndex", "_typ",
+                                          ("datetimeindex", ))
+ABCTimedeltaIndex = create_pandas_abc_type("ABCTimedeltaIndex", "_typ",
+                                           ("timedeltaindex", ))
+ABCPeriodIndex = create_pandas_abc_type("ABCPeriodIndex", "_typ",
+                                        ("periodindex", ))
+ABCCategoricalIndex = create_pandas_abc_type("ABCCategoricalIndex", "_typ",
+                                             ("categoricalindex", ))
+ABCIndexClass = create_pandas_abc_type("ABCIndexClass", "_typ",
+                                       ("index", "int64index", "rangeindex",
+                                        "float64index",
+                                        "multiindex", "datetimeindex",
+                                        "timedeltaindex", "periodindex",
+                                        "categoricalindex"))
+
+ABCSeries = create_pandas_abc_type("ABCSeries", "_typ", ("series", ))
+ABCDataFrame = create_pandas_abc_type("ABCDataFrame", "_typ", ("dataframe", ))
+ABCPanel = create_pandas_abc_type("ABCPanel", "_typ", ("panel", ))
+ABCSparseSeries = create_pandas_abc_type("ABCSparseSeries", "_subtyp",
+                                         ('sparse_series',
+                                          'sparse_time_series'))
+ABCSparseArray = create_pandas_abc_type("ABCSparseArray", "_subtyp",
+                                        ('sparse_array', 'sparse_series'))
+ABCCategorical = create_pandas_abc_type("ABCCategorical", "_typ",
+                                        ("categorical"))
+ABCPeriod = create_pandas_abc_type("ABCPeriod", "_typ", ("period", ))
+
+
+class _ABCGeneric(type):
+    def __instancecheck__(cls, inst):
+        return hasattr(inst, "_data")
+
+ABCGeneric = _ABCGeneric("ABCGeneric", tuple(), {})