appeasing the great pre-commit formatter

Author: eicchen

pandas/plotting/_matplotlib/core.py

@@ -1929,17 +1929,20 @@ def _make_plot(self, fig: Figure) -> None:
 
         data = self.data.fillna(0)
 
-        _stacked_subplots_ind_dict  = {}
-        _stacked_subplots_offsets   = []
+        _stacked_subplots_ind_dict = {}
+        _stacked_subplots_offsets = []
 
         if self.subplots != False & self.stacked:
-            # _stacked_subplots_list = [sorted(x) for x in self.subplots if len(x) > 1]
-            temp_ss_dict = {x: self.subplots[x] for x in range(len(self.subplots)) if len(self.subplots[x]) > 1}
+            temp_ss_dict = {
+                x: self.subplots[x]
+                for x in range(len(self.subplots))
+                if len(self.subplots[x]) > 1
+            }
             for k, v in temp_ss_dict.items():
                 for x in v:
                     _stacked_subplots_ind_dict.setdefault(int(x), k)
-                    
-                _stacked_subplots_offsets.append([0,0])
+
+                _stacked_subplots_offsets.append([0, 0])
 
         for i, (label, y) in enumerate(self._iter_data(data=data)):
             ax = self._get_ax(i)
@@ -1966,16 +1969,11 @@ def _make_plot(self, fig: Figure) -> None:
             start = start + self._start_base
 
             kwds["align"] = self._align
-            
-            try:
-                offset_index = _stacked_subplots_ind_dict[i]
-                _stacked_subplots_flag = 1
-            except:
-                _stacked_subplots_flag = 0
 
-            if _stacked_subplots_flag:
-                mask = y >= 0
+            if i in _stacked_subplots_ind_dict:
+                offset_index = _stacked_subplots_ind_dict[i]
                 pos_prior, neg_prior = _stacked_subplots_offsets[offset_index]
