Fix black pandas

Author: Mateusz Górski

pandas/core/frame.py

@@ -6564,7 +6564,7 @@ def apply(self, func, axis=0, raw=False, result_type=None, args=(), **kwds):
         """
         from pandas.core.apply import frame_apply
 
-        #Old apply function, which will be used for each part of DataFrame
+        # Old apply function, which will be used for each part of DataFrame
         def partial_apply(dataframe):
             op = frame_apply(
                 dataframe,
@@ -6580,7 +6580,7 @@ def partial_apply(dataframe):
         def get_dtype(dataframe, column):
             return dataframe.dtypes.values[column]
 
-        if axis == 0 or axis == 'index':
+        if axis == 0 or axis == "index":
             if self.shape[1] == 0:
                 return partial_apply(self)
 
@@ -6596,10 +6596,13 @@ def get_dtype(dataframe, column):
                 type = get_dtype(self, i)
                 j = i + 1
 
-                #While the dtype of column is the same as previous ones, they are handled together
-                while j < self.shape[1] and pandas.core.dtypes.common.is_dtype_equal(type, get_dtype(self, j)):
+                # While the dtype of column is the same as previous ones,
+                # they are handled together
+                while j < self.shape[1] and pandas.core.dtypes.common.is_dtype_equal(
+                    type, get_dtype(self, j)
+                ):
                     j += 1
-                frame = self.iloc[:, i: j]
+                frame = self.iloc[:, i:j]
                 i = j
                 result = partial_apply(frame)
 
@@ -6619,7 +6622,6 @@ def get_dtype(dataframe, column):
         else:
             return partial_apply(self)
 
-
     def applymap(self, func):
         """
         Apply a function to a Dataframe elementwise.

pandas/core/groupby/generic.py

@@ -318,7 +318,7 @@ def _aggregate_multiple_funcs(self, arg):
         return DataFrame(results, columns=columns)
 
     def _wrap_series_output(
-        self, output: Mapping[base.OutputKey, Union[Series, np.ndarray]], index: Index,
+        self, output: Mapping[base.OutputKey, Union[Series, np.ndarray]], index: Index
     ) -> Union[Series, DataFrame]:
         """
         Wraps the output of a SeriesGroupBy operation into the expected result.

pandas/core/indexes/base.py

@@ -265,7 +265,7 @@ def _outer_indexer(self, left, right):
     # Constructors
 
     def __new__(
-        cls, data=None, dtype=None, copy=False, name=None, tupleize_cols=True, **kwargs,
+        cls, data=None, dtype=None, copy=False, name=None, tupleize_cols=True, **kwargs
     ) -> "Index":
 
         from .range import RangeIndex

pandas/core/indexes/category.py

@@ -164,13 +164,7 @@ def _engine_type(self):
     # Constructors
 
     def __new__(
-        cls,
-        data=None,
-        categories=None,
-        ordered=None,
-        dtype=None,
-        copy=False,
-        name=None,
+        cls, data=None, categories=None, ordered=None, dtype=None, copy=False, name=None
     ):
 
         dtype = CategoricalDtype._from_values_or_dtype(data, categories, ordered, dtype)

pandas/core/indexes/range.py

@@ -81,7 +81,7 @@ class RangeIndex(Int64Index):
     # Constructors
 
     def __new__(
-        cls, start=None, stop=None, step=None, dtype=None, copy=False, name=None,
+        cls, start=None, stop=None, step=None, dtype=None, copy=False, name=None
     ):
 
         cls._validate_dtype(dtype)

pandas/core/ops/dispatch.py

@@ -95,7 +95,7 @@ def should_series_dispatch(left, right, op):
 
 
 def dispatch_to_extension_op(
-    op, left: Union[ABCExtensionArray, np.ndarray], right: Any,
+    op, left: Union[ABCExtensionArray, np.ndarray], right: Any
 ):
     """
     Assume that left or right is a Series backed by an ExtensionArray,

pandas/core/series.py

@@ -4386,9 +4386,7 @@ def to_period(self, freq=None, copy=True):
     hist = pandas.plotting.hist_series
 
 
