TST: unit tests, and left justify index float formatting

Author: wesm

pandas/core/format.py

@@ -401,7 +401,7 @@ def _get_column_name_list(self):
 
 
 def format_array(values, formatter, float_format=None, na_rep='NaN',
-                 digits=None, space=None):
+                 digits=None, space=None, justify='right'):
     if com.is_float_dtype(values.dtype):
         fmt_klass = FloatArrayFormatter
     elif com.is_integer_dtype(values.dtype):
@@ -420,7 +420,8 @@ def format_array(values, formatter, float_format=None, na_rep='NaN',
 
     fmt_obj = fmt_klass(values, digits, na_rep=na_rep,
                         float_format=float_format,
-                        formatter=formatter, space=space)
+                        formatter=formatter, space=space,
+                        justify=justify)
 
     return fmt_obj.get_result()
 
@@ -496,7 +497,11 @@ def get_result(self):
             fmt_str = '%% .%df' % (self.digits - 1)
             fmt_values = self._format_with(fmt_str)
 
-            maxlen = max(len(x) for x in fmt_values)
+            if len(fmt_values) > 0:
+                maxlen = max(len(x) for x in fmt_values)
+            else:
+                maxlen =0
+
             too_long = maxlen > self.digits + 5
 
             # this is pretty arbitrary for now
@@ -506,7 +511,7 @@ def get_result(self):
                 fmt_str = '%% .%de' % (self.digits - 1)
                 fmt_values = self._format_with(fmt_str)
 
-        return _make_fixed_width(fmt_values)
+        return _make_fixed_width(fmt_values, self.justify)
 
 
 class IntArrayFormatter(GenericArrayFormatter):

pandas/core/index.py

@@ -281,7 +281,7 @@ def format(self, name=False):
         if values.dtype == np.object_:
             result = [com._stringify(x) for x in values]
         else:
-            result = _trim_front(format_array(values, None))
+            result = _trim_front(format_array(values, None, justify='left'))
         return header + result
 
     def equals(self, other):

pandas/core/series.py

@@ -47,18 +47,14 @@ def na_op(x, y):
         try:
             result = op(x, y)
         except TypeError:
-            if isinstance(x, np.ndarray) and isinstance(y, np.ndarray):
+            if isinstance(y, np.ndarray):
                 mask = notnull(x) & notnull(y)
                 result = np.empty(len(x), dtype=x.dtype)
                 result[mask] = op(x[mask], y[mask])
-            elif isinstance(x, np.ndarray):
+            else:
                 mask = notnull(x)
                 result = np.empty(len(x), dtype=x.dtype)
                 result[mask] = op(x[mask], y)
-            else:
-                mask = notnull(y)
-                result = np.empty(len(y), dtype=y.dtype)
-                result[mask] = op(x, y[mask])
 
         return result
 

pandas/sparse/frame.py

@@ -100,10 +100,6 @@ def _from_axes(self, data, axes):
     def _data(self):
         return _SparseMockBlockManager(self)
 
-    def _get_numeric_columns(self):
-        # everything is necessarily float64
-        return self.columns
-
     def _consolidate_inplace(self):
         # do nothing when DataFrame calls this method
         pass
@@ -222,10 +218,7 @@ def to_dense(self):
         return DataFrame(data, index=self.index)
 
     def astype(self, dtype):
