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

scitex/stats/posthoc/_dunnett.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -33,8 +34,9 @@ from scitex.stats.utils._formatters import p2stars
 from scitex.stats.utils._normalizers import convert_results
 
 
-def dunnett_critical_value(k: int, df: int, alpha: float = 0.05,
-                          alternative: str = 'two-sided') -> float:
+def dunnett_critical_value(
+    k: int, df: int, alpha: float = 0.05, alternative: str = "two-sided"
+) -> float:
     """
     Get critical value for Dunnett's test.
 
@@ -61,7 +63,7 @@ def dunnett_critical_value(k: int, df: int, alpha: float = 0.05,
     or software (R, SAS) would be needed.
     """
     # Conservative approximation using Bonferroni adjustment
-    if alternative == 'two-sided':
+    if alternative == "two-sided":
         alpha_adj = alpha / (2 * k)
     else:
         alpha_adj = alpha / k
@@ -79,10 +81,10 @@ def posthoc_dunnett(
     control: Union[np.ndarray, pd.Series],
     treatments: List[Union[np.ndarray, pd.Series]],
     treatment_names: Optional[List[str]] = None,
-    control_name: str = 'Control',
+    control_name: str = "Control",
     alpha: float = 0.05,
-    alternative: Literal['two-sided', 'less', 'greater'] = 'two-sided',
-    return_as: str = 'dataframe'
+    alternative: Literal["two-sided", "less", "greater"] = "two-sided",
+    return_as: str = "dataframe",
 ) -> Union[pd.DataFrame, List[dict]]:
     """
     Perform Dunnett's test for comparing treatments vs control.
@@ -214,7 +216,7 @@ def posthoc_dunnett(
 
     # Treatment names
     if treatment_names is None:
-        treatment_names = [f'Treatment {i+1}' for i in range(k)]
+        treatment_names = [f"Treatment {i + 1}" for i in range(k)]
 
     if len(treatment_names) != k:
         raise ValueError(f"Expected {k} treatment names, got {len(treatment_names)}")
@@ -243,12 +245,14 @@ def posthoc_dunnett(
     # Perform comparisons vs control
     results = []
 
-    for i, (treatment, n_t, mean_t) in enumerate(zip(treatments, n_treatments, means_treatments)):
+    for i, (treatment, n_t, mean_t) in enumerate(
+        zip(treatments, n_treatments, means_treatments)
+    ):
         # Mean difference
         mean_diff = mean_t - mean_control
 
         # Standard error
-        se = np.sqrt(ms_error * (1/n_t + 1/n_control))
+        se = np.sqrt(ms_error * (1 / n_t + 1 / n_control))
 
         # t-statistic
         if se == 0:
@@ -257,9 +261,9 @@ def posthoc_dunnett(
             t_stat = mean_diff / se
 
         # p-value (conservative approximation)
-        if alternative == 'two-sided':
+        if alternative == "two-sided":
             pvalue = 2 * (1 - stats.t.cdf(abs(t_stat), df_error))
-        elif alternative == 'greater':
+        elif alternative == "greater":
             pvalue = 1 - stats.t.cdf(t_stat, df_error)
         else:  # less
             pvalue = stats.t.cdf(t_stat, df_error)
@@ -268,47 +272,53 @@ def posthoc_dunnett(
         pvalue = min(pvalue * k, 1.0)
 
         # Determine significance
-        if alternative == 'two-sided':
+        if alternative == "two-sided":
             significant = abs(t_stat) > d_crit
-        elif alternative == 'greater':
+        elif alternative == "greater":
             significant = t_stat > d_crit
         else:  # less
             significant = t_stat < -d_crit
 
         # Confidence interval
         margin = d_crit * se
-        if alternative == 'two-sided':
+        if alternative == "two-sided":
             ci_lower = mean_diff - margin
             ci_upper = mean_diff + margin
-        elif alternative == 'greater':
+        elif alternative == "greater":
             ci_lower = mean_diff - margin
             ci_upper = np.inf
         else:  # less
             ci_lower = -np.inf
             ci_upper = mean_diff + margin
 
-        results.append({
-            'treatment': treatment_names[i],
-            'control': control_name,
-            'n_treatment': n_t,
-            'n_control': n_control,
-            'mean_treatment': round(float(mean_t), 3),
-            'mean_control': round(float(mean_control), 3),
-            'mean_diff': round(float(mean_diff), 3),
-            'std_error': round(float(se), 3),
-            't_statistic': round(float(t_stat), 3),
-            'd_critical': round(float(d_crit), 3),
-            'pvalue': round(float(pvalue), 4),
-            'significant': bool(significant),
-            'pstars': p2stars(pvalue),
-            'ci_lower': round(float(ci_lower), 3) if not np.isinf(ci_lower) else '-inf',
-            'ci_upper': round(float(ci_upper), 3) if not np.isinf(ci_upper) else 'inf',
-            'alpha': alpha,
-            'alternative': alternative,
-        })
+        results.append(
+            {
+                "treatment": treatment_names[i],
+                "control": control_name,
+                "n_treatment": n_t,
+                "n_control": n_control,
+                "mean_treatment": round(float(mean_t), 3),
+                "mean_control": round(float(mean_control), 3),
+                "mean_diff": round(float(mean_diff), 3),
+                "std_error": round(float(se), 3),
+                "t_statistic": round(float(t_stat), 3),
+                "d_critical": round(float(d_crit), 3),
+                "pvalue": round(float(pvalue), 4),
+                "significant": bool(significant),
+                "pstars": p2stars(pvalue),
+                "ci_lower": round(float(ci_lower), 3)
+                if not np.isinf(ci_lower)
+                else "-inf",
+                "ci_upper": round(float(ci_upper), 3)
+                if not np.isinf(ci_upper)
+                else "inf",
+                "alpha": alpha,
+                "alternative": alternative,
+            }
+        )
 
     # Return format
-    if return_as == 'dataframe':
+    if return_as == "dataframe":
         return pd.DataFrame(results)
     else:
         return results
@@ -355,11 +365,13 @@ if __name__ == "__main__":
     results = posthoc_dunnett(
         control=placebo,
         treatments=[dose_low, dose_med, dose_high],
-        treatment_names=['Low Dose', 'Med Dose', 'High Dose'],
-        control_name='Placebo'
+        treatment_names=["Low Dose", "Med Dose", "High Dose"],
+        control_name="Placebo",
     )
 
-    logger.info(f"\n{results[['treatment', 'mean_diff', 't_statistic', 'pvalue', 'significant']].to_string()}")
+    logger.info(
+        f"\n{results[['treatment', 'mean_diff', 't_statistic', 'pvalue', 'significant']].to_string()}"
+    )
 
     # Example 2: One-sided test (treatments > control)
     logger.info("\n[Example 2] One-sided test (greater than control)")
@@ -368,12 +380,14 @@ if __name__ == "__main__":
     results_greater = posthoc_dunnett(
         control=placebo,
         treatments=[dose_low, dose_med, dose_high],
-        treatment_names=['Low Dose', 'Med Dose', 'High Dose'],
-        control_name='Placebo',
-        alternative='greater'
+        treatment_names=["Low Dose", "Med Dose", "High Dose"],
+        control_name="Placebo",
+        alternative="greater",
     )
 
-    logger.info(f"\n{results_greater[['treatment', 'mean_diff', 'pvalue', 'significant']].to_string()}")
+    logger.info(
+        f"\n{results_greater[['treatment', 'mean_diff', 'pvalue', 'significant']].to_string()}"
+    )
 
     # Example 3: Baseline comparison
     logger.info("\n[Example 3] Baseline vs interventions")
@@ -386,8 +400,8 @@ if __name__ == "__main__":
     results_baseline = posthoc_dunnett(
         control=baseline,
         treatments=[intervention_a, intervention_b],
-        treatment_names=['Intervention A', 'Intervention B'],
-        control_name='Baseline'
+        treatment_names=["Intervention A", "Intervention B"],
+        control_name="Baseline",
     )
 
     logger.info(f"\n{results_baseline.to_string()}")
@@ -400,21 +414,23 @@ if __name__ == "__main__":
 
     # All groups for Tukey
     all_groups = [placebo, dose_low, dose_med, dose_high]
-    group_names = ['Placebo', 'Low Dose', 'Med Dose', 'High Dose']
+    group_names = ["Placebo", "Low Dose", "Med Dose", "High Dose"]
 
     results_tukey = posthoc_tukey(all_groups, group_names)
 
     # Filter Tukey results for comparisons vs placebo
     tukey_vs_placebo = results_tukey[
-        (results_tukey['group_i'] == 'Placebo') |
-        (results_tukey['group_j'] == 'Placebo')
+        (results_tukey["group_i"] == "Placebo")
+        | (results_tukey["group_j"] == "Placebo")
     ]
 
     logger.info("\nDunnett's test (designed for control comparisons):")
     logger.info(f"{results[['treatment', 'pvalue', 'significant']].to_string()}")
 
     logger.info("\nTukey HSD (all pairwise, less power for control comparisons):")
-    logger.info(f"{tukey_vs_placebo[['group_i', 'group_j', 'pvalue', 'significant']].to_string()}")
+    logger.info(
+        f"{tukey_vs_placebo[['group_i', 'group_j', 'pvalue', 'significant']].to_string()}"
+    )
 
     logger.info("\nNote: Dunnett is more powerful for control comparisons")
 
@@ -430,11 +446,13 @@ if __name__ == "__main__":
     results_unbal = posthoc_dunnett(
         control=control_unbal,
         treatments=[treat1_unbal, treat2_unbal, treat3_unbal],
-        treatment_names=['T1', 'T2', 'T3']
+        treatment_names=["T1", "T2", "T3"],
     )
 
-    logger.info(f"Sample sizes: Control={len(control_unbal)}, T1={len(treat1_unbal)}, "
-               f"T2={len(treat2_unbal)}, T3={len(treat3_unbal)}")
+    logger.info(
+        f"Sample sizes: Control={len(control_unbal)}, T1={len(treat1_unbal)}, "
+        f"T2={len(treat2_unbal)}, T3={len(treat3_unbal)}"
+    )
     logger.info(f"\n{results_unbal.to_string()}")
 
     # Example 6: With confidence intervals
@@ -442,15 +460,17 @@ if __name__ == "__main__":
     logger.info("-" * 70)
 
     for _, row in results.iterrows():
-        logger.info(f"{row['treatment']} vs {row['control']}: "
-                   f"Diff = {row['mean_diff']:.2f}, "
-                   f"95% CI [{row['ci_lower']}, {row['ci_upper']}] {row['pstars']}")
+        logger.info(
+            f"{row['treatment']} vs {row['control']}: "
+            f"Diff = {row['mean_diff']:.2f}, "
+            f"95% CI [{row['ci_lower']}, {row['ci_upper']}] {row['pstars']}"
+        )
 
     # Example 7: Export results
     logger.info("\n[Example 7] Export results")
     logger.info("-" * 70)
 
-    convert_results(results, return_as='excel', path='./dunnett_results.xlsx')
+    convert_results(results, return_as="excel", path="./dunnett_results.xlsx")
     logger.info("Saved to: ./dunnett_results.xlsx")
 
     stx.session.close(

scitex/stats/posthoc/_games_howell.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -62,7 +63,7 @@ def welch_satterthwaite_df(var_i: float, n_i: int, var_j: float, n_j: int) -> fl
     s_j_sq_n_j = var_j / n_j
 
     numerator = (s_i_sq_n_i + s_j_sq_n_j) ** 2
-    denominator = (s_i_sq_n_i ** 2) / (n_i - 1) + (s_j_sq_n_j ** 2) / (n_j - 1)
+    denominator = (s_i_sq_n_i**2) / (n_i - 1) + (s_j_sq_n_j**2) / (n_j - 1)
 
     if denominator == 0:
         return n_i + n_j - 2
@@ -75,7 +76,7 @@ def posthoc_games_howell(
     groups: List[Union[np.ndarray, pd.Series]],
     group_names: Optional[List[str]] = None,
     alpha: float = 0.05,
-    return_as: str = 'dataframe'
+    return_as: str = "dataframe",
 ) -> Union[pd.DataFrame, List[dict]]:
     """
     Perform Games-Howell post-hoc test for pairwise comparisons.
