TST: added core coverage

Author: adamklein

pandas/core/common.py

@@ -630,12 +630,6 @@ def console_encode(value):
     except (AttributeError, TypeError):
         return value.encode('ascii', 'replace')
 
-def csv_encode(value, encoding='UTF-8'):
-    if py3compat.PY3 or not isinstance(value, unicode):
-        return value
-
-    return value.encode(encoding, 'replace')
-
 class UTF8Recoder:
     """
     Iterator that reads an encoded stream and reencodes the input to UTF-8
@@ -709,7 +703,3 @@ def writerow(self, row):
             self.stream.write(data)
             # empty queue
             self.queue.truncate(0)
-
-        def writerows(self, rows):
-            for row in rows:
-                self.writerow(row)

pandas/core/frame.py

@@ -2245,7 +2245,7 @@ def sort(self, columns=None, column=None, axis=0, ascending=True):
         -------
         sorted : DataFrame
         """
-        if column is not None:
+        if column is not None: # pragma: no cover
             import warnings
             warnings.warn("column is deprecated, use columns", FutureWarning)
             columns = column

pandas/core/internals.py

@@ -229,7 +229,7 @@ def _pad(values):
         _method = lib.pad_2d_inplace_float64
     elif values.dtype == np.object_:
         _method = lib.pad_2d_inplace_object
-    else:
+    else: # pragma: no cover
         raise ValueError('Invalid dtype for padding')
 
     _method(values, com.isnull(values).view(np.uint8))
@@ -239,7 +239,7 @@ def _backfill(values):
         _method = lib.backfill_2d_inplace_float64
     elif values.dtype == np.object_:
         _method = lib.backfill_2d_inplace_object
-    else:
+    else: # pragma: no cover
         raise ValueError('Invalid dtype for padding')
 
     _method(values, com.isnull(values).view(np.uint8))
@@ -608,9 +608,6 @@ def consolidate(self):
         return BlockManager(new_blocks, self.axes)
 
     def _consolidate_inplace(self):
-        if self.is_consolidated():
-            return
-
         self.blocks = _consolidate(self.blocks, self.items)
 
     def get(self, item):

pandas/core/series.py

@@ -108,7 +108,7 @@ def wrapper(self, other):
             name = _maybe_match_name(self, other)
             return Series(na_op(self.values, other.values),
                           index=self.index, name=name)
-        elif isinstance(other, DataFrame):
+        elif isinstance(other, DataFrame): # pragma: no cover
             return NotImplemented
         else:
             # scalars

pandas/tests/test_format.py

@@ -187,7 +187,8 @@ def test_to_string_no_index(self):
 
     def test_to_string_float_formatting(self):
         fmt.reset_printoptions()
-        fmt.set_printoptions(precision=6, column_space=12)
+        fmt.set_printoptions(precision=6, column_space=12,
+                             notebook_repr_html=False)
 
         df = DataFrame({'x' : [0, 0.25, 3456.000, 12e+45, 1.64e+6,
                                1.7e+8, 1.253456, np.pi, -1e6]})
@@ -341,6 +342,13 @@ def test_to_html_with_no_bold(self):
     def test_repr_html(self):
         self.frame._repr_html_()
 
+        fmt.set_printoptions(max_rows=1, max_columns=1)
+        self.frame._repr_html_()
+
+        fmt.set_printoptions(notebook_repr_html=False)
+        self.frame._repr_html_()
+
+        fmt.reset_printoptions()
 
 class TestSeriesFormatting(unittest.TestCase):
 

pandas/tests/test_frame.py

@@ -1174,6 +1174,17 @@ def test_constructor(self):
         df = DataFrame(data={})
         self.assert_(len(df.index) == 0)
 
+    def test_list_to_sdict(self):
+        from pandas.core.frame import _list_to_sdict
+
+        d, c = _list_to_sdict([], None)
+        self.assertEquals(d, {})
+        self.assertEquals(c, [])
+
+        d, c = _list_to_sdict([], [])
+        self.assertEquals(d, {})
+        self.assertEquals(c, [])
+
     def test_constructor_mixed(self):
         index, data = tm.getMixedTypeDict()
 
@@ -1536,8 +1547,8 @@ def test_constructor_list_of_series(self):
         data = [Series(d) for d in data]
 
         result = DataFrame(data)
-        expected = DataFrame.from_dict(dict(zip(range(len(data)), data)),
-                                       orient='index')
+        sdict = dict(zip(range(len(data)), data))
+        expected = DataFrame.from_dict(sdict, orient='index')
         assert_frame_equal(result, expected.reindex(result.index))
 
         result2 = DataFrame(data, index=np.arange(6))
@@ -1547,6 +1558,15 @@ def test_constructor_list_of_series(self):
         expected = DataFrame(index=[0])
         assert_frame_equal(result, expected)
 
