TST: round out test coverage in pandas.core

Author: wesm

pandas/core/frame.py

@@ -144,7 +144,7 @@ def __init__(self, data=None, index=None, columns=None, dtype=None,
                 mgr = mgr.copy()
             elif dtype is not None:
                 # no choice but to copy
-                mgr = mgr.cast(dtype)
+                mgr = mgr.astype(dtype)
         elif isinstance(data, dict):
             mgr = self._init_dict(data, index, columns, dtype=dtype)
         elif isinstance(data, np.ndarray):

pandas/core/generic.py

@@ -163,6 +163,8 @@ def drop(self, labels, axis=0):
 
 class NDFrame(PandasObject):
     """
+    N-dimensional analogue of DataFrame. Store multi-dimensional in a
+    size-mutable, labeled data structure
 
     Parameters
     ----------
@@ -174,6 +176,9 @@ class NDFrame(PandasObject):
     _default_stat_axis = 0
 
     def __init__(self, data, axes=None, copy=False, dtype=None):
+        if dtype is not None:
+            data = data.astype(dtype)
+
         self._data = data
 
     def astype(self, dtype):

pandas/core/internals.py

@@ -320,7 +320,7 @@ def _verify_integrity(self):
         tot_items = sum(len(x.items) for x in self.blocks)
         assert(len(self.items) == tot_items)
 
-    def cast(self, dtype):
+    def astype(self, dtype):
         new_blocks = []
         for block in self.blocks:
             newb = make_block(block.values.astype(dtype), block.items,

pandas/core/panel.py

@@ -143,7 +143,7 @@ def __init__(self, data, items=None, major_axis=None, minor_axis=None,
                 mgr = mgr.copy()
             elif dtype is not None:
                 # no choice but to copy
-                mgr = mgr.cast(dtype)
+                mgr = mgr.astype(dtype)
         elif isinstance(data, dict):
             mgr = self._init_dict(data, passed_axes, dtype=dtype)
         elif isinstance(data, (np.ndarray, list)):
@@ -464,7 +464,7 @@ def reindex(self, major=None, items=None, minor=None, method=None,
         if items is not None:
             result = result._reindex_axis(items, method, 0, copy)
 
-        if result is self:
+        if result is self and copy:
             raise ValueError('Must specify at least one axis')
 
         return result

pandas/core/sparse.py

@@ -1463,9 +1463,15 @@ def to_long(self, filter_observations=True):
     def reindex(self, major=None, items=None, minor=None, major_axis=None,
                 minor_axis=None, copy=False):
         """
+        Conform / reshape panel axis labels to new input labels
 
         Parameters
         ----------
+        major : array-like, default None
+        items : array-like, default None
+        minor : array-like, default None
+        copy : boolean, default False
+            Copy underlying SparseDataFrame objects
 
         Returns
         -------

pandas/io/pytables.py

@@ -82,15 +82,12 @@ class HDFStore(object):
             and if the file does not exist it is created.
         ``'r+'``
             It is similar to ``'a'``, but the file must already exist.
-
     complevel : int, 1-9, default 0
             If a complib is specified compression will be applied
             where possible
-
     complib : {'zlib', 'bzip2', 'lzo', 'blosc', None}, default None
             If complevel is > 0 apply compression to objects written
             in the store wherever possible
-
     fletcher32 : bool, default False
             If applying compression use the fletcher32 checksum
 
@@ -101,7 +98,8 @@ class HDFStore(object):
     >>> bar = store['foo']   # retrieve
     >>> store.close()
     """
-    def __init__(self, path, mode='a', complevel=0, complib=None, fletcher32=False):
+    def __init__(self, path, mode='a', complevel=0, complib=None,
+                 fletcher32=False):
         try:
             import tables as _
         except ImportError: # pragma: no cover

pandas/io/tests/test_pytables.py

@@ -159,8 +159,15 @@ def test_frame(self):
         self._check_roundtrip_table(df, tm.assert_frame_equal)
         self._check_roundtrip(df, tm.assert_frame_equal)
 
+        self._check_roundtrip_table(df, tm.assert_frame_equal,
+                                    compression=True)
+        self._check_roundtrip(df, tm.assert_frame_equal,
+                                    compression=True)
+
         tdf = tm.makeTimeDataFrame()
         self._check_roundtrip(tdf, tm.assert_frame_equal)
+        self._check_roundtrip(tdf, tm.assert_frame_equal,
+                              compression=True)
 
     def test_store_mixed(self):
         def _make_one():
@@ -283,8 +290,13 @@ def test_select_filter_corner(self):
         result = self.store.select('frame', [crit])
         tm.assert_frame_equal(result, df.ix[:, df.columns[:75]])
 
-    def _check_roundtrip(self, obj, comparator):
-        store = HDFStore(self.scratchpath, 'w')
+    def _check_roundtrip(self, obj, comparator, compression=False):
+        options = {}
+        if compression:
+            options['complevel'] = 9
+            options['complib'] = 'blosc'
+
+        store = HDFStore(self.scratchpath, 'w', **options)
         try:
             store['obj'] = obj
             retrieved = store['obj']
@@ -293,8 +305,13 @@ def _check_roundtrip(self, obj, comparator):
             store.close()
             os.remove(self.scratchpath)
 
-    def _check_roundtrip_table(self, obj, comparator):
-        store = HDFStore(self.scratchpath, 'w')
+    def _check_roundtrip_table(self, obj, comparator, compression=False):
+        options = {}
+        if compression:
+            options['complevel'] = 9
+            options['complib'] = 'blosc'
+
+        store = HDFStore(self.scratchpath, 'w', **options)
         try:
             store.put('obj', obj, table=True)
             retrieved = store['obj']

pandas/tests/test_functions.py

@@ -1,5 +1,5 @@
 from pandas import Index, isnull
-import pandas.core.functions as fns
+import pandas.sandbox.functions as fns
 import numpy as np
 import unittest
 import numpy as np

pandas/tests/test_ndframe.py

@@ -0,0 +1,30 @@
+import unittest
+
+import numpy as np
+
+from pandas.core.generic import NDFrame
+import pandas.util.testing as t
+
+class TestNDFrame(unittest.TestCase):
+
+    def setUp(self):
+        tdf = t.makeTimeDataFrame()
+        self.ndf = NDFrame(tdf._data)
+
+    def test_constructor(self):
+        # with cast
+        ndf = NDFrame(self.ndf._data, dtype=int)
+        self.assert_(ndf.values.dtype == np.int_)
+
+    def test_ndim(self):
+        self.assertEquals(self.ndf.ndim, 2)
+
+    def test_astype(self):
+        casted = self.ndf.astype(int)
+        self.assert_(casted.values.dtype == np.int_)
+
+if __name__ == '__main__':
+    import nose
+    nose.runmodule(argv=[__file__,'-vvs','-x','--pdb', '--pdb-failure'],
+                   exit=False)
+

pandas/tests/test_panel.py

@@ -522,8 +522,12 @@ def test_reindex(self):
         assert_frame_equal(larger.major_xs(self.panel.major_axis[1]),
                            smaller.major_xs(smaller_major[0]))
 
-        # reindex_like
+        # don't necessarily copy
+        result = self.panel.reindex(major=self.panel.major_axis, copy=False)
+        self.assert_(result is self.panel)
 
+    def test_reindex_like(self):
+        # reindex_like
         smaller = self.panel.reindex(items=self.panel.items[:-1],
                                      major=self.panel.major_axis[:-1],
                                      minor=self.panel.minor_axis[:-1])