more panel test coverage'

Author: wesm

pandas/core/common.py

@@ -85,6 +85,13 @@ def null_out_axis(arr, mask, axis):
 #-------------------------------------------------------------------------------
 # Lots of little utilities
 
+def _default_index(n):
+    from pandas.core.index import NULL_INDEX
+    if n == 0:
+        return NULL_INDEX
+    else:
+        return np.arange(n)
+
 def ensure_float(arr):
     if issubclass(arr.dtype.type, np.integer):
         arr = arr.astype(float)

pandas/core/frame.py

@@ -22,7 +22,7 @@
 import numpy as np
 
 from pandas.core.common import (isnull, notnull, PandasError, _ensure_index,
-                                _try_sort, _pfixed)
+                                _try_sort, _pfixed, _default_index)
 from pandas.core.daterange import DateRange
 from pandas.core.generic import PandasGeneric
 from pandas.core.index import Index, NULL_INDEX
@@ -191,7 +191,7 @@ def _init_matrix(self, values, index, columns, dtype=None,
             try:
                 values = values.astype(dtype)
             except Exception:
-                pass
+                raise ValueError('failed to cast to %s' % dtype)
 
         N, K = values.shape
 
@@ -226,11 +226,6 @@ def _constructor(self):
     #----------------------------------------------------------------------
     # Class behavior
 
-    @property
-    def _is_mixed_type(self):
-        self._consolidate_inplace()
-        return len(self._data.blocks) > 1
-
     def __nonzero__(self):
         # e.g. "if frame: ..."
         return len(self.columns) > 0 and len(self.index) > 0
@@ -701,27 +696,6 @@ def _union_index(self, other):
 
         return union_index
 
-    #----------------------------------------------------------------------
-    # Consolidation of internals
-
-    def _consolidate_inplace(self):
-        self._data = self._data.consolidate()
-
-    def consolidate(self):
-        """
-        Compute DataFrame with "consolidated" internals (data of each dtype
-        grouped together in a single ndarray). Mainly an internal API function,
-        but available here to the savvy user
-
-        Returns
-        -------
-        consolidated : DataFrame
-        """
-        cons_data = self._data.consolidate()
-        if cons_data is self._data:
-            cons_data = cons_data.copy()
-        return type(self)(cons_data)
-
     #----------------------------------------------------------------------
     # Array interface
 
@@ -2583,12 +2557,6 @@ def _homogenize_series(data, index, dtype=None):
 
     return homogenized
 
-def _default_index(n):
-    if n == 0:
-        return NULL_INDEX
-    else:
-        return np.arange(n)
-
 def _put_str(s, space):
     return ('%s' % s)[:space].ljust(space)
 

pandas/core/generic.py

@@ -29,8 +29,17 @@ class NDFrame(object):
     N-dimensional labeled array data structure with potentially heterogenous
     dtypes along one axis
     """
-    def __init__(self, data):
-        pass
+    def __init__(self, data, axes=None, copy=False):
+        self._data = data
+        self.axes = axes
+
+    def __repr__(self):
+        # TODO
+        return 'NDFrame'
+
+    @property
+    def ndim(self):
+        return self._data.ndim
 
 class PandasGeneric(Picklable):
 
@@ -43,6 +52,35 @@ class PandasGeneric(Picklable):
 
     _AXIS_NAMES = dict((v, k) for k, v in _AXIS_NUMBERS.iteritems())
 
+    #----------------------------------------------------------------------
+    # Consolidation of internals
+
+    def _consolidate_inplace(self):
+        self._data = self._data.consolidate()
+
+    def consolidate(self):
+        """
+        Compute DataFrame with "consolidated" internals (data of each dtype
+        grouped together in a single ndarray). Mainly an internal API function,
+        but available here to the savvy user
+
+        Returns
+        -------
+        consolidated : DataFrame
+        """
+        cons_data = self._data.consolidate()
+        if cons_data is self._data:
+            cons_data = cons_data.copy()
+        return type(self)(cons_data)
+
+    @property
+    def _is_mixed_type(self):
+        self._consolidate_inplace()
+        return len(self._data.blocks) > 1
+
+    #----------------------------------------------------------------------
+    # Axis name business
+
     @classmethod
     def _get_axis_number(cls, axis):
         axis = cls._AXIS_ALIASES.get(axis, axis)
@@ -108,3 +146,10 @@ def _select_generic(self, crit, axis=0):
         new_axis = axis[np.asarray([crit(label) for label in axis])]
         return self.reindex(**{axis_name : new_axis})
 
+    def _reindex_axis(self, new_index, fill_method, axis):
+        if axis == 0:
+            new_data = self._data.reindex_items(new_index)
+        else:
+            new_data = self._data.reindex_axis(new_index, axis=axis,
+                                               method=fill_method)
+        return type(self)(new_data)

pandas/core/panel.py

@@ -9,8 +9,8 @@
 
 import numpy as np
 
-from pandas.core.common import (PandasError, _mut_exclusive,
-                                _ensure_index, _pfixed)
+from pandas.core.common import (PandasError, _mut_exclusive, _ensure_index,
+                                _pfixed, _default_index)
 from pandas.core.index import Index
 from pandas.core.internals import BlockManager, make_block
 from pandas.core.frame import DataFrame
@@ -210,38 +210,20 @@ def __init__(self, data, items=None, major_axis=None, minor_axis=None,
         elif isinstance(data, np.ndarray):
             mgr = self._init_matrix(data, [items, major_axis, minor_axis],
                                     dtype=dtype, copy=copy)
-        else:
+        else: # pragma: no cover
             raise PandasError('Panel constructor not properly called!')
 
         self.factors = {}
         self._data = mgr
 
-    def _consolidate_inplace(self):
-        self._data = self._data.consolidate()
-
-    def consolidate(self):
-        """
-        Compute DataFrame with "consolidated" internals (data of each dtype
-        grouped together in a single ndarray). Mainly an internal API function,
-        but available here to the savvy user
-
-        Returns
-        -------
-        consolidated : DataFrame
-        """
-        cons_data = self._data.consolidate()
-        if cons_data is self._data:
-            cons_data = cons_data.copy()
-        return type(self)(cons_data)
-
     def _init_matrix(self, data, axes, dtype=None, copy=False):
         values = _prep_ndarray(data, copy=copy)
 
         if dtype is not None:
             try:
                 values = values.astype(dtype)
             except Exception:
-                pass
+                raise ValueError('failed to cast to %s' % dtype)
 
         shape = values.shape
         fixed_axes = []
@@ -254,7 +236,7 @@ def _init_matrix(self, data, axes, dtype=None, copy=False):
 
         items = fixed_axes[0]
         block = make_block(values, items, items)
-        return BlockManager([block], axes)
+        return BlockManager([block], fixed_axes)
 
     def _get_plane_axes(self, axis):
         """
@@ -487,47 +469,39 @@ def reindex_like(self, other, method=None):
         return self.reindex(major=other.major_axis, items=other.items,
                             minor=other.minor_axis, method=method)
 
-    def _reindex_axis(self, new_index, fill_method, axis):
-        if axis == 0:
-            new_data = self._data.reindex_items(new_index)
-        else:
-            new_data = self._data.reindex_axis(new_index, axis=axis,
-                                               method=fill_method)
-        return WidePanel(new_data)
-
     def _combine(self, other, func, axis=0):
         if isinstance(other, DataFrame):
-            return self._combineFrame(other, func, axis=axis)
+            return self._combine_frame(other, func, axis=axis)
         elif isinstance(other, Panel):
-            return self._combinePanel(other, func)
+            return self._combine_panel(other, func)
         elif np.isscalar(other):
-            newValues = func(self.values, other)
+            new_values = func(self.values, other)
 
-            return WidePanel(newValues, self.items, self.major_axis,
+            return WidePanel(new_values, self.items, self.major_axis,
                              self.minor_axis)
 
     def __neg__(self):
         return -1 * self
 
-    def _combineFrame(self, other, func, axis=0):
+    def _combine_frame(self, other, func, axis=0):
         index, columns = self._get_plane_axes(axis)
         axis = self._get_axis_number(axis)
 
         other = other.reindex(index=index, columns=columns)
 
         if axis == 0:
-            newValues = func(self.values, other.values)
+            new_values = func(self.values, other.values)
         elif axis == 1:
-            newValues = func(self.values.swapaxes(0, 1), other.values.T)
-            newValues = newValues.swapaxes(0, 1)
+            new_values = func(self.values.swapaxes(0, 1), other.values.T)
+            new_values = new_values.swapaxes(0, 1)
         elif axis == 2:
-            newValues = func(self.values.swapaxes(0, 2), other.values)
-            newValues = newValues.swapaxes(0, 2)
+            new_values = func(self.values.swapaxes(0, 2), other.values)
+            new_values = new_values.swapaxes(0, 2)
 
-        return WidePanel(newValues, self.items, self.major_axis,
+        return WidePanel(new_values, self.items, self.major_axis,
                          self.minor_axis)
 
-    def _combinePanel(self, other, func):
+    def _combine_panel(self, other, func):
         if isinstance(other, LongPanel):
             other = other.to_wide()
 
@@ -1240,14 +1214,14 @@ def __setstate__(self, state):
 
     def _combine(self, other, func, axis='items'):
         if isinstance(other, DataFrame):
-            return self._combineFrame(other, func, axis=axis)
+            return self._combine_frame(other, func, axis=axis)
         elif isinstance(other, Panel):
-            return self._combinePanel(other, func)
+            return self._combine_panel(other, func)
         elif np.isscalar(other):
             return LongPanel(func(self.values, other), self.items,
                              self.index, factors=self.factors)
 
-    def _combineFrame(self, other, func, axis='items'):
+    def _combine_frame(self, other, func, axis='items'):
         """
         Arithmetic op
 
@@ -1262,10 +1236,10 @@ def _combineFrame(self, other, func, axis='items'):
         y : LongPanel
         """
         wide = self.to_wide()
-        result = wide._combineFrame(other, func, axis=axis)
+        result = wide._combine_frame(other, func, axis=axis)
         return result.to_long()
 
-    def _combinePanel(self, other, func):
+    def _combine_panel(self, other, func):
         """
         Arithmetic operation between panels
         """

pandas/tests/test_frame.py

@@ -782,8 +782,8 @@ def test_constructor_more(self):
 
         # can't cast
         mat = np.array(['foo', 'bar'], dtype=object).reshape(2, 1)
-        df = DataFrame(mat, index=[0, 1], columns=[0], dtype=float)
-        self.assert_(df.values.dtype == np.object_)
+        self.assertRaises(ValueError, DataFrame, mat, index=[0, 1],
+                          columns=[0], dtype=float)
 
         dm = self.klass(DataFrame(self.frame._series))
         tm.assert_frame_equal(dm, self.frame)

pandas/tests/test_panel.py

@@ -165,6 +165,20 @@ def test_get_axis(self):
         assert(self.panel._get_axis(1) is self.panel.major_axis)
         assert(self.panel._get_axis(2) is self.panel.minor_axis)
 
+    def test_set_axis(self):
+        new_items = Index(np.arange(len(self.panel.items)))
+        new_major = Index(np.arange(len(self.panel.major_axis)))
+        new_minor = Index(np.arange(len(self.panel.minor_axis)))
+
+        self.panel.items = new_items
+        self.assert_(self.panel.items is new_items)
+
+        self.panel.major_axis = new_major
+        self.assert_(self.panel.major_axis is new_major)
+
+        self.panel.minor_axis = new_minor
+        self.assert_(self.panel.minor_axis is new_minor)
+
     def test_get_axis_number(self):
         self.assertEqual(self.panel._get_axis_number('items'), 0)
         self.assertEqual(self.panel._get_axis_number('major'), 1)
@@ -311,6 +325,32 @@ def setUp(self):
         self.panel = common.makeWidePanel()
         common.add_nans(self.panel)
 
+    def test_constructor(self):
+        # with BlockManager
+        wp = WidePanel(self.panel._data)
+        self.assert_(wp._data is self.panel._data)
+
+        wp = WidePanel(self.panel._data, copy=True)
+        self.assert_(wp._data is not self.panel._data)
+        assert_panel_equal(wp, self.panel)
+
+    def test_constructor_cast(self):
+        casted = WidePanel(self.panel._data, dtype=int)
+        casted2 = WidePanel(self.panel.values, dtype=int)
+
+        exp_values = self.panel.values.astype(int)
+        assert_almost_equal(casted.values, exp_values)
+        assert_almost_equal(casted2.values, exp_values)
+
+    def test_consolidate(self):
+        self.assert_(self.panel._data.is_consolidated())
+
+        self.panel['foo'] = 1.
+        self.assert_(not self.panel._data.is_consolidated())
+
+        panel = self.panel.consolidate()
+        self.assert_(panel._data.is_consolidated())
+
     def test_values(self):
         # nothing to test for the moment
         values = self.panel.values