-        new_series = dict((k, v.astype(dtype)) for k, v in self.iteritems())
-        return SparseDataFrame(new_series, index=self.index, columns=self.columns,
-                               default_fill_value=self.default_fill_value,
-                               default_kind=self.default_kind)
+        raise NotImplementedError
 
     def copy(self, deep=True):
         """

pandas/tests/test_format.py

@@ -561,15 +561,11 @@ def test_rounding(self):
         self.assertEqual(result, u' 0.000')
 
 
-# class TestFloatArrayFormatter(unittest.TestCase):
-
-#     def test_trim_zeros(self):
-#         values = np.array([1.5, 2.5, 3.5])
-#         fmt = FloatArrayFormatter(values)
-
-#         result = fmt.get_result()
-#         pass
+class TestFloatArrayFormatter(unittest.TestCase):
 
+    def test_misc(self):
+        obj = fmt.FloatArrayFormatter(np.array([], dtype=np.float64))
+        result = obj.get_result()
 
 if __name__ == '__main__':
     import nose

pandas/tools/merge.py

@@ -56,12 +56,8 @@ def __init__(self, left, right, how='inner', on=None,
         self.left_on = com._maybe_make_list(left_on)
         self.right_on = com._maybe_make_list(right_on)
 
-        self.drop_keys = False # set this later...kludge
-
         self.copy = copy
-
         self.suffixes = suffixes
-
         self.sort = sort
 
         self.left_index = left_index
@@ -91,26 +87,33 @@ def get_result(self):
         return result
 
     def _maybe_add_join_keys(self, result, left_indexer, right_indexer):
-        if not self.drop_keys:
-            # do nothing, already found in one of the DataFrames
-            return
-
         # insert group keys
-        for i, name in enumerate(self.join_names):
+
+        keys = zip(self.join_names, self.left_on, self.right_on)
+        for i, (name, lname, rname) in enumerate(keys):
+            if not _should_fill(lname, rname):
+                continue
+
             if name in result:
                 key_col = result[name]
 
-                if name in self.left:
+                if name in self.left and left_indexer is not None:
                     na_indexer = (left_indexer == -1).nonzero()[0]
+                    if len(na_indexer) == 0:
+                        continue
+
                     right_na_indexer = right_indexer.take(na_indexer)
                     key_col.put(na_indexer, com.take_1d(self.right_join_keys[i],
                                                         right_na_indexer))
-                else:
+                elif name in self.right and right_indexer is not None:
                     na_indexer = (right_indexer == -1).nonzero()[0]
-                    left_na_indexer = right_indexer.take(na_indexer)
+                    if len(na_indexer) == 0:
+                        continue
+
+                    left_na_indexer = left_indexer.take(na_indexer)
                     key_col.put(na_indexer, com.take_1d(self.left_join_keys[i],
                                                         left_na_indexer))
-            else:
+            elif left_indexer is not None:
                 # a faster way?
                 key_col = com.take_1d(self.left_join_keys[i], left_indexer)
                 na_indexer = (left_indexer == -1).nonzero()[0]
@@ -181,30 +184,41 @@ def _get_merge_keys(self):
             and self.right_on is None):
 
             if self.left_index and self.right_index:
-                pass
+                self.left_on, self.right_on = (), ()
             elif self.left_index:
                 if self.right_on is None:
                     raise Exception('Must pass right_on or right_index=True')
+                self.left_on = [None] * self.left.index.nlevels
             elif self.right_index:
                 if self.left_on is None:
                     raise Exception('Must pass left_on or left_index=True')
+                self.right_on = [None] * self.right.index.nlevels
             else:
                 # use the common columns
                 common_cols = self.left.columns.intersection(self.right.columns)
                 self.left_on = self.right_on = common_cols
-                self.drop_keys = True
-
         elif self.on is not None:
             if self.left_on is not None or self.right_on is not None:
                 raise Exception('Can only pass on OR left_on and '
                                 'right_on')
             self.left_on = self.right_on = self.on
-            self.drop_keys = True
+        elif self.left_on is not None:
+            n = len(self.left_on)
+            if self.right_index:
+                self.right_on = [None] * n
+            else:
+                assert(len(self.right_on) == n)
+        elif self.right_on is not None:
+            n = len(self.right_on)
+            if self.left_index:
+                self.left_on = [None] * n
+            else:
+                assert(len(self.left_on) == n)
 
         left_keys = []
         right_keys = []
         join_names = []
-        left_drop, right_drop = [], []
+        right_drop = []
         left, right = self.left, self.right
 
         is_lkey = lambda x: isinstance(x, np.ndarray) and len(x) == len(left)
@@ -249,8 +263,6 @@ def _get_merge_keys(self):
 
         if right_drop:
             self.right = self.right.drop(right_drop, axis=1)
-        if left_drop:
-            self.left = self.left.drop(left_drop, axis=1)
 
         return left_keys, right_keys, join_names
 
@@ -1006,6 +1018,11 @@ def _consensus_name_attr(objs):
             return None
     return name
 
+def _should_fill(lname, rname):
+    if not isinstance(lname, basestring) or not isinstance(rname, basestring):
+        return True
+    return lname == rname
+
 def _all_indexes_same(indexes):
     first = indexes[0]
     for index in indexes[1:]:
@@ -1014,4 +1031,4 @@ def _all_indexes_same(indexes):
     return True
 
 def _any(x):
-    return x is not None and len(x) > 0
+    return x is not None and len(x) > 0 and any([y is not None for y in x])

pandas/tools/tests/test_merge.py

@@ -530,6 +530,19 @@ def test_intelligently_handle_join_key(self):
 
         self.assert_(joined._data.is_consolidated())
 
+    def test_handle_join_key_pass_array(self):
+        left = DataFrame({'key' : [1, 1, 2, 2, 3],
+                          'value' : range(5)}, columns=['value', 'key'])
+        right = DataFrame({'rvalue' : range(6)})
+        key = np.array([1, 1, 2, 3, 4, 5])
+
+        merged = merge(left, right, left_on='key', right_on=key, how='outer')
+        merged2 = merge(right, left, left_on=key, right_on='key', how='outer')
+
+        assert_series_equal(merged['key'], merged2['key'])
+        self.assert_(merged['key'].notnull().all())
+        self.assert_(merged2['key'].notnull().all())
+
 class TestMergeMulti(unittest.TestCase):
 
     def setUp(self):