STYLE: Extending codespell to pandas/tests

Author: 01-vyom

.pre-commit-config.yaml

@@ -16,7 +16,6 @@ repos:
     -   id: codespell
         types_or: [python, rst, markdown]
         files: ^(pandas|doc)/
-        exclude: ^pandas/tests/
 -   repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v3.4.0
     hooks:

pandas/tests/arithmetic/test_timedelta64.py

@@ -1158,7 +1158,7 @@ def test_td64arr_add_sub_int(self, box_with_array, one):
         msg = "Addition/subtraction of integers"
         assert_invalid_addsub_type(tdarr, one, msg)
 
-        # TOOD: get inplace ops into assert_invalid_addsub_type
+        # TODO: get inplace ops into assert_invalid_addsub_type
         with pytest.raises(TypeError, match=msg):
             tdarr += one
         with pytest.raises(TypeError, match=msg):

pandas/tests/arrays/categorical/test_missing.py

@@ -107,13 +107,13 @@ def test_fillna_array(self):
         other = cat.fillna("C")
         result = cat.fillna(other)
         tm.assert_categorical_equal(result, other)
-        assert isna(cat[-1])  # didnt modify original inplace
+        assert isna(cat[-1])  # didn't modify original inplace
 
         other = np.array(["A", "B", "C", "B", "A"])
         result = cat.fillna(other)
         expected = Categorical(["A", "B", "C", "B", "A"], dtype=cat.dtype)
         tm.assert_categorical_equal(result, expected)