+        data = [{'a': 1.5, 'b': 3.0, 'c':4.0},
+                {'a': 1.5, 'b': 3.0, 'c':6.0}]
+        sdict = dict(zip(range(len(data)), data))
+        idx = Index(['a', 'b', 'c'])
+        data2 = [Series([1.5, 3, 4], idx, dtype='O'),
+                 Series([1.5, 3, 6], idx)]
+        result = DataFrame(data2)
+        expected = DataFrame.from_dict(sdict, orient='index')
+        assert_frame_equal(result, expected)
 
     def test_constructor_ragged(self):
         data = {'A' : randn(10),
@@ -1893,6 +1913,10 @@ def test_repr(self):
 
         fmt.set_printoptions(max_rows=10, max_columns=2)
         repr(self.frame)
+
+        fmt.set_printoptions(max_rows=1000, max_columns=1000)
+        repr(self.frame)
+
         fmt.reset_printoptions()
 
     def test_head_tail(self):
@@ -3302,6 +3326,21 @@ def test_align(self):
         af, bf = self.frame.align(other, join='inner', axis=1)
         self.assert_(bf.columns.equals(other.columns))
 
+        af, bf = self.frame.align(other, join='inner', axis=1, method='pad')
+        self.assert_(bf.columns.equals(other.columns))
+
+        # test other non-float types
+        af, bf = self.intframe.align(other, join='inner', axis=1, method='pad')
+        self.assert_(bf.columns.equals(other.columns))
+
+        af, bf = self.mixed_frame.align(self.mixed_frame,
+                                        join='inner', axis=1, method='pad')
+        self.assert_(bf.columns.equals(self.mixed_frame.columns))
+
+        af, bf = self.frame.align(other.ix[:,0], join='inner', axis=1,
+                                  method=None, fill_value=None)
+        self.assert_(bf.index.equals(Index([])))
+
         # try to align dataframe to series along bad axis
         self.assertRaises(ValueError, self.frame.align, af.ix[0,:3],
                           join='inner', axis=2)
@@ -4614,6 +4653,13 @@ def test_consolidate(self):
         self.frame.consolidate(inplace=True)
         self.assert_(len(self.frame._data.blocks) == 1)
 
+    def test_consolidate_inplace(self):
+        frame = self.frame.copy()
+
+        # triggers in-place consolidation
+        for letter in range(ord('A'), ord('Z')):
+            self.frame[chr(letter)] = chr(letter)
+
     def test_as_matrix_consolidate(self):
         self.frame['E'] = 7.
         self.assert_(not self.frame._data.is_consolidated())

pandas/tests/test_graphics.py

@@ -14,9 +14,9 @@ class TestSeriesPlots(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        import sys
-        if 'IPython' in sys.modules:
-            raise nose.SkipTest
+        #import sys
+        #if 'IPython' in sys.modules:
+        #    raise nose.SkipTest
 
         try:
             import matplotlib as mpl
@@ -50,9 +50,9 @@ class TestDataFramePlots(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        import sys
-        if 'IPython' in sys.modules:
-            raise nose.SkipTest
+        #import sys
+        #if 'IPython' in sys.modules:
+        #    raise nose.SkipTest
 
         try:
             import matplotlib as mpl

pandas/tests/test_groupby.py

@@ -204,6 +204,25 @@ def test_agg_apply_corner(self):
         assert_frame_equal(grouped.agg(np.sum), DataFrame({}))
         assert_frame_equal(grouped.apply(np.sum), DataFrame({}))
 
+    def test_agg_grouping_is_list_tuple(self):
+        from pandas.core.groupby import Grouping
+
+        df = tm.makeTimeDataFrame()
+
+        grouped = df.groupby(lambda x: x.year)
+        grouper = grouped.grouper.groupings[0].grouper
+        grouped.grouper.groupings[0] = Grouping(self.ts.index, list(grouper))
+
+        result = grouped.agg(np.mean)
+        expected = grouped.mean()
+        tm.assert_frame_equal(result, expected)
+
+        grouped.grouper.groupings[0] = Grouping(self.ts.index, tuple(grouper))
+
+        result = grouped.agg(np.mean)
+        expected = grouped.mean()
+        tm.assert_frame_equal(result, expected)
+
     def test_agg_python_multiindex(self):
         grouped = self.mframe.groupby(['A', 'B'])
 
@@ -475,6 +494,16 @@ def test_frame_groupby(self):
             samething = self.tsframe.index.take(indices[k])
             self.assert_(np.array_equal(v, samething))
 
+    def test_grouping_is_iterable(self):
+        # this code path isn't used anywhere else
+        # not sure it's useful
+        grouped = self.tsframe.groupby([lambda x: x.weekday(),
+                                        lambda x: x.year])
+
+        # test it works
+        for g in grouped.grouper.groupings[0]:
+            pass
+
     def test_frame_groupby_columns(self):
         mapping = {
             'A' : 0, 'B' : 0, 'C' : 1, 'D' : 1

pandas/tests/test_panel.py

@@ -864,6 +864,13 @@ def test_fillna(self):
         assert_frame_equal(filled['ItemA'],
                            self.panel['ItemA'].fillna(method='backfill'))
 
+        panel = self.panel.copy()
+        panel['str'] = 'foo'
+
+        filled = panel.fillna(method='backfill')
+        assert_frame_equal(filled['ItemA'],
+                           panel['ItemA'].fillna(method='backfill'))
+
         empty = self.panel.reindex(items=[])
         filled = empty.fillna(0)
         assert_panel_equal(filled, empty)

pandas/tests/test_series.py

@@ -1149,6 +1149,15 @@ def test_between(self):
         expected = s[5:16].dropna()
         assert_series_equal(result, expected)
 
+    def test_scalar_na_cmp(self):
+        s = Series([2,3,4,5,6,7,8,9,10])
+        s[::2] = np.nan
+
+        def tester(a, b):
+            return a & b
+
+        self.assertRaises(ValueError, tester, s, datetime(2005,1,1))
+
     def test_idxmin(self):
         # test idxmin
         # _check_stat_op approach can not be used here because of isnull check.
@@ -1258,6 +1267,7 @@ def test_operators_frame(self):
 
         tm.assert_almost_equal(self.ts + self.ts, (self.ts + df)['A'])
         tm.assert_almost_equal(self.ts ** self.ts, (self.ts ** df)['A'])
+        tm.assert_almost_equal(self.ts < self.ts, (self.ts < df)['A'])
 
     def test_operators_combine(self):
         def _check_fill(meth, op, a, b, fill_value=0):