+                mask = y >= 0
                 start = np.where(mask, pos_prior, neg_prior) + self._start_base
                 w = self.bar_width / 2
                 rect = self._plot(
@@ -1991,7 +1989,7 @@ def _make_plot(self, fig: Figure) -> None:
                 pos_new = pos_prior + np.where(mask, y, 0)
                 neg_new = neg_prior + np.where(mask, 0, y)
                 _stacked_subplots_offsets[offset_index] = [pos_new, neg_new]
-                
+
             elif self.subplots:
                 w = self.bar_width / 2
                 rect = self._plot(

pandas/tests/plotting/test_common.py

@@ -1,5 +1,5 @@
 import pytest
-import numpy as np
+
 from pandas import DataFrame
 from pandas.tests.plotting.common import (
     _check_plot_works,
@@ -58,7 +58,3 @@ def test_colorbar_layout(self):
 
         fig.colorbar(cs0, ax=[axes["A"], axes["B"]], location="right")
         DataFrame(x).plot(ax=axes["C"])
-
-
-
-

pandas/tests/plotting/test_misc.py

@@ -682,93 +682,128 @@ def test_bar_plt_xaxis_intervalrange(self):
             for a, b in zip(s.plot.bar().get_xticklabels(), expected)
         )
 
+
 @pytest.fixture(scope="class")
 def BSS_data() -> np.array:
-    yield np.random.default_rng(3).integers(0,100,5)
+    return np.random.default_rng(3).integers(0, 100, 5)
+
 
 @pytest.fixture(scope="class")
 def BSS_df(BSS_data) -> DataFrame:
-    BSS_df = DataFrame({"A": BSS_data, "B": BSS_data[::-1], "C": BSS_data[0], "D": BSS_data[-1]})
+    BSS_df = DataFrame(
+        {"A": BSS_data, "B": BSS_data[::-1], "C": BSS_data[0], "D": BSS_data[-1]}
+    )
     return BSS_df
 
+
 def _BSS_xyheight_from_ax_helper(BSS_data, ax, subplot_division):
     subplot_data_df_list = []
 
-    # get xy and height of squares that represent the data graphed from the df, seperated by subplots
+    # get xy and height of squares representing data, separated by subplots
     for i in range(len(subplot_division)):
-        subplot_data = np.array([(x.get_x(), x.get_y(), x.get_height()) for x in ax[i].findobj(plt.Rectangle) if x.get_height() in BSS_data])
-        subplot_data_df_list.append(DataFrame(data = subplot_data, columns = ["x_coord", "y_coord", "height"]))
+        subplot_data = np.array(
+            [
+                (x.get_x(), x.get_y(), x.get_height())
+                for x in ax[i].findobj(plt.Rectangle)
+                if x.get_height() in BSS_data
+            ]
+        )
+        subplot_data_df_list.append(
+            DataFrame(data=subplot_data, columns=["x_coord", "y_coord", "height"])
+        )
 
     return subplot_data_df_list
 
+
 def _BSS_subplot_checker(BSS_data, BSS_df, subplot_data_df, subplot_columns):
-    assert_flag = 0
-    subplot_sliced_by_source = [subplot_data_df.iloc[len(BSS_data) * i : len(BSS_data) * (i+1)].reset_index() for i in range(0, len(subplot_columns))]
-    expected_total_height = BSS_df.loc[:,subplot_columns].sum(axis=1)
-    
+    subplot_sliced_by_source = [
+        subplot_data_df.iloc[len(BSS_data) * i : len(BSS_data) * (i + 1)].reset_index()
+        for i in range(len(subplot_columns))
+    ]
+    expected_total_height = BSS_df.loc[:, subplot_columns].sum(axis=1)
+
     for i in range(len(subplot_columns)):
         sliced_df = subplot_sliced_by_source[i]
         if i == 0:
-            #Checks that the bar chart starts y=0
+            # Checks that the bar chart starts y=0
             assert (sliced_df["y_coord"] == 0).all
             height_iter = sliced_df["y_coord"].add(sliced_df["height"])
         else:
             height_iter = height_iter + sliced_df["height"]
 
-        if i+1 == len(subplot_columns):
-            #Checks final height matches what is expected
-            tm.assert_series_equal(height_iter, expected_total_height, check_names = False, check_dtype= False)
-            
+        if i + 1 == len(subplot_columns):
+            # Checks final height matches what is expected
+            tm.assert_series_equal(
+                height_iter, expected_total_height, check_names=False, check_dtype=False
+            )
+
         else:
-            #Checks each preceding bar ends where the next one starts
-            next_start_coord = subplot_sliced_by_source[i+1]["y_coord"]
-            tm.assert_series_equal(height_iter, next_start_coord, check_names = False, check_dtype= False)
+            # Checks each preceding bar ends where the next one starts
+            next_start_coord = subplot_sliced_by_source[i + 1]["y_coord"]
+            tm.assert_series_equal(
+                height_iter, next_start_coord, check_names=False, check_dtype=False
+            )
+
 
 class TestBarSubplotStacked:
-    #GH Issue 61018
-    @pytest.mark.parametrize("columns_used",[["A", "B"],
-                                             ["C", "D"],
-                                             ["D", "A"]
-    ])
+    # GH Issue 61018
+    @pytest.mark.parametrize("columns_used", [["A", "B"], ["C", "D"], ["D", "A"]])
     def test_bar_1_subplot_1_double_stacked(self, BSS_data, BSS_df, columns_used):
         BSS_df_trimmed = BSS_df[columns_used]
         subplot_division = [columns_used]
-        ax = BSS_df_trimmed.plot(subplots = subplot_division, kind="bar", stacked=True)
-        subplot_data_df_list = _BSS_xyheight_from_ax_helper(BSS_data, ax, subplot_division)
+        ax = BSS_df_trimmed.plot(subplots=subplot_division, kind="bar", stacked=True)
+        subplot_data_df_list = _BSS_xyheight_from_ax_helper(
+            BSS_data, ax, subplot_division
+        )
         for i in range(len(subplot_data_df_list)):
-            _BSS_subplot_checker(BSS_data, BSS_df_trimmed, subplot_data_df_list[i], subplot_division[i])
+            _BSS_subplot_checker(
+                BSS_data, BSS_df_trimmed, subplot_data_df_list[i], subplot_division[i]
+            )
 
-    @pytest.mark.parametrize("columns_used",[["A", "B", "C"],
-                                             ["A", "C", "B"],
-                                             ["D", "A", "C"]
-                                              
-    ])
+    @pytest.mark.parametrize(
+        "columns_used", [["A", "B", "C"], ["A", "C", "B"], ["D", "A", "C"]]
+    )
     def test_bar_2_subplot_1_double_stacked(self, BSS_data, BSS_df, columns_used):
-        BSS_df_trimmed = BSS_df[columns_used] 
+        BSS_df_trimmed = BSS_df[columns_used]
         subplot_division = [(columns_used[0], columns_used[1]), (columns_used[2],)]
-        ax = BSS_df_trimmed.plot(subplots = subplot_division, kind="bar", stacked=True)
-        subplot_data_df_list = _BSS_xyheight_from_ax_helper(BSS_data, ax, subplot_division)
+        ax = BSS_df_trimmed.plot(subplots=subplot_division, kind="bar", stacked=True)
+        subplot_data_df_list = _BSS_xyheight_from_ax_helper(
+            BSS_data, ax, subplot_division
+        )
         for i in range(len(subplot_data_df_list)):
-            _BSS_subplot_checker(BSS_data, BSS_df_trimmed, subplot_data_df_list[i], subplot_division[i])
+            _BSS_subplot_checker(
+                BSS_data, BSS_df_trimmed, subplot_data_df_list[i], subplot_division[i]
+            )
 
-    @pytest.mark.parametrize("subplot_division", [[("A", "B"), ("C", "D")],
-                                                  [("A", "D"), ("C", "B")],
-                                                  [("B", "C"), ("D", "A")],
-                                                  [("B", "D"), ("C", "A")]
-    ])
+    @pytest.mark.parametrize(
+        "subplot_division",
+        [
+            [("A", "B"), ("C", "D")],
+            [("A", "D"), ("C", "B")],
+            [("B", "C"), ("D", "A")],
+            [("B", "D"), ("C", "A")],
+        ],
+    )
     def test_bar_2_subplot_2_double_stacked(self, BSS_data, BSS_df, subplot_division):
-        ax = BSS_df.plot(subplots = subplot_division, kind="bar", stacked=True)
-        subplot_data_df_list = _BSS_xyheight_from_ax_helper(BSS_data, ax, subplot_division)
+        ax = BSS_df.plot(subplots=subplot_division, kind="bar", stacked=True)
+        subplot_data_df_list = _BSS_xyheight_from_ax_helper(
+            BSS_data, ax, subplot_division
+        )
         for i in range(len(subplot_data_df_list)):
-            _BSS_subplot_checker(BSS_data, BSS_df, subplot_data_df_list[i], subplot_division[i])
-    
-    @pytest.mark.parametrize("subplot_division", [[("A", "B", "C")],
-                                                  [("A", "D", "B")],
-                                                  [("C", "A", "D")],
-                                                  [("D", "C", "A")]
-    ])
+            _BSS_subplot_checker(
+                BSS_data, BSS_df, subplot_data_df_list[i], subplot_division[i]
+            )
+
+    @pytest.mark.parametrize(
+        "subplot_division",
+        [[("A", "B", "C")], [("A", "D", "B")], [("C", "A", "D")], [("D", "C", "A")]],
+    )
     def test_bar_2_subplots_1_triple_stacked(self, BSS_data, BSS_df, subplot_division):
-        ax = BSS_df.plot(subplots = subplot_division, kind="bar", stacked=True)
-        subplot_data_df_list = _BSS_xyheight_from_ax_helper(BSS_data, ax, subplot_division)
+        ax = BSS_df.plot(subplots=subplot_division, kind="bar", stacked=True)
+        subplot_data_df_list = _BSS_xyheight_from_ax_helper(
+            BSS_data, ax, subplot_division
+        )
         for i in range(len(subplot_data_df_list)):
-            _BSS_subplot_checker(BSS_data, BSS_df, subplot_data_df_list[i], subplot_division[i])
+            _BSS_subplot_checker(
+                BSS_data, BSS_df, subplot_data_df_list[i], subplot_division[i]
+            )