Revert "try to fix interpolation problem the elegant way - does not seem to work"

This reverts commit ce22584.

Author: CloseChoice

pandas/core/generic.py

@@ -6881,52 +6881,55 @@ def interpolate(
         inplace = validate_bool_kwarg(inplace, "inplace")
 
         axis = self._get_axis_number(axis)
-        axis_index = self._get_axis(axis)
 
-        if isinstance(axis_index, MultiIndex) and method != "linear":
+        if axis == 0:
+            df = self
+        else:
+            df = self.T
+
+        if isinstance(df.index, MultiIndex) and method != "linear":
             raise ValueError(
                 "Only `method=linear` interpolation is supported on MultiIndexes."
             )
 
-        if self.ndim == 2 and np.all(self.dtypes == np.dtype(object)):
+        if df.ndim == 2 and np.all(df.dtypes == np.dtype(object)):
             raise TypeError(
                 "Cannot interpolate with all object-dtype columns "
                 "in the DataFrame. Try setting at least one "
                 "column to a numeric dtype."
             )
 
         # create/use the index
-        if method in ["linear"]:
+        if method in ["linear", "bfill", "ffill", "pad"]:
             # prior default
-            axis_index = np.arange(len(axis_index))
+            index = np.arange(len(df.index))
         else:
-            methods = {"index", "values", "nearest", "time", "bfill", "ffill", "pad"}
+            index = df.index
+            methods = {"index", "values", "nearest", "time"}
             is_numeric_or_datetime = (
-                is_numeric_dtype(axis_index)
-                or is_datetime64_any_dtype(axis_index)
-                or is_timedelta64_dtype(axis_index)
+                is_numeric_dtype(index)
+                or is_datetime64_any_dtype(index)
+                or is_timedelta64_dtype(index)
             )
             if method not in methods and not is_numeric_or_datetime:
                 raise ValueError(
                     "Index column must be numeric or datetime type when "
-                    f"using {method} method other than linear. "
+                    f"using {method} method other than linear, bfill, ffill or pad. "
                     "Try setting a numeric or datetime index column before "
                     "interpolating."
                 )
 
-        if isna(axis_index).any():
+        if isna(index).any():
             raise NotImplementedError(
                 "Interpolation with NaNs in the index "
                 "has not been implemented. Try filling "
                 "those NaNs before interpolating."
             )
-        data = self._mgr
-        print(self)
-        print(f'data: {data}')
+        data = df._mgr
         new_data = data.interpolate(
             method=method,
-            axis=axis,
-            index=axis_index,
+            axis=self._info_axis_number,
+            index=index,
             limit=limit,
             limit_direction=limit_direction,
             limit_area=limit_area,
@@ -6936,6 +6939,8 @@ def interpolate(
         )
 
         result = self._constructor(new_data)
+        if axis == 1:
+            result = result.T
         if inplace:
             return self._update_inplace(result)
         else:

pandas/core/internals/blocks.py

@@ -1211,8 +1211,7 @@ def func(x):
             )
 
         # interp each column independently
-        print(data)
-        interp_values = np.apply_along_axis(func, 1, data)
+        interp_values = np.apply_along_axis(func, axis, data)
 
         blocks = [self.make_block_same_class(interp_values)]
         return self._maybe_downcast(blocks, downcast)

pandas/core/internals/managers.py

@@ -555,7 +555,6 @@ def diff(self, n: int, axis: int) -> "BlockManager":
         return self.apply("diff", n=n, axis=axis)
 
     def interpolate(self, **kwargs) -> "BlockManager":
-        #import pdb; pdb.set_trace()
         return self.apply("interpolate", **kwargs)
 
     def shift(self, periods: int, axis: int, fill_value) -> "BlockManager":

pandas/tests/frame/methods/test_interpolate.py

@@ -295,7 +295,22 @@ def test_interp_ffill(self, axis):
                 "C": [3.0, 6.0, 9.0, np.nan, np.nan, 30.0],
             }
         )
-        expected = df.ffill(axis=axis)
+        if axis == 0:
+            expected = DataFrame(
+                {
+                    "A": [1.0, 2.0, 3.0, 4.0, np.nan, 5.0],
+                    "B": [2.0, 4.0, 6.0, 4.0, 8.0, 10.0],
+                    "C": [3.0, 6.0, 9.0, 4.0, 8.0, 30.0],
+                }
+            )
+        if axis == 1:
+            expected = DataFrame(
+                {
+                    "A": [1.0, 2.0, 3.0, 4.0, 4.0, 5.0],
+                    "B": [2.0, 4.0, 6.0, 6.0, 8.0, 10.0],
+                    "C": [3.0, 6.0, 9.0, 9.0, 9.0, 30.0],
+                }
+            )
         result = df.interpolate(method="ffill", axis=axis)
         tm.assert_frame_equal(result, expected)
 
@@ -309,7 +324,22 @@ def test_interp_bfill(self, axis):
                 "C": [3.0, 6.0, 9.0, np.nan, np.nan, 30.0],
             }
         )
-        expected = df.bfill(axis=axis)
+        if axis == 0:
+            expected = DataFrame(
+                {
+                    "A": [1.0, 2.0, 3.0, 4.0, 8.0, 5.0],
+                    "B": [2.0, 4.0, 6.0, np.nan, 8.0, 10.0],
+                    "C": [3.0, 6.0, 9.0, np.nan, np.nan, 30.0],
+                }
+            )
+        if axis == 1:
+            expected = DataFrame(
+                {
+                    "A": [1.0, 2.0, 3.0, 4.0, 5.0, 5.0],
+                    "B": [2.0, 4.0, 6.0, 8.0, 8.0, 10.0],
+                    "C": [3.0, 6.0, 9.0, 30.0, 30.0, 30.0],
+                }
+            )
         result = df.interpolate(method="bfill", axis=axis)
         tm.assert_frame_equal(result, expected)
 
@@ -323,6 +353,21 @@ def test_interp_pad(self, axis):
                 "C": [3.0, 6.0, 9.0, np.nan, np.nan, 30.0],
             }
         )
-        expected = df.fillna(method='pad', axis=axis)
+        if axis == 0:
+            expected = DataFrame(
+                {
+                    "A": [1.0, 2.0, 3.0, 4.0, np.nan, 5.0],
+                    "B": [2.0, 4.0, 6.0, 4.0, 8.0, 10.0],
+                    "C": [3.0, 6.0, 9.0, 4.0, 8.0, 30.0],
+                }
+            )
+        if axis == 1:
+            expected = DataFrame(
+                {
+                    "A": [1.0, 2.0, 3.0, 4.0, 4.0, 5.0],
+                    "B": [2.0, 4.0, 6.0, 6.0, 8.0, 10.0],
+                    "C": [3.0, 6.0, 9.0, 9.0, 9.0, 30.0],
+                }
+            )
         result = df.interpolate(method="pad", axis=axis)
         tm.assert_frame_equal(result, expected)

pandas/tests/series/methods/test_interpolate.py

@@ -660,7 +660,7 @@ def test_interp_non_timedelta_index(self, interp_methods_ind, ind):
         else:
             expected_error = (
                 "Index column must be numeric or datetime type when "
-                f"using {method} method other than linear. "
+                f"using {method} method other than linear, bfill, ffill or pad. "
                 "Try setting a numeric or datetime index column before "
                 "interpolating."
             )