@@ -191,7 +192,7 @@ def posthoc_games_howell(
 
     # Group names
     if group_names is None:
-        group_names = [f'Group {i+1}' for i in range(k)]
+        group_names = [f"Group {i + 1}" for i in range(k)]
 
     if len(group_names) != k:
         raise ValueError(f"Expected {k} group names, got {len(group_names)}")
@@ -244,29 +245,31 @@ def posthoc_games_howell(
             ci_lower = mean_diff - margin
             ci_upper = mean_diff + margin
 
-            results.append({
-                'group_i': group_names[i],
-                'group_j': group_names[j],
-                'n_i': n_i,
-                'n_j': n_j,
-                'mean_i': round(float(mean_i), 3),
-                'mean_j': round(float(mean_j), 3),
-                'var_i': round(float(var_i), 3),
-                'var_j': round(float(var_j), 3),
-                'mean_diff': round(float(mean_diff), 3),
-                'std_error': round(float(se), 3),
-                't_statistic': round(float(t_stat), 3),
-                'df': round(float(df), 2),
-                'pvalue': round(float(pvalue), 4),
-                'significant': bool(significant),
-                'pstars': p2stars(pvalue),
-                'ci_lower': round(float(ci_lower), 3),
-                'ci_upper': round(float(ci_upper), 3),
-                'alpha': alpha,
-            })
+            results.append(
+                {
+                    "group_i": group_names[i],
+                    "group_j": group_names[j],
+                    "n_i": n_i,
+                    "n_j": n_j,
+                    "mean_i": round(float(mean_i), 3),
+                    "mean_j": round(float(mean_j), 3),
+                    "var_i": round(float(var_i), 3),
+                    "var_j": round(float(var_j), 3),
+                    "mean_diff": round(float(mean_diff), 3),
+                    "std_error": round(float(se), 3),
+                    "t_statistic": round(float(t_stat), 3),
+                    "df": round(float(df), 2),
+                    "pvalue": round(float(pvalue), 4),
+                    "significant": bool(significant),
+                    "pstars": p2stars(pvalue),
+                    "ci_lower": round(float(ci_lower), 3),
+                    "ci_upper": round(float(ci_upper), 3),
+                    "alpha": alpha,
+                }
+            )
 
     # Return format
-    if return_as == 'dataframe':
+    if return_as == "dataframe":
         return pd.DataFrame(results)
     else:
         return results
@@ -300,20 +303,27 @@ if __name__ == "__main__":
     logger.info("-" * 70)
 
     np.random.seed(42)
-    group1 = np.random.normal(10, 1, 20)   # Small variance
-    group2 = np.random.normal(12, 5, 25)   # Large variance
-    group3 = np.random.normal(11, 2, 15)   # Medium variance
+    group1 = np.random.normal(10, 1, 20)  # Small variance
+    group2 = np.random.normal(12, 5, 25)  # Large variance
+    group3 = np.random.normal(11, 2, 15)  # Medium variance
 
-    logger.info(f"Group 1: mean={np.mean(group1):.2f}, var={np.var(group1, ddof=1):.2f}, n={len(group1)}")
-    logger.info(f"Group 2: mean={np.mean(group2):.2f}, var={np.var(group2, ddof=1):.2f}, n={len(group2)}")
-    logger.info(f"Group 3: mean={np.mean(group3):.2f}, var={np.var(group3, ddof=1):.2f}, n={len(group3)}")
+    logger.info(
+        f"Group 1: mean={np.mean(group1):.2f}, var={np.var(group1, ddof=1):.2f}, n={len(group1)}"
+    )
+    logger.info(
+        f"Group 2: mean={np.mean(group2):.2f}, var={np.var(group2, ddof=1):.2f}, n={len(group2)}"
+    )
+    logger.info(
+        f"Group 3: mean={np.mean(group3):.2f}, var={np.var(group3, ddof=1):.2f}, n={len(group3)}"
+    )
 
     results = posthoc_games_howell(
-        [group1, group2, group3],
-        group_names=['Low Var', 'High Var', 'Med Var']
+        [group1, group2, group3], group_names=["Low Var", "High Var", "Med Var"]
     )
 
-    logger.info(f"\n{results[['group_i', 'group_j', 'mean_diff', 'df', 'pvalue', 'significant']].to_string()}")
+    logger.info(
+        f"\n{results[['group_i', 'group_j', 'mean_diff', 'df', 'pvalue', 'significant']].to_string()}"
+    )
 
     # Example 2: Comparison with Tukey HSD
     logger.info("\n[Example 2] Games-Howell vs Tukey HSD")
@@ -325,10 +335,14 @@ if __name__ == "__main__":
     results_tukey = posthoc_tukey([group1, group2, group3])
 
     logger.info("\nGames-Howell results:")
-    logger.info(f"{results_gh[['group_i', 'group_j', 'pvalue', 'significant']].to_string()}")
+    logger.info(
+        f"{results_gh[['group_i', 'group_j', 'pvalue', 'significant']].to_string()}"
+    )
 
     logger.info("\nTukey HSD results:")
-    logger.info(f"{results_tukey[['group_i', 'group_j', 'pvalue', 'significant']].to_string()}")
+    logger.info(
+        f"{results_tukey[['group_i', 'group_j', 'pvalue', 'significant']].to_string()}"
+    )
 
     logger.info("\nNote: Games-Howell is more appropriate with unequal variances")
 
@@ -340,24 +354,28 @@ if __name__ == "__main__":
 
     anova_result = test_anova(
         [group1, group2, group3],
-        var_names=['Low Var', 'High Var', 'Med Var'],
-        check_assumptions=True
+        var_names=["Low Var", "High Var", "Med Var"],
+        check_assumptions=True,
     )
 
-    logger.info(f"ANOVA: F = {anova_result['statistic']:.3f}, p = {anova_result['pvalue']:.4f}")
+    logger.info(
+        f"ANOVA: F = {anova_result['statistic']:.3f}, p = {anova_result['pvalue']:.4f}"
+    )
     logger.info(f"Assumptions met: {anova_result.get('assumptions_met', 'N/A')}")
 
-    is_sig = anova_result.get('significant', anova_result.get('is_significant', False))
+    is_sig = anova_result.get("significant", anova_result.get("is_significant", False))
     if is_sig:
-        logger.info("\nANOVA significant. Using Games-Howell (robust to unequal variances)...")
+        logger.info(
+            "\nANOVA significant. Using Games-Howell (robust to unequal variances)..."
+        )
         logger.info(f"\n{results.to_string()}")
 
     # Example 4: Extreme variance ratios
     logger.info("\n[Example 4] Extreme variance heterogeneity")
     logger.info("-" * 70)
 
-    extreme1 = np.random.normal(50, 1, 20)    # Very small variance
-    extreme2 = np.random.normal(55, 10, 20)   # Very large variance
+    extreme1 = np.random.normal(50, 1, 20)  # Very small variance
+    extreme2 = np.random.normal(55, 10, 20)  # Very large variance
 
     var_ratio = np.var(extreme2, ddof=1) / np.var(extreme1, ddof=1)
     logger.info(f"Variance ratio: {var_ratio:.1f}")
@@ -370,7 +388,7 @@ if __name__ == "__main__":
     logger.info("\n[Example 5] Export results")
     logger.info("-" * 70)
 
-    convert_results(results, return_as='excel', path='./games_howell_results.xlsx')
+    convert_results(results, return_as="excel", path="./games_howell_results.xlsx")
     logger.info("Saved to: ./games_howell_results.xlsx")
 
     stx.session.close(

scitex/stats/posthoc/_tukey_hsd.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -76,7 +77,7 @@ def posthoc_tukey(
     groups: List[Union[np.ndarray, pd.Series]],
     group_names: Optional[List[str]] = None,
     alpha: float = 0.05,
-    return_as: str = 'dataframe'
+    return_as: str = "dataframe",
 ) -> Union[pd.DataFrame, List[dict]]:
     """
     Perform Tukey HSD post-hoc test for pairwise comparisons.
@@ -189,7 +190,7 @@ def posthoc_tukey(
 
     # Group names
     if group_names is None:
-        group_names = [f'Group {i+1}' for i in range(k)]
+        group_names = [f"Group {i + 1}" for i in range(k)]
 
     if len(group_names) != k:
         raise ValueError(f"Expected {k} group names, got {len(group_names)}")
@@ -226,7 +227,7 @@ def posthoc_tukey(
             mean_diff = mean_i - mean_j
 
             # Standard error for unequal sample sizes (Tukey-Kramer)
-            se = np.sqrt(ms_error * (1/n_i + 1/n_j) / 2)
+            se = np.sqrt(ms_error * (1 / n_i + 1 / n_j) / 2)
 
             # Studentized range statistic
             q_stat = abs(mean_diff) / se
@@ -245,27 +246,29 @@ def posthoc_tukey(
             ci_lower = mean_diff - margin
             ci_upper = mean_diff + margin
 
-            results.append({
-                'group_i': group_names[i],
-                'group_j': group_names[j],
-                'n_i': n_i,
-                'n_j': n_j,
-                'mean_i': round(float(mean_i), 3),
-                'mean_j': round(float(mean_j), 3),
-                'mean_diff': round(float(mean_diff), 3),
-                'std_error': round(float(se), 3),
-                'q_statistic': round(float(q_stat), 3),
-                'q_critical': round(float(q_crit), 3),
-                'pvalue': round(float(pvalue), 4),
-                'significant': bool(significant),
-                'pstars': p2stars(pvalue),
-                'ci_lower': round(float(ci_lower), 3),
-                'ci_upper': round(float(ci_upper), 3),
-                'alpha': alpha,
-            })
+            results.append(
+                {
+                    "group_i": group_names[i],
+                    "group_j": group_names[j],
+                    "n_i": n_i,
+                    "n_j": n_j,
+                    "mean_i": round(float(mean_i), 3),
+                    "mean_j": round(float(mean_j), 3),
+                    "mean_diff": round(float(mean_diff), 3),
+                    "std_error": round(float(se), 3),
+                    "q_statistic": round(float(q_stat), 3),
+                    "q_critical": round(float(q_crit), 3),
+                    "pvalue": round(float(pvalue), 4),
+                    "significant": bool(significant),
+                    "pstars": p2stars(pvalue),
+                    "ci_lower": round(float(ci_lower), 3),
+                    "ci_upper": round(float(ci_upper), 3),
+                    "alpha": alpha,
+                }
+            )
 
     # Return format
-    if return_as == 'dataframe':
+    if return_as == "dataframe":
         return pd.DataFrame(results)
     else:
         return results
@@ -309,20 +312,24 @@ if __name__ == "__main__":
 
     anova_result = test_anova(
         [control, treatment1, treatment2, treatment3],
-        var_names=['Control', 'Treat1', 'Treat2', 'Treat3']
+        var_names=["Control", "Treat1", "Treat2", "Treat3"],
     )
 
-    logger.info(f"ANOVA: F = {anova_result['statistic']:.3f}, p = {anova_result['pvalue']:.4f}")
+    logger.info(
+        f"ANOVA: F = {anova_result['statistic']:.3f}, p = {anova_result['pvalue']:.4f}"
+    )
 
-    if anova_result['significant']:
+    if anova_result["significant"]:
         logger.info("\nANOVA significant, conducting Tukey HSD...")
 
         results = posthoc_tukey(
             [control, treatment1, treatment2, treatment3],
-            group_names=['Control', 'Treat1', 'Treat2', 'Treat3']
+            group_names=["Control", "Treat1", "Treat2", "Treat3"],
         )
 
-        logger.info(f"\n{results[['group_i', 'group_j', 'mean_diff', 'pvalue', 'significant']].to_string()}")
+        logger.info(
+            f"\n{results[['group_i', 'group_j', 'mean_diff', 'pvalue', 'significant']].to_string()}"
+        )
 
     # Example 2: Unbalanced design (Tukey-Kramer)
     logger.info("\n[Example 2] Unbalanced design (different sample sizes)")
@@ -333,8 +340,7 @@ if __name__ == "__main__":
     group_c = np.random.normal(55, 10, 20)
 
     results_unbalanced = posthoc_tukey(
-        [group_a, group_b, group_c],
-        group_names=['A', 'B', 'C']
+        [group_a, group_b, group_c], group_names=["A", "B", "C"]
     )
 
     logger.info(f"Sample sizes: A={len(group_a)}, B={len(group_b)}, C={len(group_c)}")
@@ -345,16 +351,18 @@ if __name__ == "__main__":
     logger.info("-" * 70)
 
     for _, row in results.iterrows():
-        if row['significant']:
-            logger.info(f"{row['group_i']} vs {row['group_j']}: "
-                       f"Diff = {row['mean_diff']:.2f}, "
-                       f"95% CI [{row['ci_lower']:.2f}, {row['ci_upper']:.2f}] {row['pstars']}")
+        if row["significant"]:
+            logger.info(
+                f"{row['group_i']} vs {row['group_j']}: "
+                f"Diff = {row['mean_diff']:.2f}, "
+                f"95% CI [{row['ci_lower']:.2f}, {row['ci_upper']:.2f}] {row['pstars']}"
+            )
 
     # Example 4: Export results
     logger.info("\n[Example 4] Export results")
     logger.info("-" * 70)
 
-    convert_results(results, return_as='excel', path='./tukey_hsd_results.xlsx')
+    convert_results(results, return_as="excel", path="./tukey_hsd_results.xlsx")
     logger.info("Saved to: ./tukey_hsd_results.xlsx")
 
     stx.session.close(

scitex/stats/power/__init__.py

@@ -14,6 +14,6 @@ from ._power import (
 )
 
 __all__ = [
-    'power_ttest',
-    'sample_size_ttest',
+    "power_ttest",
+    "sample_size_ttest",
 ]