Fix-up black formatting: fix noqa comments + type annotations

Author: jorisvandenbossche

Diff for: pandas/api/extensions/__init__.py

@@ -5,10 +5,9 @@
 )
 
 from pandas.core.accessor import (  # noqa: F401
+    register_dataframe_accessor,
     register_index_accessor,
     register_series_accessor,
 )
 from pandas.core.algorithms import take  # noqa: F401
 from pandas.core.arrays import ExtensionArray, ExtensionScalarOpsMixin  # noqa: F401
-
-from pandas.core.accessor import register_dataframe_accessor  # noqa: F401; noqa: F401

Diff for: pandas/compat/numpy/function.py

@@ -108,8 +108,7 @@ def validate_argmax_with_skipna(skipna, args, kwargs):
     return skipna
 
 
-ARGSORT_DEFAULTS = OrderedDict()
-# type: OrderedDict[str, Optional[Union[int, str]]]
+ARGSORT_DEFAULTS = OrderedDict()  # type: OrderedDict[str, Optional[Union[int, str]]]
 ARGSORT_DEFAULTS["axis"] = -1
 ARGSORT_DEFAULTS["kind"] = "quicksort"
 ARGSORT_DEFAULTS["order"] = None
@@ -125,8 +124,7 @@ def validate_argmax_with_skipna(skipna, args, kwargs):
 
 # two different signatures of argsort, this second validation
 # for when the `kind` param is supported
-ARGSORT_DEFAULTS_KIND = OrderedDict()
-# type: OrderedDict[str, Optional[int]]
+ARGSORT_DEFAULTS_KIND = OrderedDict()  # type: OrderedDict[str, Optional[int]]
 ARGSORT_DEFAULTS_KIND["axis"] = -1
 ARGSORT_DEFAULTS_KIND["order"] = None
 validate_argsort_kind = CompatValidator(
@@ -243,8 +241,7 @@ def validate_cum_func_with_skipna(skipna, args, kwargs, name):
     ROUND_DEFAULTS, fname="round", method="both", max_fname_arg_count=1
 )
 
-SORT_DEFAULTS = OrderedDict()
-# type: OrderedDict[str, Optional[Union[int, str]]]
+SORT_DEFAULTS = OrderedDict()  # type: OrderedDict[str, Optional[Union[int, str]]]
 SORT_DEFAULTS["axis"] = -1
 SORT_DEFAULTS["kind"] = "quicksort"
 SORT_DEFAULTS["order"] = None
@@ -278,8 +275,7 @@ def validate_cum_func_with_skipna(skipna, args, kwargs, name):
     MEDIAN_DEFAULTS, fname="median", method="both", max_fname_arg_count=1
 )
 
-STAT_DDOF_FUNC_DEFAULTS = OrderedDict()
-# type: OrderedDict[str, Optional[bool]]
+STAT_DDOF_FUNC_DEFAULTS = OrderedDict()  # type: OrderedDict[str, Optional[bool]]
 STAT_DDOF_FUNC_DEFAULTS["dtype"] = None
 STAT_DDOF_FUNC_DEFAULTS["out"] = None
 STAT_DDOF_FUNC_DEFAULTS["keepdims"] = False

Diff for: pandas/core/indexes/datetimelike.py

@@ -73,14 +73,14 @@ class DatetimeIndexOpsMixin(ExtensionOpsMixin):
     # properties there.  They can be made into cache_readonly for Index
     # subclasses bc they are immutable
     inferred_freq = cache_readonly(
-        DatetimeLikeArrayMixin.inferred_freq.fget
-    )  # type: ignore
+        DatetimeLikeArrayMixin.inferred_freq.fget  # type: ignore
+    )
     _isnan = cache_readonly(DatetimeLikeArrayMixin._isnan.fget)  # type: ignore
     hasnans = cache_readonly(DatetimeLikeArrayMixin._hasnans.fget)  # type: ignore
     _hasnans = hasnans  # for index / array -agnostic code
     _resolution = cache_readonly(
-        DatetimeLikeArrayMixin._resolution.fget
-    )  # type: ignore
+        DatetimeLikeArrayMixin._resolution.fget  # type: ignore
+    )
     resolution = cache_readonly(DatetimeLikeArrayMixin.resolution.fget)  # type: ignore
 
     _maybe_mask_results = ea_passthrough(DatetimeLikeArrayMixin._maybe_mask_results)

