Refactoring function name and formatting

Author: cyberosa

dabest/_effsize_objects.py

@@ -1141,7 +1141,7 @@ def plot(self, color_col=None,
 
         """
 
-        from .plotter import EffectSizeDataFramePlotter
+        from .plotter import effectsize_df_plotter
 
         if hasattr(self, "results") is False:
             self.__pre_calc()
@@ -1158,7 +1158,7 @@ def plot(self, color_col=None,
         all_kwargs = locals()
         del all_kwargs["self"]
 
-        out = EffectSizeDataFramePlotter(self, **all_kwargs)
+        out = effectsize_df_plotter(self, **all_kwargs)
 
         return out
 

dabest/_modidx.py

@@ -78,5 +78,4 @@
                                    'dabest.plot_tools.sankeydiag': ('API/plot_tools.html#sankeydiag', 'dabest/plot_tools.py'),
                                    'dabest.plot_tools.single_sankey': ('API/plot_tools.html#single_sankey', 'dabest/plot_tools.py'),
                                    'dabest.plot_tools.width_determine': ('API/plot_tools.html#width_determine', 'dabest/plot_tools.py')},
-            'dabest.plotter': { 'dabest.plotter.EffectSizeDataFramePlotter': ( 'API/plotter.html#effectsizedataframeplotter',
-                                                                               'dabest/plotter.py')}}}
+            'dabest.plotter': {'dabest.plotter.effectsize_df_plotter': ('API/plotter.html#effectsize_df_plotter', 'dabest/plotter.py')}}}

dabest/forest_plot.py

@@ -4,20 +4,16 @@
 __all__ = ['load_plot_data', 'extract_plot_data', 'forest_plot']
 
 # %% ../nbs/API/forest_plot.ipynb 5
-import numpy as np
-import scipy as sp
-import pandas as pd
-import matplotlib as mpl
 import matplotlib.pyplot as plt
 # %matplotlib inline
 import seaborn as sns
-from typing import List, Optional, Tuple, Union
+from typing import List, Optional, Union
 
 
 # %% ../nbs/API/forest_plot.ipynb 6
-def load_plot_data(contrasts: List, 
-                   effect_size: str = 'mean_diff', 
-                   contrast_type: str = 'delta2') -> List:
+def load_plot_data(
+    contrasts: List, effect_size: str = "mean_diff", contrast_type: str = "delta2"
+) -> List:
     """
     Loads plot data based on specified effect size and contrast type.
 
@@ -30,63 +26,71 @@ def load_plot_data(contrasts: List,
     List: Contrast plot data based on specified parameters.
     """
     effect_attr_map = {
-        'mean_diff': 'mean_diff',
-        'median_diff': 'median_diff',
-        'cliffs_delta': 'cliffs_delta',
-        'cohens_d': 'cohens_d',
-        'hedges_g': 'hedges_g'
+        "mean_diff": "mean_diff",
+        "median_diff": "median_diff",
+        "cliffs_delta": "cliffs_delta",
+        "cohens_d": "cohens_d",
+        "hedges_g": "hedges_g",
     }
 
-    contrast_attr_map = {
-        'delta2': 'delta_delta',
-        'mini_meta': 'mini_meta'
-    }
+    contrast_attr_map = {"delta2": "delta_delta", "mini_meta": "mini_meta"}
 
     effect_attr = effect_attr_map.get(effect_size)
-    contrast_attr = contrast_attr_map.get(contrast_type, 'delta_delta')
+    contrast_attr = contrast_attr_map.get(contrast_type, "delta_delta")
 
     if not effect_attr:
         raise ValueError(f"Invalid effect_size: {effect_size}")
 
-    return [getattr(getattr(contrast, effect_attr), contrast_attr) for contrast in contrasts]
+    return [
+        getattr(getattr(contrast, effect_attr), contrast_attr) for contrast in contrasts
+    ]
+
 
 def extract_plot_data(contrast_plot_data, contrast_labels):
-    """ Extracts bootstrap, difference, and confidence intervals based on contrast labels. """
-    if contrast_labels == 'mini_meta':
-        attribute_suffix = 'weighted_delta'
+    """Extracts bootstrap, difference, and confidence intervals based on contrast labels."""
+    if contrast_labels == "mini_meta":
+        attribute_suffix = "weighted_delta"
     else:
-        attribute_suffix = 'delta_delta'
+        attribute_suffix = "delta_delta"
 
-    bootstraps = [getattr(result, f'bootstraps_{attribute_suffix}') for result in contrast_plot_data]
+    bootstraps = [
+        getattr(result, f"bootstraps_{attribute_suffix}")
+        for result in contrast_plot_data
+    ]
     differences = [result.difference for result in contrast_plot_data]
     bcalows = [result.bca_low for result in contrast_plot_data]
     bcahighs = [result.bca_high for result in contrast_plot_data]
 
     return bootstraps, differences, bcalows, bcahighs
 
-def forest_plot(contrasts: List, 
-                selected_indices: Optional[List] = None, 
-                analysis_type: str = 'delta2', 
-                xticklabels: Optional[List] = None,
-                effect_size: str = 'mean_diff', 
-                contrast_labels: str = 'delta_delta', 
-                ylabel: str = 'ΔΔ Volume (nL)',
-                plot_elements_to_extract: Optional[List] = None, 
-                title: str = 'ΔΔ Forest', 
-                custom_palette: Optional[Union[dict, list, str]] = None,  # Custom color palette parameter
-                fontsize: int = 20, 
-                violin_kwargs: Optional[dict] = None, 
-                marker_size: int = 20, 
-                ci_line_width: float = 2.5,
-                zero_line_width: int = 1, 
-                remove_spines: bool = True, 
-                ax: Optional[plt.Axes] = None,
-                additional_plotting_kwargs: Optional[dict] = None, 
-                rotation_for_xlabels: int = 45, 
-                alpha_violin_plot: float = 0.4) -> plt.Figure:
+
+def forest_plot(
+    contrasts: List,
+    selected_indices: Optional[List] = None,
+    analysis_type: str = "delta2",
+    xticklabels: Optional[List] = None,
+    effect_size: str = "mean_diff",
+    contrast_labels: str = "delta_delta",
+    ylabel: str = "ΔΔ Volume (nL)",
+    plot_elements_to_extract: Optional[List] = None,
+    title: str = "ΔΔ Forest",
+    custom_palette: Optional[
+        Union[dict, list, str]
+    ] = None,  # Custom color palette parameter
+    fontsize: int = 20,
+    violin_kwargs: Optional[dict] = None,
+    marker_size: int = 20,
+    ci_line_width: float = 2.5,
+    zero_line_width: int = 1,
+    remove_spines: bool = True,
+    ax: Optional[plt.Axes] = None,
+    additional_plotting_kwargs: Optional[dict] = None,
+    rotation_for_xlabels: int = 45,
+    alpha_violin_plot: float = 0.4,
+) -> plt.Figure:
     """
     Generates a customized forest plot using contrast objects from DABEST-python package or similar.
-    
+
     Parameters:
     contrasts (List): List of contrast objects.
     selected_indices (Optional[List]): Indices of contrasts to be plotted, if not all.
@@ -114,11 +118,14 @@ def forest_plot(contrasts: List,
     plt.Figure: The matplotlib figure object with the plot.
     """
     from .plot_tools import halfviolin
+
     # Load plot data
     contrast_plot_data = load_plot_data(contrasts, effect_size, analysis_type)
 
     # Extract data for plotting
-    bootstraps, differences, bcalows, bcahighs = extract_plot_data(contrast_plot_data, contrast_labels)
+    bootstraps, differences, bcalows, bcahighs = extract_plot_data(
+        contrast_plot_data, contrast_labels
+    )
 
     # Infer the figsize based on the number of contrasts
     all_groups_count = len(contrasts)
@@ -135,43 +142,56 @@ def forest_plot(contrasts: List,
         fig = ax.figure
 
     # Zero line
-    ax.plot([0, len(contrasts) + 1], [0, 0], 'k', linewidth=zero_line_width)
+    ax.plot([0, len(contrasts) + 1], [0, 0], "k", linewidth=zero_line_width)
 
     # Violin plots with customizable colors
-    violin_kwargs = violin_kwargs or {'widths': 0.5, 'vert': True, 'showextrema': False, 'showmedians': False}
+    violin_kwargs = violin_kwargs or {
+        "widths": 0.5,
+        "vert": True,
+        "showextrema": False,
+        "showmedians": False,
+    }
     v = ax.violinplot(bootstraps, **violin_kwargs)
     halfviolin(v, alpha=alpha_violin_plot)  # Apply halfviolin from dabest
 
     # Handle the custom color palette
     if custom_palette:
         if isinstance(custom_palette, dict):
-            violin_colors = [custom_palette.get(c, sns.color_palette()[0]) for c in contrasts]
+            violin_colors = [
+                custom_palette.get(c, sns.color_palette()[0]) for c in contrasts
+            ]
         elif isinstance(custom_palette, list):
-            violin_colors = custom_palette[:len(contrasts)]
+            violin_colors = custom_palette[: len(contrasts)]
         elif isinstance(custom_palette, str):
             if custom_palette in plt.colormaps():
                 violin_colors = sns.color_palette(custom_palette, len(contrasts))
             else:
-                raise ValueError(f"The specified `custom_palette` {custom_palette} is not a recognized Matplotlib palette.")
+                raise ValueError(
+                    f"The specified `custom_palette` {custom_palette} is not a recognized Matplotlib palette."
+                )
     else:
-        violin_colors = sns.color_palette()[:len(contrasts)]
+        violin_colors = sns.color_palette()[: len(contrasts)]
 
-    for patch, color in zip(v['bodies'], violin_colors):
+    for patch, color in zip(v["bodies"], violin_colors):
         patch.set_facecolor(color)
         patch.set_alpha(alpha_violin_plot)
 
     # Effect size dot and confidence interval
     for k in range(1, len(contrasts) + 1):
-        ax.plot(k, differences[k - 1], 'k.', markersize=marker_size)
-        ax.plot([k, k], [bcalows[k - 1], bcahighs[k - 1]], 'k', linewidth=ci_line_width)
+        ax.plot(k, differences[k - 1], "k.", markersize=marker_size)
+        ax.plot([k, k], [bcalows[k - 1], bcahighs[k - 1]], "k", linewidth=ci_line_width)
 
     # Custom settings
     ax.set_xticks(range(1, len(contrasts) + 1))
-    ax.set_xticklabels(xticklabels or range(1, len(contrasts) + 1), rotation=rotation_for_xlabels, fontsize=fontsize)
+    ax.set_xticklabels(
+        xticklabels or range(1, len(contrasts) + 1),
+        rotation=rotation_for_xlabels,
+        fontsize=fontsize,
+    )
     ax.set_xlim([0, len(contrasts) + 1])
     ax.set_ylabel(ylabel, fontsize=fontsize)
     ax.set_title(title, fontsize=fontsize)
-    ylim = (min(bcalows)-0.25, max(bcahighs)+0.25)
+    ylim = (min(bcalows) - 0.25, max(bcahighs) + 0.25)
     ax.set_ylim(ylim)
 
     # Remove spines if requested
@@ -184,4 +204,3 @@ def forest_plot(contrasts: List,
         ax.set(**additional_plotting_kwargs)
 
     return fig
-

dabest/plotter.py

@@ -1,7 +1,7 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/API/plotter.ipynb.
 
 # %% auto 0
-__all__ = ['EffectSizeDataFramePlotter']
+__all__ = ['effectsize_df_plotter']
 
 # %% ../nbs/API/plotter.ipynb 4
 import numpy as np
@@ -14,7 +14,7 @@
 
 # %% ../nbs/API/plotter.ipynb 5
 # TODO refactor function name
-def EffectSizeDataFramePlotter(effectsize_df, **plot_kwargs):
+def effectsize_df_plotter(effectsize_df, **plot_kwargs):
     """
     Custom function that creates an estimation plot from an EffectSizeDataFrame.
     Keywords

nbs/API/effsize_objects.ipynb

@@ -1302,7 +1302,7 @@
     "\n",
     "        \"\"\"\n",
     "\n",
-    "        from .plotter import EffectSizeDataFramePlotter\n",
+    "        from .plotter import effectsize_df_plotter\n",
     "\n",
     "        if hasattr(self, \"results\") is False:\n",
     "            self.__pre_calc()\n",
@@ -1319,7 +1319,7 @@
     "        all_kwargs = locals()\n",
     "        del all_kwargs[\"self\"]\n",
     "\n",
-    "        out = EffectSizeDataFramePlotter(self, **all_kwargs)\n",
+    "        out = effectsize_df_plotter(self, **all_kwargs)\n",
     "\n",
     "        return out\n",
     "\n",