scitex 2.5.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

scitex/stats/correct/_correct_sidak.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -215,11 +216,11 @@ def correct_sidak(
             logger.info("\nDetailed results:")
             for r in corrected_results:
                 comparison = ""
-                if 'var_x' in r and 'var_y' in r:
+                if "var_x" in r and "var_y" in r:
                     comparison = f"{r['var_x']} vs {r['var_y']}: "
-                elif 'test_method' in r:
+                elif "test_method" in r:
                     comparison = f"{r['test_method']}: "
-                elif 'comparison' in r:
+                elif "comparison" in r:
                     comparison = f"{r['comparison']}: "
 
                 logger.info(
@@ -236,6 +237,7 @@ def correct_sidak(
     if plot:
         if ax is None:
             import matplotlib.pyplot as plt
+
             fig, ax = plt.subplots(figsize=(10, 6))
         _plot_sidak(corrected_results, alpha, alpha_adj, m, ax)
 
@@ -257,23 +259,40 @@ def _plot_sidak(corrected_results, alpha, alpha_adj, m, ax):
 
     # Plot original and adjusted p-values
     ax.scatter(x, pvalues, label="Original p-values", alpha=0.7, s=100, color="C0")
-    ax.scatter(x, pvalues_adj, label="Adjusted p-values", alpha=0.7, s=100, color="C1", marker="s")
+    ax.scatter(
+        x,
+        pvalues_adj,
+        label="Adjusted p-values",
+        alpha=0.7,
+        s=100,
+        color="C1",
+        marker="s",
+    )
 
     # Connect original to adjusted with lines
     for i in range(m):
         ax.plot([i, i], [pvalues[i], pvalues_adj[i]], "k-", alpha=0.3, linewidth=0.5)
 
     # Add significance thresholds
-    ax.axhline(alpha, color="red", linestyle="--", linewidth=2, alpha=0.5, label=f"α = {alpha}")
-    ax.axhline(alpha_adj, color="orange", linestyle="--", linewidth=2, alpha=0.5,
-               label=f"α_adj = {alpha_adj:.4f}")
+    ax.axhline(
+        alpha, color="red", linestyle="--", linewidth=2, alpha=0.5, label=f"α = {alpha}"
+    )
+    ax.axhline(
+        alpha_adj,
+        color="orange",
+        linestyle="--",
+        linewidth=2,
+        alpha=0.5,
+        label=f"α_adj = {alpha_adj:.4f}",
+    )
 
     # Formatting
     ax.set_xlabel("Test Index")
     ax.set_ylabel("P-value")
     rejections = sum(r["rejected"] for r in corrected_results)
-    ax.set_title(f"Šidák Correction (m={m} tests)\n"
-                 f"{rejections}/{m} hypotheses rejected")
+    ax.set_title(
+        f"Šidák Correction (m={m} tests)\n{rejections}/{m} hypotheses rejected"
+    )
     ax.set_yscale("log")
     ax.grid(True, alpha=0.3)
     ax.legend()
@@ -289,7 +308,7 @@ def _plot_sidak(corrected_results, alpha, alpha_adj, m, ax):
             elif "comparison" in r:
                 labels.append(r["comparison"])
             else:
-                labels.append(f"Test {len(labels)+1}")
+                labels.append(f"Test {len(labels) + 1}")
         ax.set_xticks(x)
         ax.set_xticklabels(labels, rotation=45, ha="right", fontsize=8)
     else:
@@ -309,7 +328,9 @@ def main():
 
     # Parse empty args for session
     parser = argparse.ArgumentParser()
-    parser.add_argument('--verbose', action='store_true', default=True, help='Enable verbose output')
+    parser.add_argument(
+        "--verbose", action="store_true", default=True, help="Enable verbose output"
+    )
     args = parser.parse_args([])
 
     CONFIG, sys.stdout, sys.stderr, plt, CC, rng_manager = stx.session.start(
@@ -326,9 +347,7 @@ def main():
     logger.info("=" * 70)
 
     # Example 1: Basic usage with 5 independent tests
-    logger.info(
-        "\n[Example 1] Basic Šidák correction with 5 independent t-tests"
-    )
+    logger.info("\n[Example 1] Basic Šidák correction with 5 independent t-tests")
     logger.info("-" * 70)
 
     np.random.seed(42)
@@ -410,9 +429,7 @@ def main():
         logger.info(f"Output type: {type(df_corrected)}")
         logger.info(f"\nCorrected DataFrame (first 3 rows):")
         logger.info(
-            df_corrected[
-                ["var_x", "var_y", "pvalue", "pvalue_adjusted", "rejected"]
-            ]
+            df_corrected[["var_x", "var_y", "pvalue", "pvalue_adjusted", "rejected"]]
             .head(3)
             .to_string()
         )
@@ -437,7 +454,7 @@ def main():
 
     for i, (orig, corr) in enumerate(zip(edge_results, edge_corrected)):
         logger.info(
-            f"Test {i+1}: p = {orig['pvalue']:.4f} -> "
+            f"Test {i + 1}: p = {orig['pvalue']:.4f} -> "
             f"p_adj = {corr['pvalue_adjusted']:.4f}"
         )
 
@@ -478,9 +495,7 @@ def main():
         bonf_alpha = alpha / m
         sidak_alpha = 1.0 - (1.0 - alpha) ** (1.0 / m)
         ratio = sidak_alpha / bonf_alpha
-        logger.info(
-            f"{m:<5} {bonf_alpha:.6f}     {sidak_alpha:.6f}     {ratio:.4f}"
-        )
+        logger.info(f"{m:<5} {bonf_alpha:.6f}     {sidak_alpha:.6f}     {ratio:.4f}")
 
     logger.info("\nNote: Šidák is always ≥ Bonferroni (more powerful)")
     logger.info("Difference increases with larger m")

scitex/stats/descriptive/_circular.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -50,6 +51,8 @@ from scitex.decorators import batch_fn, torch_fn
 logger = logging.getLogger(__name__)
 
 """Functions & Classes"""
+
+
 # @batch_fn
 @torch_fn
 def describe_circular(
@@ -110,17 +113,15 @@ def describe_circular(
     else:
         _funcs = [func_candidates[ff] for ff in func_names]
 
-    calculated = [
-        ff(angles, values, dim=dim, keepdims=keepdims) for ff in _funcs
-    ]
+    calculated = [ff(angles, values, dim=dim, keepdims=keepdims) for ff in _funcs]
 
     return torch.stack(calculated, dim=-1), func_names
 
 
 def _ensure_more_than_2d(data: torch.Tensor) -> None:
-    assert (
-        data.ndim >= 2
-    ), f"Input tensor must be more than 2 dimensional with batch dimension as first axis, got {data.ndim}"
+    assert data.ndim >= 2, (
+        f"Input tensor must be more than 2 dimensional with batch dimension as first axis, got {data.ndim}"
+    )
 
 
 def _check_angle_units(angles: torch.Tensor) -> None:
@@ -174,9 +175,9 @@ def circular_mean(
 
     _ensure_more_than_2d(angles)
     _check_angle_units(angles)
-    assert (
-        angles.shape == values.shape
-    ), f"angles shape {angles.shape} must match values shape {values.shape}"
+    assert angles.shape == values.shape, (
+        f"angles shape {angles.shape} must match values shape {values.shape}"
+    )
 
     dim = axis if dim is None else dim
     cos_angles = torch.cos(angles)
@@ -189,9 +190,7 @@ def circular_mean(
     sin_component = sin_component / value_sum
 
     mean_angle = torch.atan2(sin_component, cos_component)
-    mean_angle = torch.where(
-        mean_angle < 0, mean_angle + 2 * np.pi, mean_angle
-    )
+    mean_angle = torch.where(mean_angle < 0, mean_angle + 2 * np.pi, mean_angle)
 
     return mean_angle if keepdims else mean_angle.squeeze(dim)
 
@@ -230,9 +229,9 @@ def circular_concentration(
     """
     _ensure_more_than_2d(angles)
     _check_angle_units(angles)
-    assert (
-        angles.shape == values.shape
-    ), f"angles shape {angles.shape} must match values shape {values.shape}"
+    assert angles.shape == values.shape, (
+        f"angles shape {angles.shape} must match values shape {values.shape}"
+    )
 
     dim = axis if dim is None else dim
     cos_angles = torch.cos(angles)
@@ -280,9 +279,9 @@ def circular_skewness(
     """
     _ensure_more_than_2d(angles)
     _check_angle_units(angles)
-    assert (
-        angles.shape == values.shape
-    ), f"angles shape {angles.shape} must match values shape {values.shape}"
+    assert angles.shape == values.shape, (
+        f"angles shape {angles.shape} must match values shape {values.shape}"
+    )
 
     dim = axis if dim is None else dim
     cos_angles = torch.cos(angles)
@@ -334,9 +333,9 @@ def circular_kurtosis(
     """
     _ensure_more_than_2d(angles)
     _check_angle_units(angles)
-    assert (
-        angles.shape == values.shape
-    ), f"angles shape {angles.shape} must match values shape {values.shape}"
+    assert angles.shape == values.shape, (
+        f"angles shape {angles.shape} must match values shape {values.shape}"
+    )
 
     dim = axis if dim is None else dim
     cos_angles = torch.cos(angles)

scitex/stats/descriptive/_describe.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -40,13 +41,26 @@ import torch
 from scitex import logging
 
 from scitex.decorators import batch_fn, torch_fn
-from ._nan import (nancount, nankurtosis, nanmax, nanmean, nanmin, nanq25,
-                   nanq50, nanq75, nanskewness, nanstd, nanvar)
+from ._nan import (
+    nancount,
+    nankurtosis,
+    nanmax,
+    nanmean,
+    nanmin,
+    nanq25,
+    nanq50,
+    nanq75,
+    nanskewness,
+    nanstd,
+    nanvar,
+)
 from ._real import kurtosis, mean, q25, q50, q75, skewness, std
 
 logger = logging.getLogger(__name__)
 
 """Functions & Classes"""
+
+
 def verify_non_leakage(
     x: torch.Tensor,
     dim: Optional[Union[int, Tuple[int, ...]]] = None,
@@ -56,9 +70,9 @@ def verify_non_leakage(
     x_first = x[:1]
     described_first, _ = describe(x_first, dim=dim)
 
-    assert (
-        described_first.shape == described[:1].shape
-    ), f"Shape mismatch: {described_first.shape} != {described[:1].shape}"
+    assert described_first.shape == described[:1].shape, (
+        f"Shape mismatch: {described_first.shape} != {described[:1].shape}"
+    )
 
     torch.testing.assert_close(
         described_first,

scitex/stats/descriptive/_nan.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -43,6 +44,8 @@ from scitex.decorators import batch_fn, torch_fn
 logger = logging.getLogger(__name__)
 
 """Functions & Classes"""
+
+
 @torch_fn
 @batch_fn
 def nanmax(x, axis=-1, dim=None, batch_size=None, keepdims=False):
@@ -155,10 +158,7 @@ def nanzscore(x, axis=-1, dim=None, batch_size=None, keepdims=True):
 @batch_fn
 def nankurtosis(x, axis=-1, dim=None, batch_size=None, keepdims=False):
     zscores = nanzscore(x, axis=axis, keepdims=True)
-    return (
-        torch.nanmean(torch.pow(zscores, 4.0), dim=dim, keepdims=keepdims)
-        - 3.0
-    )
+    return torch.nanmean(torch.pow(zscores, 4.0), dim=dim, keepdims=keepdims) - 3.0
 
 
 @torch_fn
@@ -239,9 +239,7 @@ def nanquantile(x, q, axis=-1, dim=None, batch_size=None, keepdims=False):
         dim_list = [d if d >= 0 else len(original_shape) + d for d in dim_list]
 
         # Determine which dimensions to keep
-        keep_dims = [
-            i for i in range(len(original_shape)) if i not in dim_list
-        ]
+        keep_dims = [i for i in range(len(original_shape)) if i not in dim_list]
 
         # Permute tensor to move dims to reduce to the end
         perm_dims = keep_dims + dim_list

scitex/stats/descriptive/_real.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -43,6 +44,8 @@ from scitex.decorators import torch_fn
 logger = logging.getLogger(__name__)
 
 """Functions & Classes"""
+
+
 @torch_fn
 def mean(x, axis=-1, dim=None, keepdims=False):
     return x.mean(dim, keepdims=keepdims)
@@ -75,9 +78,7 @@ def skewness(x, axis=-1, dim=None, keepdims=False):
 @torch_fn
 def kurtosis(x, axis=-1, dim=None, keepdims=False):
     zscores = zscore(x, axis=axis, keepdims=True)
-    return (
-        torch.mean(torch.pow(zscores, 4.0), dim=dim, keepdims=keepdims) - 3.0
-    )
+    return torch.mean(torch.pow(zscores, 4.0), dim=dim, keepdims=keepdims) - 3.0
 
 
 @torch_fn

scitex/stats/effect_sizes/__init__.py

@@ -26,16 +26,15 @@ from ._epsilon_squared import epsilon_squared, interpret_epsilon_squared
 
 __all__ = [
     # Parametric
-    'cohens_d',
-    'interpret_cohens_d',
-    'eta_squared',
-    'interpret_eta_squared',
-
+    "cohens_d",
+    "interpret_cohens_d",
+    "eta_squared",
+    "interpret_eta_squared",
     # Non-parametric
-    'cliffs_delta',
-    'interpret_cliffs_delta',
-    'prob_superiority',
-    'interpret_prob_superiority',
-    'epsilon_squared',
-    'interpret_epsilon_squared',
+    "cliffs_delta",
+    "interpret_cliffs_delta",
+    "prob_superiority",
+    "interpret_prob_superiority",
+    "epsilon_squared",
+    "interpret_epsilon_squared",
 ]

scitex/stats/effect_sizes/_cliffs_delta.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -39,8 +40,7 @@ logger = getLogger(__name__)
 
 
 def cliffs_delta(
-    x: Union[np.ndarray, pd.Series],
-    y: Union[np.ndarray, pd.Series]
+    x: Union[np.ndarray, pd.Series], y: Union[np.ndarray, pd.Series]
 ) -> float:
     """
     Compute Cliff's delta non-parametric effect size.
@@ -168,13 +168,13 @@ def interpret_cliffs_delta(delta: float) -> str:
     delta_abs = abs(delta)
 
     if delta_abs < 0.147:
-        return 'negligible'
+        return "negligible"
     elif delta_abs < 0.33:
-        return 'small'
+        return "small"
     elif delta_abs < 0.474:
-        return 'medium'
+        return "medium"
     else:
-        return 'large'
+        return "large"
 
 
 """Main function"""
@@ -211,11 +211,16 @@ def main(args):
     delta_outlier = cliffs_delta(x_outlier, y_outlier)
 
     from ._cohens_d import cohens_d
+
     d_normal = cohens_d(x_normal, y_normal)
     d_outlier = cohens_d(x_outlier, y_outlier)
 
-    logger.info(f"Without outlier: Cliff's δ = {delta_normal:.3f}, Cohen's d = {d_normal:.3f}")
-    logger.info(f"With outlier:    Cliff's δ = {delta_outlier:.3f}, Cohen's d = {d_outlier:.3f}")
+    logger.info(
+        f"Without outlier: Cliff's δ = {delta_normal:.3f}, Cohen's d = {d_normal:.3f}"
+    )
+    logger.info(
+        f"With outlier:    Cliff's δ = {delta_outlier:.3f}, Cohen's d = {d_outlier:.3f}"
+    )
     logger.info("Cliff's delta is stable, Cohen's d is inflated by outlier")
 
     # Example 3: Different effect sizes
@@ -228,9 +233,7 @@ def main(args):
         delta = cliffs_delta(control, treatment)
         interpretation = interpret_cliffs_delta(delta)
 
-        logger.info(
-            f"Shift = {shift:.1f}: δ = {delta:.3f} ({interpretation})"
-        )
+        logger.info(f"Shift = {shift:.1f}: δ = {delta:.3f} ({interpretation})")
 
     # Visualization
     logger.info("\n=== Creating visualization ===")
@@ -242,12 +245,12 @@ def main(args):
     x_demo = np.random.exponential(2, 200)
     y_demo = np.random.exponential(3, 200)
 
-    ax.hist(x_demo, bins=30, alpha=0.5, label='Group X', density=True)
-    ax.hist(y_demo, bins=30, alpha=0.5, label='Group Y', density=True)
+    ax.hist(x_demo, bins=30, alpha=0.5, label="Group X", density=True)
+    ax.hist(y_demo, bins=30, alpha=0.5, label="Group Y", density=True)
 
     delta_demo = cliffs_delta(x_demo, y_demo)
-    ax.set_xlabel('Value')
-    ax.set_ylabel('Density')
+    ax.set_xlabel("Value")
+    ax.set_ylabel("Density")
     ax.set_title(f"Distributions (Cliff's δ = {delta_demo:.2f})")
     ax.legend()
 
@@ -256,24 +259,28 @@ def main(args):
     delta_values = np.linspace(-1, 1, 100)
     interpretations = [interpret_cliffs_delta(d) for d in delta_values]
 
-    color_map = {'negligible': 'lightgray', 'small': 'yellow',
-                 'medium': 'orange', 'large': 'red'}
+    color_map = {
+        "negligible": "lightgray",
+        "small": "yellow",
+        "medium": "orange",
+        "large": "red",
+    }
     colors = [color_map[i] for i in interpretations]
 
     ax.scatter(delta_values, [0] * len(delta_values), c=colors, s=50, alpha=0.7)
     ax.set_xlabel("Cliff's δ")
     ax.set_yticks([])
-    ax.set_title('Effect Size Interpretation')
-    ax.axvline(0, color='black', linestyle='-', alpha=0.3)
-    ax.axvline(0.147, color='black', linestyle='--', alpha=0.3)
-    ax.axvline(0.33, color='black', linestyle='--', alpha=0.3)
-    ax.axvline(0.474, color='black', linestyle='--', alpha=0.3)
-    ax.axvline(-0.147, color='black', linestyle='--', alpha=0.3)
-    ax.axvline(-0.33, color='black', linestyle='--', alpha=0.3)
-    ax.axvline(-0.474, color='black', linestyle='--', alpha=0.3)
+    ax.set_title("Effect Size Interpretation")
+    ax.axvline(0, color="black", linestyle="-", alpha=0.3)
+    ax.axvline(0.147, color="black", linestyle="--", alpha=0.3)
+    ax.axvline(0.33, color="black", linestyle="--", alpha=0.3)
+    ax.axvline(0.474, color="black", linestyle="--", alpha=0.3)
+    ax.axvline(-0.147, color="black", linestyle="--", alpha=0.3)
+    ax.axvline(-0.33, color="black", linestyle="--", alpha=0.3)
+    ax.axvline(-0.474, color="black", linestyle="--", alpha=0.3)
 
     stx.plt.tight_layout()
-    stx.io.save(fig, './cliffs_delta_demo.jpg')
+    stx.io.save(fig, "./cliffs_delta_demo.jpg")
     logger.info("Visualization saved")
 
     return 0
@@ -284,11 +291,7 @@ def parse_args():
     parser = argparse.ArgumentParser(
         description="Demonstrate Cliff's delta effect size calculation"
     )
-    parser.add_argument(
-        '--verbose',
-        action='store_true',
-        help='Enable verbose output'
-    )
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
     return parser.parse_args()
 
 
@@ -319,7 +322,7 @@ def run_main():
     )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run_main()
 
 # EOF

scitex/stats/effect_sizes/_cohens_d.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -42,7 +43,7 @@ def cohens_d(
     x: Union[np.ndarray, pd.Series],
     y: Optional[Union[np.ndarray, pd.Series]] = None,
     paired: bool = False,
-    correction: Literal['hedges', 'glass', None] = None
+    correction: Literal["hedges", "glass", None] = None,
 ) -> float:
     """
     Compute Cohen's d effect size.
@@ -136,7 +137,7 @@ def cohens_d(
         n1, n2 = len(x), len(y)
         mean_diff = np.mean(x) - np.mean(y)
 
-        if correction == 'glass':
+        if correction == "glass":
             # Glass's delta: use only control group (y) SD
             d = mean_diff / np.std(y, ddof=1)
         else:
@@ -147,7 +148,7 @@ def cohens_d(
             d = mean_diff / pooled_std
 
         # Apply Hedges' correction for small samples
-        if correction == 'hedges':
+        if correction == "hedges":
             # Hedges' g correction factor
             correction_factor = 1 - (3 / (4 * (n1 + n2) - 9))
             d = d * correction_factor
@@ -181,13 +182,13 @@ def interpret_cohens_d(d: float) -> str:
     d_abs = abs(d)
 
     if d_abs < 0.2:
-        return 'negligible'
+        return "negligible"
     elif d_abs < 0.5:
-        return 'small'
+        return "small"
     elif d_abs < 0.8:
-        return 'medium'
+        return "medium"
     else:
-        return 'large'
+        return "large"
 
 
 """Main function"""
@@ -220,11 +221,13 @@ def main(args):
             f"Interpretation: {interpretation}"
         )
 
-        results.append({
-            'true_d': true_d,
-            'computed_d': computed_d,
-            'interpretation': interpretation
-        })
+        results.append(
+            {
+                "true_d": true_d,
+                "computed_d": computed_d,
+                "interpretation": interpretation,
+            }
+        )
 
     # Example 2: Paired vs independent
     logger.info("\n=== Example 2: Paired vs Independent ===")
@@ -249,8 +252,8 @@ def main(args):
     y_small = np.random.normal(0.5, 1, small_n)
 
     d_standard = cohens_d(x_small, y_small)
-    d_hedges = cohens_d(x_small, y_small, correction='hedges')
-    d_glass = cohens_d(x_small, y_small, correction='glass')
+    d_hedges = cohens_d(x_small, y_small, correction="hedges")
+    d_glass = cohens_d(x_small, y_small, correction="glass")
 
     logger.info(f"Standard Cohen's d = {d_standard:.3f}")
     logger.info(f"Hedges' g = {d_hedges:.3f} (corrected for small n)")
@@ -266,31 +269,31 @@ def main(args):
     control_demo = np.random.normal(0, 1, 1000)
     treatment_demo = np.random.normal(0.8, 1, 1000)
 
-    ax.hist(control_demo, bins=30, alpha=0.5, label='Control', density=True)
-    ax.hist(treatment_demo, bins=30, alpha=0.5, label='Treatment', density=True)
+    ax.hist(control_demo, bins=30, alpha=0.5, label="Control", density=True)
+    ax.hist(treatment_demo, bins=30, alpha=0.5, label="Treatment", density=True)
 
     d_demo = cohens_d(control_demo, treatment_demo)
-    ax.axvline(np.mean(control_demo), color='blue', linestyle='--', alpha=0.7)
-    ax.axvline(np.mean(treatment_demo), color='orange', linestyle='--', alpha=0.7)
+    ax.axvline(np.mean(control_demo), color="blue", linestyle="--", alpha=0.7)
+    ax.axvline(np.mean(treatment_demo), color="orange", linestyle="--", alpha=0.7)
 
-    ax.set_xlabel('Value')
-    ax.set_ylabel('Density')
+    ax.set_xlabel("Value")
+    ax.set_ylabel("Density")
     ax.set_title(f"Distributions (Cohen's d = {d_demo:.2f})")
     ax.legend()
 
     # Plot 2: Effect size comparison
     ax = axes[1]
     df_results = pd.DataFrame(results)
-    ax.scatter(df_results['true_d'], df_results['computed_d'], s=100)
-    ax.plot([-0.5, 1.5], [-0.5, 1.5], 'k--', alpha=0.5, label='Perfect agreement')
-    ax.set_xlabel('True Effect Size')
+    ax.scatter(df_results["true_d"], df_results["computed_d"], s=100)
+    ax.plot([-0.5, 1.5], [-0.5, 1.5], "k--", alpha=0.5, label="Perfect agreement")
+    ax.set_xlabel("True Effect Size")
     ax.set_ylabel("Computed Cohen's d")
-    ax.set_title('True vs Computed Effect Sizes')
+    ax.set_title("True vs Computed Effect Sizes")
     ax.legend()
     ax.grid(True, alpha=0.3)
 
     stx.plt.tight_layout()
-    stx.io.save(fig, './cohens_d_demo.jpg')
+    stx.io.save(fig, "./cohens_d_demo.jpg")
     logger.info("Visualization saved")
 
     return 0
@@ -301,11 +304,7 @@ def parse_args():
     parser = argparse.ArgumentParser(
         description="Demonstrate Cohen's d effect size calculation"
     )
-    parser.add_argument(
-        '--verbose',
-        action='store_true',
-        help='Enable verbose output'
-    )
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
     return parser.parse_args()
 
 
@@ -336,7 +335,7 @@ def run_main():
     )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run_main()
 
 # EOF