-Series._setup_axes(
-    ["index"], docs={"index": "The index (axis labels) of the Series."},
-)
+Series._setup_axes(["index"], docs={"index": "The index (axis labels) of the Series."})
 Series._add_numeric_operations()
 Series._add_series_only_operations()
 Series._add_series_or_dataframe_operations()

pandas/core/window/indexers.py

@@ -35,7 +35,7 @@ class BaseIndexer:
     """Base class for window bounds calculations"""
 
     def __init__(
-        self, index_array: Optional[np.ndarray] = None, window_size: int = 0, **kwargs,
+        self, index_array: Optional[np.ndarray] = None, window_size: int = 0, **kwargs
     ):
         """
         Parameters
@@ -100,7 +100,7 @@ def get_window_bounds(
     ) -> Tuple[np.ndarray, np.ndarray]:
 
         return calculate_variable_window_bounds(
-            num_values, self.window_size, min_periods, center, closed, self.index_array,
+            num_values, self.window_size, min_periods, center, closed, self.index_array
         )
 
 

pandas/io/formats/css.py

@@ -17,9 +17,7 @@ def expand(self, prop, value):
         try:
             mapping = self.SIDE_SHORTHANDS[len(tokens)]
         except KeyError:
-            warnings.warn(
-                f'Could not expand "{prop}: {value}"', CSSWarning,
-            )
+            warnings.warn(f'Could not expand "{prop}: {value}"', CSSWarning)
             return
         for key, idx in zip(self.SIDES, mapping):
             yield prop_fmt.format(key), tokens[idx]
@@ -114,10 +112,7 @@ def __call__(self, declarations_str, inherited=None):
                 props[prop] = self.size_to_pt(
                     props[prop], em_pt=font_size, conversions=self.BORDER_WIDTH_RATIOS
                 )
-            for prop in [
-                f"margin-{side}",
-                f"padding-{side}",
-            ]:
+            for prop in [f"margin-{side}", f"padding-{side}"]:
                 if prop in props:
                     # TODO: support %
                     props[prop] = self.size_to_pt(

pandas/io/formats/excel.py

@@ -133,8 +133,7 @@ def build_border(self, props):
         return {
             side: {
                 "style": self._border_style(
-                    props.get(f"border-{side}-style"),
-                    props.get(f"border-{side}-width"),
+                    props.get(f"border-{side}-style"), props.get(f"border-{side}-width")
                 ),
                 "color": self.color_to_excel(props.get(f"border-{side}-color")),
             }

pandas/io/formats/style.py

@@ -291,10 +291,7 @@ def format_attr(pair):
 
             # ... except maybe the last for columns.names
             name = self.data.columns.names[r]
-            cs = [
-                BLANK_CLASS if name is None else INDEX_NAME_CLASS,
-                f"level{r}",
-            ]
+            cs = [BLANK_CLASS if name is None else INDEX_NAME_CLASS, f"level{r}"]
             name = BLANK_VALUE if name is None else name
             row_es.append(
                 {
@@ -308,11 +305,7 @@ def format_attr(pair):
 
             if clabels:
                 for c, value in enumerate(clabels[r]):
-                    cs = [
-                        COL_HEADING_CLASS,
-                        f"level{r}",
-                        f"col{c}",
-                    ]
+                    cs = [COL_HEADING_CLASS, f"level{r}", f"col{c}"]
                     cs.extend(
                         cell_context.get("col_headings", {}).get(r, {}).get(c, [])
                     )
@@ -356,11 +349,7 @@ def format_attr(pair):
         for r, idx in enumerate(self.data.index):
             row_es = []
             for c, value in enumerate(rlabels[r]):
-                rid = [
-                    ROW_HEADING_CLASS,
-                    f"level{c}",
-                    f"row{r}",
-                ]
+                rid = [ROW_HEADING_CLASS, f"level{c}", f"row{r}"]
                 es = {
                     "type": "th",
                     "is_visible": (_is_visible(r, c, idx_lengths) and not hidden_index),

pandas/io/orc.py

@@ -12,7 +12,7 @@
 
 
 def read_orc(
-    path: FilePathOrBuffer, columns: Optional[List[str]] = None, **kwargs,
+    path: FilePathOrBuffer, columns: Optional[List[str]] = None, **kwargs
 ) -> "DataFrame":
     """
     Load an ORC object from the file path, returning a DataFrame.