Diff for: pandas/tests/arrays/categorical/test_constructors.py

@@ -224,8 +224,8 @@ def test_constructor(self):
 
         # this is a legitimate constructor
         with tm.assert_produces_warning(None):
-            c = Categorical(
-                np.array([], dtype="int64"), categories=[3, 2, 1], ordered=True  # noqa
+            c = Categorical(  # noqa
+                np.array([], dtype="int64"), categories=[3, 2, 1], ordered=True
             )
 
     def test_constructor_with_existing_categories(self):

Diff for: pandas/tests/arrays/sparse/test_array.py

@@ -689,13 +689,13 @@ def test_getslice_tuple(self):
         dense = np.array([np.nan, 0, 3, 4, 0, 5, np.nan, np.nan, 0])
 
         sparse = SparseArray(dense)
-        res = sparse[4:,]
-        exp = SparseArray(dense[4:,])
+        res = sparse[4:,]  # noqa: E231
+        exp = SparseArray(dense[4:,])  # noqa: E231
         tm.assert_sp_array_equal(res, exp)
 
         sparse = SparseArray(dense, fill_value=0)
-        res = sparse[4:,]
-        exp = SparseArray(dense[4:,], fill_value=0)
+        res = sparse[4:,]  # noqa: E231
+        exp = SparseArray(dense[4:,], fill_value=0)  # noqa: E231
         tm.assert_sp_array_equal(res, exp)
 
         with pytest.raises(IndexError):

Diff for: pandas/tests/frame/test_alter_axes.py

@@ -238,9 +238,8 @@ def test_set_index_pass_arrays_duplicate(
         # cannot drop the same column twice;
         # use "is" because == would give ambiguous Boolean error for containers
         first_drop = (
-            False if (keys[0] is "A" and keys[1] is "A") else drop
-        )  # noqa: F632
-
+            False if (keys[0] is "A" and keys[1] is "A") else drop  # noqa: F632
+        )
         # to test against already-tested behaviour, we add sequentially,
         # hence second append always True; must wrap keys in list, otherwise
         # box = list would be interpreted as keys

Diff for: pandas/tests/frame/test_analytics.py

@@ -2135,8 +2135,8 @@ def test_round(self):
         nan_round_Series = Series({"col1": np.nan, "col2": 1})
 
         # TODO(wesm): unused?
-        expected_nan_round = DataFrame(
-            {"col1": [1.123, 2.123, 3.123], "col2": [1.2, 2.2, 3.2]}  # noqa
+        expected_nan_round = DataFrame(  # noqa
+            {"col1": [1.123, 2.123, 3.123], "col2": [1.2, 2.2, 3.2]}
         )
 
         with pytest.raises(TypeError):

Diff for: pandas/tests/frame/test_query_eval.py

@@ -102,8 +102,8 @@ def test_ops(self):
                 ("/", "__truediv__", "__rtruediv__"),
             ]:
 
-                base = DataFrame(
-                    np.tile(m.values, n).reshape(n, -1), columns=list("abcd")  # noqa
+                base = DataFrame(  # noqa
+                    np.tile(m.values, n).reshape(n, -1), columns=list("abcd")
                 )
 
                 expected = eval("base{op}df".format(op=op_str))

Diff for: pandas/tests/indexing/test_callable.py

@@ -17,11 +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,]
-        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,]
-        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.B == "b", :]
         tm.assert_frame_equal(res, df.loc[df.B == "b", :])
@@ -90,8 +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"],]
-        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"], :]
         tm.assert_frame_equal(res, df.loc[["A", "C"], :])

Diff for: pandas/tests/test_strings.py

@@ -1839,13 +1839,13 @@ def test_ismethods(self):
         digit_e = [False, False, False, True, False, False, False, True, False, False]
 
         # TODO: unused
-        num_e = [
+        num_e = [  # noqa
             False,
             False,
             False,
             True,
             False,
-            False,  # noqa
+            False,
             False,
             True,
             False,