Passing all the non-time tests

pandas/core/window/ewm.py

@@ -819,36 +819,44 @@ def mean(self, *args, update=None, update_times=None, **kwargs):
         1  0.75  5.75
         """
         result_kwargs = {}
+        is_frame = True if self._selected_obj.ndim == 2 else False
         if update is not None:
             if self._mean.last_ewm is None:
                 raise ValueError(
                     "Must call mean with update=None first before passing update"
                 )
             result_from = 1
             result_kwargs["index"] = update.index
-            if update.ndim == 2:
+            if is_frame:
                 last_value = self._mean.last_ewm[np.newaxis, :]
                 result_kwargs["columns"] = update.columns
             else:
                 last_value = self._mean.last_ewm
                 result_kwargs["name"] = update.name
-            obj = np.concatenate((last_value, update.to_numpy()))
+            np_array = np.concatenate((last_value, update.to_numpy()))
         else:
             result_from = 0
             result_kwargs["index"] = self._selected_obj.index
-            if self._selected_obj.ndim == 2:
+            if is_frame:
                 result_kwargs["columns"] = self._selected_obj.columns
             else:
                 result_kwargs["name"] = self._selected_obj.name
-            obj = self._selected_obj.astype(np.float64).to_numpy()
+            np_array = self._selected_obj.astype(np.float64).to_numpy()
         if update_times is None:
             update_times = np.ones(
                 max(self._selected_obj.shape[self.axis - 1] - 1, 0), dtype=np.float64
             )
         else:
             update_times = _calculate_deltas(update_times, self.halflife)
         ewma_func = generate_online_numba_ewma_func(self.engine_kwargs)
-        result = self._mean.run_ewm(obj, update_times, self.min_periods, ewma_func)
+        result = self._mean.run_ewm(
+            np_array if is_frame else np_array[:, np.newaxis],
+            update_times,
+            self.min_periods,
+            ewma_func,
+        )
+        if not is_frame:
+            result = result.squeeze()
         result = result[result_from:]
         result = self._selected_obj._constructor(result, **result_kwargs)
         return result

pandas/tests/window/test_online.py

@@ -39,37 +39,51 @@ def test_online_vs_non_online_mean(
         # Test resetting once
         for _ in range(2):
             result = online_ewm.mean()
-            tm.assert_frame_equal(result, expected.head(2))
+            tm.assert_equal(result, expected.head(2))
 
             result = online_ewm.mean(update=obj.tail(3))
-            tm.assert_frame_equal(result, expected.tail(3))
+            tm.assert_equal(result, expected.tail(3))
 
             online_ewm.reset()
 
     @pytest.mark.parametrize(
         "obj", [DataFrame({"a": range(5), "b": range(5)}), Series(range(5), name="foo")]
     )
-    def test_update_times_mean(self, obj, nogil, parallel, nopython, adjust, ignore_na):
+    def test_update_times_mean(
+        self, obj, nogil, parallel, nopython, adjust, ignore_na, halflife_with_times
+    ):
         times = Series(
             np.array(
                 ["2020-01-01", "2020-01-02", "2020-01-04", "2020-01-17", "2020-01-21"],
                 dtype="datetime64",
             )
         )
-        expected = obj.ewm(0.5, adjust=adjust, ignore_na=ignore_na, times=times).mean()
+        expected = obj.ewm(
+            0.5,
+            adjust=adjust,
+            ignore_na=ignore_na,
+            times=times,
+            halflife=halflife_with_times,
+        ).mean()
 
         engine_kwargs = {"nogil": nogil, "parallel": parallel, "nopython": nopython}
         online_ewm = (
             obj.head(2)
-            .ewm(0.5, adjust=adjust, ignore_na=ignore_na, times=times.head(2))
+            .ewm(
+                0.5,
+                adjust=adjust,
+                ignore_na=ignore_na,
+                times=times.head(2),
+                halflife=halflife_with_times,
+            )
             .online(engine_kwargs=engine_kwargs)
         )
         # Test resetting once
         for _ in range(2):
             result = online_ewm.mean()
-            tm.assert_frame_equal(result, expected.head(2))
+            tm.assert_equal(result, expected.head(2))
 
             result = online_ewm.mean(update=obj.tail(3), update_times=times.tail(3))
-            tm.assert_frame_equal(result, expected.tail(3))
+            tm.assert_equal(result, expected.tail(3))
 
             online_ewm.reset()