pandas/io/pytables.py

@@ -177,10 +177,7 @@ class DuplicateWarning(Warning):
 _FORMAT_MAP = {"f": "fixed", "fixed": "fixed", "t": "table", "table": "table"}
 
 # storer class map
-_STORER_MAP = {
-    "series": "SeriesFixed",
-    "frame": "FrameFixed",
-}
+_STORER_MAP = {"series": "SeriesFixed", "frame": "FrameFixed"}
 
 # table class map
 _TABLE_MAP = {
@@ -2863,7 +2860,7 @@ def read_index_node(
         # If the index was an empty array write_array_empty() will
         # have written a sentinel. Here we relace it with the original.
         if "shape" in node._v_attrs and np.prod(node._v_attrs.shape) == 0:
-            data = np.empty(node._v_attrs.shape, dtype=node._v_attrs.value_type,)
+            data = np.empty(node._v_attrs.shape, dtype=node._v_attrs.value_type)
         kind = _ensure_decoded(node._v_attrs.kind)
         name = None
 
@@ -3600,10 +3597,7 @@ def _read_axes(
         for a in self.axes:
             a.set_info(self.info)
             res = a.convert(
-                values,
-                nan_rep=self.nan_rep,
-                encoding=self.encoding,
-                errors=self.errors,
+                values, nan_rep=self.nan_rep, encoding=self.encoding, errors=self.errors
             )
             results.append(res)
 
@@ -3995,7 +3989,7 @@ def create_description(
         return d
 
     def read_coordinates(
-        self, where=None, start: Optional[int] = None, stop: Optional[int] = None,
+        self, where=None, start: Optional[int] = None, stop: Optional[int] = None
     ):
         """select coordinates (row numbers) from a table; return the
         coordinates object
@@ -4262,7 +4256,7 @@ def write_data_chunk(
             self.table.flush()
 
     def delete(
-        self, where=None, start: Optional[int] = None, stop: Optional[int] = None,
+        self, where=None, start: Optional[int] = None, stop: Optional[int] = None
     ):
 
         # delete all rows (and return the nrows)
@@ -4691,7 +4685,7 @@ def _convert_index(name: str, index: Index, encoding: str, errors: str) -> Index
     if inferred_type == "date":
         converted = np.asarray([v.toordinal() for v in values], dtype=np.int32)
         return IndexCol(
-            name, converted, "date", _tables().Time32Col(), index_name=index_name,
+            name, converted, "date", _tables().Time32Col(), index_name=index_name
         )
     elif inferred_type == "string":
 
@@ -4707,13 +4701,13 @@ def _convert_index(name: str, index: Index, encoding: str, errors: str) -> Index
 
     elif inferred_type in ["integer", "floating"]:
         return IndexCol(
-            name, values=converted, kind=kind, typ=atom, index_name=index_name,
+            name, values=converted, kind=kind, typ=atom, index_name=index_name
         )
     else:
         assert isinstance(converted, np.ndarray) and converted.dtype == object
         assert kind == "object", kind
         atom = _tables().ObjectAtom()
-        return IndexCol(name, converted, kind, atom, index_name=index_name,)
+        return IndexCol(name, converted, kind, atom, index_name=index_name)
 
 
 def _unconvert_index(

pandas/tests/arithmetic/test_numeric.py

@@ -95,7 +95,7 @@ class TestNumericArraylikeArithmeticWithDatetimeLike:
     # TODO: also check name retentention
     @pytest.mark.parametrize("box_cls", [np.array, pd.Index, pd.Series])
     @pytest.mark.parametrize(
-        "left", lefts, ids=lambda x: type(x).__name__ + str(x.dtype),
+        "left", lefts, ids=lambda x: type(x).__name__ + str(x.dtype)
     )
     def test_mul_td64arr(self, left, box_cls):
         # GH#22390
@@ -115,7 +115,7 @@ def test_mul_td64arr(self, left, box_cls):
     # TODO: also check name retentention
     @pytest.mark.parametrize("box_cls", [np.array, pd.Index, pd.Series])
     @pytest.mark.parametrize(
-        "left", lefts, ids=lambda x: type(x).__name__ + str(x.dtype),
+        "left", lefts, ids=lambda x: type(x).__name__ + str(x.dtype)
     )
     def test_div_td64arr(self, left, box_cls):
         # GH#22390

pandas/tests/arrays/sparse/test_array.py

@@ -660,16 +660,12 @@ 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:,
-        ]  # noqa: E231
+        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:,
-        ]  # noqa: E231
+        res = sparse[4:,]  # noqa: E231
         exp = SparseArray(dense[4:,], fill_value=0)  # noqa: E231
         tm.assert_sp_array_equal(res, exp)
 

pandas/tests/arrays/test_boolean.py

@@ -565,9 +565,7 @@ def test_kleene_xor_scalar(self, other, expected):
             a, pd.array([True, False, None], dtype="boolean")
         )
 
-    @pytest.mark.parametrize(
-        "other", [True, False, pd.NA, [True, False, None] * 3],
-    )
+    @pytest.mark.parametrize("other", [True, False, pd.NA, [True, False, None] * 3])
     def test_no_masked_assumptions(self, other, all_logical_operators):
         # The logical operations should not assume that masked values are False!
         a = pd.arrays.BooleanArray(

pandas/tests/frame/test_apply.py

@@ -693,11 +693,8 @@ def test_apply_dup_names_multi_agg(self):
 
     def test_apply_get_dtype(self):
         # GH 28773
-        df = DataFrame({
-            "col_1": [1, 2, 3],
-            "col_2": ["hi", "there", "friend"]
-        })
-        expected = Series(data=['int64', 'object'] ,index=['col_1', 'col_2'])
+        df = DataFrame({"col_1": [1, 2, 3], "col_2": ["hi", "there", "friend"]})
+        expected = Series(data=["int64", "object"], index=["col_1", "col_2"])
         tm.assert_series_equal(df.apply(lambda x: x.dtype), expected)
 
 

pandas/tests/indexing/common.py

@@ -170,7 +170,7 @@ def check_values(self, f, func, values=False):
             tm.assert_almost_equal(result, expected)
 
     def check_result(
-        self, method1, key1, method2, key2, typs=None, axes=None, fails=None,
+        self, method1, key1, method2, key2, typs=None, axes=None, fails=None
     ):
         def _eq(axis, obj, key1, key2):
             """ compare equal for these 2 keys """

pandas/tests/indexing/test_callable.py

@@ -17,14 +17,10 @@ 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
+        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
+        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", :]
@@ -94,9 +90,7 @@ 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
+        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"], :]

pandas/tests/indexing/test_loc.py

@@ -116,7 +116,7 @@ def test_loc_getitem_label_out_of_range(self):
         self.check_result("loc", "f", "ix", "f", typs=["floats"], fails=KeyError)
         self.check_result("loc", "f", "loc", "f", typs=["floats"], fails=KeyError)
         self.check_result(
-            "loc", 20, "loc", 20, typs=["ints", "uints", "mixed"], fails=KeyError,
+            "loc", 20, "loc", 20, typs=["ints", "uints", "mixed"], fails=KeyError
         )
         self.check_result("loc", 20, "loc", 20, typs=["labels"], fails=TypeError)
         self.check_result("loc", 20, "loc", 20, typs=["ts"], axes=0, fails=TypeError)
@@ -129,7 +129,7 @@ def test_loc_getitem_label_list(self):
 
     def test_loc_getitem_label_list_with_missing(self):
         self.check_result(
-            "loc", [0, 1, 2], "loc", [0, 1, 2], typs=["empty"], fails=KeyError,
+            "loc", [0, 1, 2], "loc", [0, 1, 2], typs=["empty"], fails=KeyError
         )
         self.check_result(
             "loc",