Comma cleanup (#36082)

Author: JonathanShrek

pandas/tests/indexes/datetimes/test_datetime.py

@@ -51,7 +51,7 @@ def test_reindex_with_same_tz(self):
             "2010-01-02 00:00:00",
         ]
         expected1 = DatetimeIndex(
-            expected_list1, dtype="datetime64[ns, UTC]", freq=None,
+            expected_list1, dtype="datetime64[ns, UTC]", freq=None
         )
         expected2 = np.array([0] + [-1] * 21 + [23], dtype=np.dtype("intp"))
         tm.assert_index_equal(result1, expected1)

pandas/tests/indexes/datetimes/test_timezones.py

@@ -799,7 +799,7 @@ def test_dti_from_tzaware_datetime(self, tz):
 
     @pytest.mark.parametrize("tzstr", ["US/Eastern", "dateutil/US/Eastern"])
     def test_dti_tz_constructors(self, tzstr):
-        """ Test different DatetimeIndex constructions with timezone
+        """Test different DatetimeIndex constructions with timezone
         Follow-up of GH#4229
         """
         arr = ["11/10/2005 08:00:00", "11/10/2005 09:00:00"]

pandas/tests/indexes/multi/test_constructors.py

@@ -741,18 +741,18 @@ def test_raise_invalid_sortorder():
 
     with pytest.raises(ValueError, match=r".* sortorder 2 with lexsort_depth 1.*"):
         MultiIndex(
-            levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 2, 1]], sortorder=2,
+            levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 2, 1]], sortorder=2
         )
 
     with pytest.raises(ValueError, match=r".* sortorder 1 with lexsort_depth 0.*"):
         MultiIndex(
-            levels=levels, codes=[[0, 0, 1, 0, 1, 1], [0, 1, 0, 2, 2, 1]], sortorder=1,
+            levels=levels, codes=[[0, 0, 1, 0, 1, 1], [0, 1, 0, 2, 2, 1]], sortorder=1
         )
 
 
 def test_datetimeindex():
     idx1 = pd.DatetimeIndex(
-        ["2013-04-01 9:00", "2013-04-02 9:00", "2013-04-03 9:00"] * 2, tz="Asia/Tokyo",
+        ["2013-04-01 9:00", "2013-04-02 9:00", "2013-04-03 9:00"] * 2, tz="Asia/Tokyo"
     )
     idx2 = pd.date_range("2010/01/01", periods=6, freq="M", tz="US/Eastern")
     idx = MultiIndex.from_arrays([idx1, idx2])

pandas/tests/indexes/multi/test_isin.py

@@ -78,7 +78,7 @@ def test_isin_level_kwarg():
 @pytest.mark.parametrize(
     "labels,expected,level",
     [
-        ([("b", np.nan)], np.array([False, False, True]), None,),
+        ([("b", np.nan)], np.array([False, False, True]), None),
         ([np.nan, "a"], np.array([True, True, False]), 0),
         (["d", np.nan], np.array([False, True, True]), 1),
     ],

pandas/tests/indexes/test_base.py

@@ -2426,7 +2426,7 @@ def test_index_with_tuple_bool(self):
         # TODO: remove tupleize_cols=False once correct behaviour is restored
         # TODO: also this op right now produces FutureWarning from numpy
         idx = Index([("a", "b"), ("b", "c"), ("c", "a")], tupleize_cols=False)
-        result = idx == ("c", "a",)
+        result = idx == ("c", "a")
         expected = np.array([False, False, True])
         tm.assert_numpy_array_equal(result, expected)
 

pandas/tests/indexes/timedeltas/test_scalar_compat.py

@@ -104,18 +104,18 @@ def test_round(self):
                 "L",
                 t1a,
                 TimedeltaIndex(
-                    ["-1 days +00:00:00", "-2 days +23:58:58", "-2 days +23:57:56"],
+                    ["-1 days +00:00:00", "-2 days +23:58:58", "-2 days +23:57:56"]
                 ),
             ),
             (
                 "S",
                 t1a,
                 TimedeltaIndex(
-                    ["-1 days +00:00:00", "-2 days +23:58:58", "-2 days +23:57:56"],
+                    ["-1 days +00:00:00", "-2 days +23:58:58", "-2 days +23:57:56"]
                 ),
             ),
-            ("12T", t1c, TimedeltaIndex(["-1 days", "-1 days", "-1 days"],),),
-            ("H", t1c, TimedeltaIndex(["-1 days", "-1 days", "-1 days"],),),
+            ("12T", t1c, TimedeltaIndex(["-1 days", "-1 days", "-1 days"])),
+            ("H", t1c, TimedeltaIndex(["-1 days", "-1 days", "-1 days"])),
             ("d", t1c, TimedeltaIndex([-1, -1, -1], unit="D")),
         ]:
 

pandas/tests/indexes/timedeltas/test_searchsorted.py

@@ -17,7 +17,7 @@ def test_searchsorted_different_argument_classes(self, klass):
         tm.assert_numpy_array_equal(result, expected)
 
     @pytest.mark.parametrize(
-        "arg", [[1, 2], ["a", "b"], [Timestamp("2020-01-01", tz="Europe/London")] * 2],
+        "arg", [[1, 2], ["a", "b"], [Timestamp("2020-01-01", tz="Europe/London")] * 2]
     )
     def test_searchsorted_invalid_argument_dtype(self, arg):
         idx = TimedeltaIndex(["1 day", "2 days", "3 days"])

pandas/tests/indexing/common.py

@@ -144,9 +144,7 @@ def check_values(self, f, func, values=False):
 
             tm.assert_almost_equal(result, expected)
 
-    def check_result(
-        self, method, key, typs=None, axes=None, fails=None,
-    ):
+    def check_result(self, method, key, typs=None, axes=None, fails=None):
         def _eq(axis, obj, key):
             """ compare equal for these 2 keys """
             axified = _axify(obj, key, axis)

pandas/tests/indexing/test_callable.py

@@ -17,15 +17,11 @@ def test_frame_loc_callable(self):
         res = df.loc[lambda x: x.A > 2]
         tm.assert_frame_equal(res, df.loc[df.A > 2])
 
-        res = df.loc[
-            lambda x: x.A > 2,
-        ]  # noqa: E231
-        tm.assert_frame_equal(res, df.loc[df.A > 2,])  # noqa: E231
+        res = df.loc[lambda x: x.A > 2]  # noqa: E231
+        tm.assert_frame_equal(res, df.loc[df.A > 2])  # noqa: E231
 
-        res = df.loc[
-            lambda x: x.A > 2,
-        ]  # noqa: E231
-        tm.assert_frame_equal(res, df.loc[df.A > 2,])  # noqa: E231
+        res = df.loc[lambda x: x.A > 2]  # noqa: E231
+        tm.assert_frame_equal(res, df.loc[df.A > 2])  # noqa: E231
 
         res = df.loc[lambda x: x.B == "b", :]
         tm.assert_frame_equal(res, df.loc[df.B == "b", :])
@@ -94,10 +90,8 @@ def test_frame_loc_callable_labels(self):
         res = df.loc[lambda x: ["A", "C"]]
         tm.assert_frame_equal(res, df.loc[["A", "C"]])
 
-        res = df.loc[
-            lambda x: ["A", "C"],
-        ]  # noqa: E231
-        tm.assert_frame_equal(res, df.loc[["A", "C"],])  # noqa: E231
+        res = df.loc[lambda x: ["A", "C"]]  # noqa: E231
+        tm.assert_frame_equal(res, df.loc[["A", "C"]])  # noqa: E231
 
         res = df.loc[lambda x: ["A", "C"], :]
         tm.assert_frame_equal(res, df.loc[["A", "C"], :])

pandas/tests/indexing/test_check_indexer.py

@@ -32,7 +32,7 @@ def test_valid_input(indexer, expected):
 
 
 @pytest.mark.parametrize(
-    "indexer", [[True, False, None], pd.array([True, False, None], dtype="boolean")],
+    "indexer", [[True, False, None], pd.array([True, False, None], dtype="boolean")]
 )
 def test_boolean_na_returns_indexer(indexer):
     # https://github.com/pandas-dev/pandas/issues/31503
@@ -61,7 +61,7 @@ def test_bool_raise_length(indexer):
 
 
 @pytest.mark.parametrize(
-    "indexer", [[0, 1, None], pd.array([0, 1, pd.NA], dtype="Int64")],
+    "indexer", [[0, 1, None], pd.array([0, 1, pd.NA], dtype="Int64")]
 )
 def test_int_raise_missing_values(indexer):
     array = np.array([1, 2, 3])
@@ -89,9 +89,7 @@ def test_raise_invalid_array_dtypes(indexer):
         check_array_indexer(array, indexer)
 
 
-@pytest.mark.parametrize(
-    "indexer", [None, Ellipsis, slice(0, 3), (None,)],
-)
+@pytest.mark.parametrize("indexer", [None, Ellipsis, slice(0, 3), (None,)])
 def test_pass_through_non_array_likes(indexer):
     array = np.array([1, 2, 3])
 

pandas/tests/indexing/test_coercion.py

@@ -87,7 +87,7 @@ def _assert_setitem_series_conversion(
         # tm.assert_series_equal(temp, expected_series)
 
     @pytest.mark.parametrize(
-        "val,exp_dtype", [(1, object), (1.1, object), (1 + 1j, object), (True, object)],
+        "val,exp_dtype", [(1, object), (1.1, object), (1 + 1j, object), (True, object)]
     )
     def test_setitem_series_object(self, val, exp_dtype):
         obj = pd.Series(list("abcd"))

pandas/tests/indexing/test_floats.py

@@ -181,9 +181,7 @@ def test_scalar_with_mixed(self):
         expected = 3
         assert result == expected
 
-    @pytest.mark.parametrize(
-        "index_func", [tm.makeIntIndex, tm.makeRangeIndex],
-    )
+    @pytest.mark.parametrize("index_func", [tm.makeIntIndex, tm.makeRangeIndex])
     @pytest.mark.parametrize("klass", [Series, DataFrame])
     def test_scalar_integer(self, index_func, klass):
 
@@ -405,7 +403,7 @@ def test_slice_integer(self):
 
     @pytest.mark.parametrize("l", [slice(2, 4.0), slice(2.0, 4), slice(2.0, 4.0)])
     def test_integer_positional_indexing(self, l):
-        """ make sure that we are raising on positional indexing
+        """make sure that we are raising on positional indexing
         w.r.t. an integer index
         """
         s = Series(range(2, 6), index=range(2, 6))
@@ -425,9 +423,7 @@ def test_integer_positional_indexing(self, l):
         with pytest.raises(TypeError, match=msg):
             s.iloc[l]
 
-    @pytest.mark.parametrize(
-        "index_func", [tm.makeIntIndex, tm.makeRangeIndex],
-    )
+    @pytest.mark.parametrize("index_func", [tm.makeIntIndex, tm.makeRangeIndex])
     def test_slice_integer_frame_getitem(self, index_func):
 
         # similar to above, but on the getitem dim (of a DataFrame)
@@ -486,9 +482,7 @@ def test_slice_integer_frame_getitem(self, index_func):
                 s[l]
 
     @pytest.mark.parametrize("l", [slice(3.0, 4), slice(3, 4.0), slice(3.0, 4.0)])
-    @pytest.mark.parametrize(
-        "index_func", [tm.makeIntIndex, tm.makeRangeIndex],
-    )
+    @pytest.mark.parametrize("index_func", [tm.makeIntIndex, tm.makeRangeIndex])
     def test_float_slice_getitem_with_integer_index_raises(self, l, index_func):
 
         # similar to above, but on the getitem dim (of a DataFrame)