CI: fix flake C413, C414, C416 errors

Author: simonjayhawkins

pandas/core/arrays/categorical.py

@@ -1110,7 +1110,7 @@ def remove_categories(self, removals, inplace=False):
         if not is_list_like(removals):
             removals = [removals]
 
-        removal_set = set(list(removals))
+        removal_set = set(removals)
         not_included = removal_set - set(self.dtype.categories)
         new_categories = [c for c in self.dtype.categories if c not in removal_set]
 

pandas/core/arrays/sparse/scipy_sparse.py

@@ -51,7 +51,7 @@ def _get_label_to_i_dict(labels, sort_labels=False):
             """
             labels = Index(map(tuple, labels)).unique().tolist()  # squish
             if sort_labels:
-                labels = sorted(list(labels))
+                labels = sorted(labels)
             d = OrderedDict((k, i) for i, k in enumerate(labels))
             return d
 

pandas/core/frame.py

@@ -4281,7 +4281,7 @@ def set_index(
         arrays = []
         names = []
         if append:
-            names = [x for x in self.index.names]
+            names = list(self.index.names)
             if isinstance(self.index, ABCMultiIndex):
                 for i in range(self.index.nlevels):
                     arrays.append(self.index._get_level_values(i))
@@ -7268,7 +7268,7 @@ def _series_round(s, decimals):
             if isinstance(decimals, Series):
                 if not decimals.index.is_unique:
                     raise ValueError("Index of decimals must be unique")
-            new_cols = [col for col in _dict_round(self, decimals)]
+            new_cols = list(_dict_round(self, decimals))
         elif is_integer(decimals):
             # Dispatch to Series.round
             new_cols = [_series_round(v, decimals) for _, v in self.items()]

pandas/core/indexes/multi.py

@@ -368,7 +368,7 @@ def _verify_integrity(self, codes=None, levels=None):
             if not level.is_unique:
                 raise ValueError(
                     "Level values must be unique: {values} on "
-                    "level {level}".format(values=[value for value in level], level=i)
+                    "level {level}".format(values=list(level), level=i)
                 )
         if self.sortorder is not None:
             if self.sortorder > self._lexsort_depth():
@@ -1992,8 +1992,8 @@ def levshape(self):
     def __reduce__(self):
         """Necessary for making this object picklable"""
         d = dict(
-            levels=[lev for lev in self.levels],
-            codes=[level_codes for level_codes in self.codes],
+            levels=list(self.levels),
+            codes=list(self.codes),
             sortorder=self.sortorder,
             names=list(self.names),
         )

pandas/core/internals/managers.py

@@ -260,7 +260,7 @@ def get_ftypes(self):
     def __getstate__(self):
         block_values = [b.values for b in self.blocks]
         block_items = [self.items[b.mgr_locs.indexer] for b in self.blocks]
-        axes_array = [ax for ax in self.axes]
+        axes_array = list(self.axes)
 
         extra_state = {
             "0.14.1": {

pandas/core/tools/datetimes.py

@@ -857,7 +857,7 @@ def f(value):
 
     # we require at least Ymd
     required = ["year", "month", "day"]
-    req = sorted(list(set(required) - set(unit_rev.keys())))
+    req = sorted(set(required) - set(unit_rev.keys()))
     if len(req):
         raise ValueError(
             "to assemble mappings requires at least that "
@@ -866,7 +866,7 @@ def f(value):
         )
 
     # keys we don't recognize
-    excess = sorted(list(set(unit_rev.keys()) - set(_unit_map.values())))
+    excess = sorted(set(unit_rev.keys()) - set(_unit_map.values()))
     if len(excess):
         raise ValueError(
             "extra keys have been passed "

pandas/io/parsers.py

@@ -1605,7 +1605,7 @@ def ix(col):
 
         # remove index items from content and columns, don't pop in
         # loop
-        for i in reversed(sorted(to_remove)):
+        for i in sorted(to_remove, reverse=True):
             data.pop(i)
             if not self._implicit_index:
                 columns.pop(i)
@@ -1637,7 +1637,7 @@ def _get_name(icol):
 
         # remove index items from content and columns, don't pop in
         # loop
-        for c in reversed(sorted(to_remove)):
+        for c in sorted(to_remove, reverse=True):
             data.pop(c)
             col_names.remove(c)
 

pandas/io/pytables.py

@@ -1341,7 +1341,7 @@ def info(self) -> str:
             type=type(self), path=pprint_thing(self._path)
         )
         if self.is_open:
-            lkeys = sorted(list(self.keys()))
+            lkeys = sorted(self.keys())
             if len(lkeys):
                 keys = []
                 values = []

pandas/tests/api/test_api.py

@@ -13,7 +13,7 @@ def check(self, namespace, expected, ignored=None):
 
         result = sorted(f for f in dir(namespace) if not f.startswith("__"))
         if ignored is not None:
-            result = sorted(list(set(result) - set(ignored)))
+            result = sorted(set(result) - set(ignored))
 
         expected = sorted(expected)
         tm.assert_almost_equal(result, expected)

pandas/tests/frame/test_alter_axes.py

@@ -381,7 +381,7 @@ def test_set_index_custom_label_hashable_iterable(self):
         class Thing(frozenset):
             # need to stabilize repr for KeyError (due to random order in sets)
             def __repr__(self) -> str:
-                tmp = sorted(list(self))
+                tmp = sorted(self)
                 # double curly brace prints one brace in format string
                 return "frozenset({{{}}})".format(", ".join(map(repr, tmp)))
 
@@ -745,8 +745,7 @@ def test_rename_axis_mapper(self):
         # GH 19978
         mi = MultiIndex.from_product([["a", "b", "c"], [1, 2]], names=["ll", "nn"])
         df = DataFrame(
-            {"x": [i for i in range(len(mi))], "y": [i * 10 for i in range(len(mi))]},
-            index=mi,
+            {"x": list(range(len(mi))), "y": [i * 10 for i in range(len(mi))]}, index=mi
         )
 
         # Test for rename of the Index object of columns

pandas/tests/frame/test_analytics.py

@@ -1244,7 +1244,7 @@ def test_mode_dropna(self, dropna, expected):
             }
         )
 
-        result = df[sorted(list(expected.keys()))].mode(dropna=dropna)
+        result = df[sorted(expected.keys())].mode(dropna=dropna)
         expected = DataFrame(expected)
         tm.assert_frame_equal(result, expected)
 

pandas/tests/frame/test_reshape.py

@@ -699,7 +699,7 @@ def verify(df):
             for i, j in zip(rows, cols):
                 left = sorted(df.iloc[i, j].split("."))
                 right = mk_list(df.index[i]) + mk_list(df.columns[j])
-                right = sorted(list(map(cast, right)))
+                right = sorted(map(cast, right))
                 assert left == right
 
         df = DataFrame(

pandas/tests/groupby/test_function.py

@@ -1300,8 +1300,8 @@ def test_size_groupby_all_null():
         ([np.nan, 4.0, np.nan, 2.0, np.nan], [np.nan, 4.0, np.nan, 2.0, np.nan]),
         # Timestamps
         (
-            [x for x in pd.date_range("1/1/18", freq="D", periods=5)],
-            [x for x in pd.date_range("1/1/18", freq="D", periods=5)][::-1],
+            list(pd.date_range("1/1/18", freq="D", periods=5)),
+            list(pd.date_range("1/1/18", freq="D", periods=5))[::-1],
         ),
         # All NA
         ([np.nan] * 5, [np.nan] * 5),

pandas/tests/indexes/timedeltas/test_setops.py

@@ -39,7 +39,7 @@ def test_union_bug_1730(self):
         rng_b = timedelta_range("1 day", periods=4, freq="4H")
 
         result = rng_a.union(rng_b)
-        exp = TimedeltaIndex(sorted(set(list(rng_a)) | set(list(rng_b))))
+        exp = TimedeltaIndex(sorted(set(rng_a) | set(rng_b)))
         tm.assert_index_equal(result, exp)
 
     def test_union_bug_1745(self):
@@ -50,7 +50,7 @@ def test_union_bug_1745(self):
         )
 
         result = left.union(right)
-        exp = TimedeltaIndex(sorted(set(list(left)) | set(list(right))))
+        exp = TimedeltaIndex(sorted(set(left) | set(right)))
         tm.assert_index_equal(result, exp)
 
     def test_union_bug_4564(self):
@@ -59,7 +59,7 @@ def test_union_bug_4564(self):
         right = left + pd.offsets.Minute(15)
 
         result = left.union(right)
-        exp = TimedeltaIndex(sorted(set(list(left)) | set(list(right))))
+        exp = TimedeltaIndex(sorted(set(left) | set(right)))
         tm.assert_index_equal(result, exp)
 
     def test_intersection_bug_1708(self):

pandas/tests/indexing/multiindex/test_loc.py

@@ -223,16 +223,14 @@ def test_loc_getitem_int_slice(self):
         # GH 3053
         # loc should treat integer slices like label slices
 
-        index = MultiIndex.from_tuples(
-            [t for t in itertools.product([6, 7, 8], ["a", "b"])]
-        )
+        index = MultiIndex.from_tuples(list(itertools.product([6, 7, 8], ["a", "b"])))
         df = DataFrame(np.random.randn(6, 6), index, index)
         result = df.loc[6:8, :]
         expected = df
         tm.assert_frame_equal(result, expected)
 
         index = MultiIndex.from_tuples(
-            [t for t in itertools.product([10, 20, 30], ["a", "b"])]
+            list(itertools.product([10, 20, 30], ["a", "b"]))
         )
         df = DataFrame(np.random.randn(6, 6), index, index)
         result = df.loc[20:30, :]

pandas/tests/indexing/multiindex/test_xs.py

@@ -160,9 +160,7 @@ def test_xs_integer_key():
     # see gh-2107
     dates = range(20111201, 20111205)
     ids = "abcde"
-    index = MultiIndex.from_tuples(
-        [x for x in product(dates, ids)], names=["date", "secid"]
-    )
+    index = MultiIndex.from_tuples(list(product(dates, ids)), names=["date", "secid"])
     df = DataFrame(np.random.randn(len(index), 3), index, ["X", "Y", "Z"])
 
     result = df.xs(20111201, level="date")

pandas/tests/indexing/test_categorical.py

@@ -472,7 +472,7 @@ def test_getitem_with_listlike(self):
             [[1, 0], [0, 1]], dtype="uint8", index=[0, 1], columns=cats
         )
         dummies = pd.get_dummies(cats)
-        result = dummies[[c for c in dummies.columns]]
+        result = dummies[list(dummies.columns)]
         tm.assert_frame_equal(result, expected)
 
     def test_setitem_listlike(self):

pandas/tests/io/formats/test_to_excel.py

@@ -262,7 +262,7 @@ def test_css_to_excel_inherited(css, inherited, expected):
 @pytest.mark.parametrize(
     "input_color,output_color",
     (
-        [(name, rgb) for name, rgb in CSSToExcelConverter.NAMED_COLORS.items()]
+        list(CSSToExcelConverter.NAMED_COLORS.items())
         + [("#" + rgb, rgb) for rgb in CSSToExcelConverter.NAMED_COLORS.values()]
         + [("#F0F", "FF00FF"), ("#ABC", "AABBCC")]
     ),

pandas/tests/io/pytables/test_store.py

@@ -2806,16 +2806,16 @@ def test_select_iterator(self, setup_path):
 
             expected = store.select("df")
 
-            results = [s for s in store.select("df", iterator=True)]
+            results = list(store.select("df", iterator=True))
             result = concat(results)
             tm.assert_frame_equal(expected, result)
 
-            results = [s for s in store.select("df", chunksize=100)]
+            results = list(store.select("df", chunksize=100))
             assert len(results) == 5
             result = concat(results)
             tm.assert_frame_equal(expected, result)
 
-            results = [s for s in store.select("df", chunksize=150)]
+            results = list(store.select("df", chunksize=150))
             result = concat(results)
             tm.assert_frame_equal(result, expected)
 
@@ -2835,7 +2835,7 @@ def test_select_iterator(self, setup_path):
             df = tm.makeTimeDataFrame(500)
             df.to_hdf(path, "df", format="table")
 
-            results = [s for s in read_hdf(path, "df", chunksize=100)]
+            results = list(read_hdf(path, "df", chunksize=100))
             result = concat(results)
 
             assert len(results) == 5
@@ -2856,12 +2856,9 @@ def test_select_iterator(self, setup_path):
 
             # full selection
             expected = store.select_as_multiple(["df1", "df2"], selector="df1")
-            results = [
-                s
-                for s in store.select_as_multiple(
-                    ["df1", "df2"], selector="df1", chunksize=150
-                )
-            ]
+            results = list(
+                store.select_as_multiple(["df1", "df2"], selector="df1", chunksize=150)
+            )
             result = concat(results)
             tm.assert_frame_equal(expected, result)
 
@@ -2916,27 +2913,27 @@ def test_select_iterator_complete_8014(self, setup_path):
             end_dt = expected.index[-1]
 
             # select w/iterator and no where clause works
-            results = [s for s in store.select("df", chunksize=chunksize)]
+            results = list(store.select("df", chunksize=chunksize))
             result = concat(results)
             tm.assert_frame_equal(expected, result)
 
             # select w/iterator and where clause, single term, begin of range
             where = "index >= '{beg_dt}'".format(beg_dt=beg_dt)
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
             result = concat(results)
             tm.assert_frame_equal(expected, result)
 
             # select w/iterator and where clause, single term, end of range
             where = "index <= '{end_dt}'".format(end_dt=end_dt)
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
             result = concat(results)
             tm.assert_frame_equal(expected, result)
 
             # select w/iterator and where clause, inclusive range
             where = "index >= '{beg_dt}' & index <= '{end_dt}'".format(
                 beg_dt=beg_dt, end_dt=end_dt
             )
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
             result = concat(results)
             tm.assert_frame_equal(expected, result)
 
@@ -2958,14 +2955,14 @@ def test_select_iterator_non_complete_8014(self, setup_path):
 
             # select w/iterator and where clause, single term, begin of range
             where = "index >= '{beg_dt}'".format(beg_dt=beg_dt)
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
             result = concat(results)
             rexpected = expected[expected.index >= beg_dt]
             tm.assert_frame_equal(rexpected, result)
 
             # select w/iterator and where clause, single term, end of range
             where = "index <= '{end_dt}'".format(end_dt=end_dt)
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
             result = concat(results)
             rexpected = expected[expected.index <= end_dt]
             tm.assert_frame_equal(rexpected, result)
@@ -2974,7 +2971,7 @@ def test_select_iterator_non_complete_8014(self, setup_path):
             where = "index >= '{beg_dt}' & index <= '{end_dt}'".format(
                 beg_dt=beg_dt, end_dt=end_dt
             )
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
             result = concat(results)
             rexpected = expected[
                 (expected.index >= beg_dt) & (expected.index <= end_dt)
@@ -2992,7 +2989,7 @@ def test_select_iterator_non_complete_8014(self, setup_path):
 
             # select w/iterator and where clause, single term, begin of range
             where = "index > '{end_dt}'".format(end_dt=end_dt)
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
             assert 0 == len(results)
 
     def test_select_iterator_many_empty_frames(self, setup_path):
@@ -3014,14 +3011,14 @@ def test_select_iterator_many_empty_frames(self, setup_path):
 
             # select w/iterator and where clause, single term, begin of range
             where = "index >= '{beg_dt}'".format(beg_dt=beg_dt)
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
             result = concat(results)
             rexpected = expected[expected.index >= beg_dt]
             tm.assert_frame_equal(rexpected, result)
 
             # select w/iterator and where clause, single term, end of range
             where = "index <= '{end_dt}'".format(end_dt=end_dt)
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
 
             assert len(results) == 1
             result = concat(results)
@@ -3032,7 +3029,7 @@ def test_select_iterator_many_empty_frames(self, setup_path):
             where = "index >= '{beg_dt}' & index <= '{end_dt}'".format(
                 beg_dt=beg_dt, end_dt=end_dt
             )
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
 
             # should be 1, is 10
             assert len(results) == 1
@@ -3052,7 +3049,7 @@ def test_select_iterator_many_empty_frames(self, setup_path):
             where = "index <= '{beg_dt}' & index >= '{end_dt}'".format(
                 beg_dt=beg_dt, end_dt=end_dt
             )
-            results = [s for s in store.select("df", where=where, chunksize=chunksize)]
+            results = list(store.select("df", where=where, chunksize=chunksize))
 
             # should be []
             assert len(results) == 0

pandas/tests/io/sas/test_xport.py

@@ -104,7 +104,7 @@ def test1_incremental(self):
 
         reader = read_sas(self.file01, index="SEQN", chunksize=1000)
 
-        all_data = [x for x in reader]
+        all_data = list(reader)
         data = pd.concat(all_data, axis=0)
 
         tm.assert_frame_equal(data, data_csv, check_index_type=False)