-        assert isna(cat[-1])  # didnt modify original inplace
+        assert isna(cat[-1])  # didn't modify original inplace
 
     @pytest.mark.parametrize(
         "values, expected",

pandas/tests/arrays/sparse/test_array.py

@@ -95,7 +95,7 @@ def test_constructor_na_dtype(self, dtype):
             SparseArray([0, 1, np.nan], dtype=dtype)
 
     def test_constructor_warns_when_losing_timezone(self):
-        # GH#32501 warn when losing timezone inforamtion
+        # GH#32501 warn when losing timezone information
         dti = pd.date_range("2016-01-01", periods=3, tz="US/Pacific")
 
         expected = SparseArray(np.asarray(dti, dtype="datetime64[ns]"))

pandas/tests/computation/test_eval.py

@@ -1144,11 +1144,11 @@ def test_performance_warning_for_poor_alignment(self, engine, parser):
             if not is_python_engine:
                 assert len(w) == 1
                 msg = str(w[0].message)
-                loged = np.log10(s.size - df.shape[1])
+                logged = np.log10(s.size - df.shape[1])
                 expected = (
                     f"Alignment difference on axis 1 is larger "
                     f"than an order of magnitude on term 'df', "
-                    f"by more than {loged:.4g}; performance may suffer"
+                    f"by more than {logged:.4g}; performance may suffer"
                 )
                 assert msg == expected
 
@@ -1404,25 +1404,25 @@ def test_multi_line_expression(self):
 
         expected["c"] = expected["a"] + expected["b"]
         expected["d"] = expected["c"] + expected["b"]
-        ans = df.eval(
+        answer = df.eval(
             """
         c = a + b
         d = c + b""",
             inplace=True,
         )
         tm.assert_frame_equal(expected, df)
-        assert ans is None
+        assert answer is None
 
         expected["a"] = expected["a"] - 1
         expected["e"] = expected["a"] + 2
-        ans = df.eval(
+        answer = df.eval(
             """
         a = a - 1
         e = a + 2""",
             inplace=True,
         )
         tm.assert_frame_equal(expected, df)
-        assert ans is None
+        assert answer is None
 
         # multi-line not valid if not all assignments
         msg = "Multi-line expressions are only valid if all expressions contain"
@@ -1467,15 +1467,15 @@ def test_multi_line_expression_local_variable(self):
         local_var = 7
         expected["c"] = expected["a"] * local_var
         expected["d"] = expected["c"] + local_var
-        ans = df.eval(
+        answer = df.eval(
             """
         c = a * @local_var
         d = c + @local_var
         """,
             inplace=True,
         )
         tm.assert_frame_equal(expected, df)
-        assert ans is None
+        assert answer is None
 
     def test_multi_line_expression_callable_local_variable(self):
         # 26426
@@ -1487,15 +1487,15 @@ def local_func(a, b):
         expected = df.copy()
         expected["c"] = expected["a"] * local_func(1, 7)
         expected["d"] = expected["c"] + local_func(1, 7)
-        ans = df.eval(
+        answer = df.eval(
             """
         c = a * @local_func(1, 7)
         d = c + @local_func(1, 7)
         """,
             inplace=True,
         )
         tm.assert_frame_equal(expected, df)
-        assert ans is None
+        assert answer is None
 
     def test_multi_line_expression_callable_local_variable_with_kwargs(self):
         # 26426
@@ -1507,15 +1507,15 @@ def local_func(a, b):
         expected = df.copy()
         expected["c"] = expected["a"] * local_func(b=7, a=1)
         expected["d"] = expected["c"] + local_func(b=7, a=1)
-        ans = df.eval(
+        answer = df.eval(
             """
         c = a * @local_func(b=7, a=1)
         d = c + @local_func(b=7, a=1)
         """,
             inplace=True,
         )
         tm.assert_frame_equal(expected, df)
-        assert ans is None
+        assert answer is None
 
     def test_assignment_in_query(self):
         # GH 8664

pandas/tests/config/test_config.py

@@ -112,8 +112,8 @@ def test_describe_option(self):
 
         # if no doc is specified we get a default message
         # saying "description not available"
-        assert "vailable" in self.cf.describe_option("f", _print_desc=False)
-        assert "vailable" in self.cf.describe_option("g.h", _print_desc=False)
+        assert "available" in self.cf.describe_option("f", _print_desc=False)
+        assert "available" in self.cf.describe_option("g.h", _print_desc=False)
         assert "precated" in self.cf.describe_option("g.h", _print_desc=False)
         assert "k" in self.cf.describe_option("g.h", _print_desc=False)
 

pandas/tests/dtypes/cast/test_promote.py

@@ -103,7 +103,7 @@ def _assert_match(result_fill_value, expected_fill_value):
 
     if hasattr(result_fill_value, "dtype"):
         # Compare types in a way that is robust to platform-specific
-        #  idiosyncracies where e.g. sometimes we get "ulonglong" as an alias
+        #  idiosyncrasies where e.g. sometimes we get "ulonglong" as an alias
         #  for "uint64" or "intc" as an alias for "int32"
         assert result_fill_value.dtype.kind == expected_fill_value.dtype.kind
         assert result_fill_value.dtype.itemsize == expected_fill_value.dtype.itemsize

pandas/tests/dtypes/test_missing.py

@@ -553,7 +553,7 @@ def test_array_equivalent_nested():
 )
 def test_na_value_for_dtype(dtype, na_value):
     result = na_value_for_dtype(dtype)
-    # identify check doesnt work for datetime64/timedelta64("NaT") bc they
+    # identify check doesn't work for datetime64/timedelta64("NaT") bc they
     #  are not singletons
     assert result is na_value or (
         isna(result) and isna(na_value) and type(result) is type(na_value)

pandas/tests/extension/base/dim2.py

@@ -238,7 +238,7 @@ def test_reductions_2d_axis1(self, data, method, request):
             else:
                 raise AssertionError("Both reductions should raise or neither")
 
-        # not necesarrily type/dtype-preserving, so weaker assertions
+        # not necessarily type/dtype-preserving, so weaker assertions
         assert result.shape == (1,)
         expected_scalar = getattr(data, method)()
         if pd.isna(result[0]):

pandas/tests/extension/base/methods.py

@@ -90,7 +90,7 @@ def test_argmin_argmax(self, data_for_sorting, data_missing_for_sorting, na_valu
         assert data_for_sorting.argmax() == 1
         assert data_for_sorting.argmin() == 2
 
-        # with repeated values -> first occurence
+        # with repeated values -> first occurrence
         data = data_for_sorting.take([2, 0, 0, 1, 1, 2])
         assert data.argmax() == 3
         assert data.argmin() == 0
@@ -109,7 +109,7 @@ def test_argmin_argmax_empty_array(self, method, data):
 
     @pytest.mark.parametrize("method", ["argmax", "argmin"])
     def test_argmin_argmax_all_na(self, method, data, na_value):
-        # all missing with skipna=True is the same as emtpy
+        # all missing with skipna=True is the same as empty
         err_msg = "attempt to get"
         data_na = type(data)._from_sequence([na_value, na_value], dtype=data.dtype)
         with pytest.raises(ValueError, match=err_msg):
@@ -530,7 +530,7 @@ def test_equals(self, data, na_value, as_series, box):
         # different length
         assert data[:2].equals(data[:3]) is False
 
-        # emtpy are equal
+        # empty are equal
         assert data[:0].equals(data[:0]) is True
 
         # other types

pandas/tests/extension/test_boolean.py

@@ -234,7 +234,7 @@ def test_argmin_argmax(self, data_for_sorting, data_missing_for_sorting):
         assert data_for_sorting.argmax() == 0
         assert data_for_sorting.argmin() == 2
 
-        # with repeated values -> first occurence
+        # with repeated values -> first occurrence
         data = data_for_sorting.take([2, 0, 0, 1, 1, 2])
         assert data.argmax() == 1
         assert data.argmin() == 0

pandas/tests/frame/indexing/test_indexing.py

@@ -439,8 +439,8 @@ def test_setitem_corner(self, float_frame):
         dm["foo"] = "bar"
         assert dm["foo"].dtype == np.object_
 
-        dm["coercable"] = ["1", "2", "3"]
-        assert dm["coercable"].dtype == np.object_
+        dm["coercible"] = ["1", "2", "3"]
+        assert dm["coercible"].dtype == np.object_
 
     def test_setitem_corner2(self):
         data = {

pandas/tests/frame/indexing/test_setitem.py

@@ -420,7 +420,7 @@ def test_setitem_intervals(self):
         assert isinstance(ser.cat.categories, IntervalIndex)
 
         # B & D end up as Categoricals
-        # the remainer are converted to in-line objects
+        # the remainder are converted to in-line objects
         # containing an IntervalIndex.values
         df["B"] = ser
         df["C"] = np.array(ser)
@@ -433,13 +433,13 @@ def test_setitem_intervals(self):
         assert is_categorical_dtype(df["D"].dtype)
         assert is_interval_dtype(df["D"].cat.categories)
 
-        # Thes goes through the Series constructor and so get inferred back
+        # These goes through the Series constructor and so get inferred back
         #  to IntervalDtype
         assert is_interval_dtype(df["C"])
         assert is_interval_dtype(df["E"])
 
         # But the Series constructor doesn't do inference on Series objects,
-        #  so setting df["F"] doesnt get cast back to IntervalDtype
+        #  so setting df["F"] doesn't get cast back to IntervalDtype
         assert is_object_dtype(df["F"])
 
         # they compare equal as Index

pandas/tests/frame/methods/test_cov_corr.py

@@ -207,7 +207,7 @@ def test_corr_item_cache(self, using_array_manager):
 
         _ = df.corr()
 
-        # Check that the corr didnt break link between ser and df
+        # Check that the corr didn't break link between ser and df
         ser.values[0] = 99
         assert df.loc[0, "A"] == 99
         assert df["A"] is ser

pandas/tests/frame/methods/test_quantile.py

@@ -550,11 +550,11 @@ class TestQuantileExtensionDtype:
             pd.date_range("2016-01-01", periods=9, tz="US/Pacific"),
             pytest.param(
                 pd.array(np.arange(9), dtype="Int64"),
-                marks=pytest.mark.xfail(reason="doesnt implement from_factorized"),
+                marks=pytest.mark.xfail(reason="doesn't implement from_factorized"),
             ),
             pytest.param(
                 pd.array(np.arange(9), dtype="Float64"),
-                marks=pytest.mark.xfail(reason="doesnt implement from_factorized"),
+                marks=pytest.mark.xfail(reason="doesn't implement from_factorized"),
             ),
         ],
         ids=lambda x: str(x.dtype),

pandas/tests/frame/methods/test_replace.py

@@ -1439,8 +1439,8 @@ def test_categorical_replace_with_dict(self, replace_dict, final_data):
 
         a = pd.Categorical(final_data[:, 0], categories=[3, 2])
 
-        excat = [3, 2] if replace_dict["b"] == 1 else [1, 3]
-        b = pd.Categorical(final_data[:, 1], categories=excat)
+        ex_cat = [3, 2] if replace_dict["b"] == 1 else [1, 3]
+        b = pd.Categorical(final_data[:, 1], categories=ex_cat)
 
         expected = DataFrame({"a": a, "b": b})
         result = df.replace(replace_dict, 3)

pandas/tests/frame/methods/test_reset_index.py

@@ -137,8 +137,8 @@ def test_reset_index(self, float_frame):
 
         # preserve column names
         float_frame.columns.name = "columns"
-        resetted = float_frame.reset_index()
-        assert resetted.columns.name == "columns"
+        reset = float_frame.reset_index()
+        assert reset.columns.name == "columns"
 
         # only remove certain columns
         df = float_frame.reset_index().set_index(["index", "A", "B"])
@@ -159,10 +159,10 @@ def test_reset_index(self, float_frame):
 
         # test resetting in place
         df = float_frame.copy()
-        resetted = float_frame.reset_index()
+        reset = float_frame.reset_index()
         return_value = df.reset_index(inplace=True)
         assert return_value is None
-        tm.assert_frame_equal(df, resetted, check_names=False)
+        tm.assert_frame_equal(df, reset, check_names=False)
 
         df = float_frame.reset_index().set_index(["index", "A", "B"])
         rs = df.reset_index("A", drop=True)
@@ -224,11 +224,11 @@ def test_reset_index_right_dtype(self):
         )
         df = DataFrame(s1)
 
-        resetted = s1.reset_index()
-        assert resetted["time"].dtype == np.float64
+        reset = s1.reset_index()
+        assert reset["time"].dtype == np.float64
 
-        resetted = df.reset_index()
-        assert resetted["time"].dtype == np.float64
+        reset = df.reset_index()
+        assert reset["time"].dtype == np.float64
 
     def test_reset_index_multiindex_col(self):
         vals = np.random.randn(3, 3).astype(object)

pandas/tests/frame/methods/test_to_dict_of_blocks.py

@@ -53,7 +53,7 @@ def test_to_dict_of_blocks_item_cache():
 
     df._to_dict_of_blocks()
 
-    # Check that the to_dict_of_blocks didnt break link between ser and df
+    # Check that the to_dict_of_blocks didn't break link between ser and df
     ser.values[0] = "foo"
     assert df.loc[0, "b"] == "foo"
 

pandas/tests/frame/methods/test_values.py

@@ -91,7 +91,7 @@ def test_frame_values_with_tz(self):
         )
         tm.assert_numpy_array_equal(result, expected)
 
-        # two columns, homogenous
+        # two columns, homogeneous
 
         df["B"] = df["A"]
         result = df.values

pandas/tests/frame/test_block_internals.py

@@ -388,7 +388,7 @@ def test_update_inplace_sets_valid_block_values():
     # inplace update of a single column
     df["a"].fillna(1, inplace=True)
 
-    # check we havent put a Series into any block.values
+    # check we haven't put a Series into any block.values
     assert isinstance(df._mgr.blocks[0].values, Categorical)
 
     # smoketest for OP bug from GH#35731

pandas/tests/frame/test_constructors.py

@@ -1195,7 +1195,7 @@ def test_constructor_unequal_length_nested_list_column(self):
 
     def test_constructor_sequence_like(self):
         # GH 3783
-        # collections.Squence like
+        # collections.Sequence like
 
         class DummyContainer(abc.Sequence):
             def __init__(self, lst):
@@ -1426,9 +1426,9 @@ def test_constructor_list_of_dataclasses(self):
 
         Point = make_dataclass("Point", [("x", int), ("y", int)])
 
-        datas = [Point(0, 3), Point(1, 3)]
+        data = [Point(0, 3), Point(1, 3)]
         expected = DataFrame({"x": [0, 1], "y": [3, 3]})
-        result = DataFrame(datas)
+        result = DataFrame(data)
         tm.assert_frame_equal(result, expected)
 
     def test_constructor_list_of_dataclasses_with_varying_types(self):
@@ -1439,12 +1439,12 @@ def test_constructor_list_of_dataclasses_with_varying_types(self):
         Point = make_dataclass("Point", [("x", int), ("y", int)])
         HLine = make_dataclass("HLine", [("x0", int), ("x1", int), ("y", int)])
 
-        datas = [Point(0, 3), HLine(1, 3, 3)]
+        data = [Point(0, 3), HLine(1, 3, 3)]
 
         expected = DataFrame(
             {"x": [0, np.nan], "y": [3, 3], "x0": [np.nan, 1], "x1": [np.nan, 3]}
         )
-        result = DataFrame(datas)
+        result = DataFrame(data)
         tm.assert_frame_equal(result, expected)
 
     def test_constructor_list_of_dataclasses_error_thrown(self):
@@ -1912,7 +1912,7 @@ def test_constructor_for_list_with_dtypes(self):
         expected = Series([np.dtype("int64")] * 5)
         tm.assert_series_equal(result, expected)
 
-        # overflow issue? (we always expecte int64 upcasting here)
+        # overflow issue? (we always expected int64 upcasting here)
         df = DataFrame({"a": [2 ** 31, 2 ** 31 + 1]})
         assert df.dtypes.iloc[0] == np.dtype("int64")