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

scitex/stats/utils/_effect_size.py

@@ -30,11 +30,13 @@ from scitex.logging import getLogger
 logger = getLogger(__name__)
 
 """Functions"""
+
+
 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.
@@ -128,7 +130,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:
@@ -139,7 +141,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
@@ -148,8 +150,7 @@ def cohens_d(
 
 
 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.
@@ -250,8 +251,7 @@ def cliffs_delta(
 
 
 def prob_superiority(
-    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 probability of superiority P(X > Y).
@@ -381,13 +381,13 @@ def interpret_prob_superiority(prob: float) -> str:
     distance = abs(prob - 0.5)
 
     if distance < 0.06:
-        return 'negligible'
+        return "negligible"
     elif distance < 0.14:
-        return 'small'
+        return "small"
     elif distance < 0.21:
-        return 'medium'
+        return "medium"
     else:
-        return 'large'
+        return "large"
 
 
 def interpret_cliffs_delta(delta: float) -> str:
@@ -418,19 +418,16 @@ 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"
 
 
-def eta_squared(
-    groups: List[Union[np.ndarray, pd.Series]],
-    ddof: int = 1
-) -> float:
+def eta_squared(groups: List[Union[np.ndarray, pd.Series]], ddof: int = 1) -> float:
     """
     Compute eta-squared (η²) effect size for ANOVA.
 
@@ -549,13 +546,13 @@ def interpret_eta_squared(eta2: float) -> str:
     'large'
     """
     if eta2 < 0.01:
-        return 'negligible'
+        return "negligible"
     elif eta2 < 0.06:
-        return 'small'
+        return "small"
     elif eta2 < 0.14:
-        return 'medium'
+        return "medium"
     else:
-        return 'large'
+        return "large"
 
 
 def epsilon_squared(groups):
@@ -675,13 +672,13 @@ def interpret_epsilon_squared(epsilon2: float) -> str:
     'large'
     """
     if epsilon2 < 0.01:
-        return 'negligible'
+        return "negligible"
     elif epsilon2 < 0.06:
-        return 'small'
+        return "small"
     elif epsilon2 < 0.14:
-        return 'medium'
+        return "medium"
     else:
-        return 'large'
+        return "large"
 
 
 def interpret_cohens_d(d: float) -> str:
@@ -710,16 +707,18 @@ 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"""
+
+
 def main(args):
     """Demonstrate effect size computation (Cohen's d, Cliff's delta, eta-squared)."""
     logger.info("Demonstrating effect size calculations")
@@ -750,11 +749,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 ===")
@@ -780,8 +781,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)")
@@ -816,8 +817,12 @@ def main(args):
     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 6: Eta-squared for ANOVA
@@ -848,7 +853,9 @@ def main(args):
     logger.info(f"Cohen's d:     {d:.3f} ({interpret_cohens_d(d)})")
     logger.info(f"Cliff's delta: {delta:.3f} ({interpret_cliffs_delta(delta)})")
     logger.info(f"P(X > Y):      {prob:.3f} ({interpret_prob_superiority(prob)})")
-    logger.info(f"Eta-squared:   {eta2_groups:.3f} ({interpret_eta_squared(eta2_groups)})")
+    logger.info(
+        f"Eta-squared:   {eta2_groups:.3f} ({interpret_eta_squared(eta2_groups)})"
+    )
 
     # Create visualization
     logger.info("\n=== Creating visualization ===")
@@ -858,11 +865,11 @@ def main(args):
     # Plot 1: Effect size comparison
     ax = axes[0, 0]
     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.set_ylabel('Computed Cohen\'s d')
-    ax.set_title('True vs Computed Effect Sizes')
+    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.legend()
     ax.grid(True, alpha=0.3)
 
@@ -871,16 +878,16 @@ 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_title(f'Distributions (Cohen\'s d = {d_demo:.2f})')
+    ax.set_xlabel("Value")
+    ax.set_ylabel("Density")
+    ax.set_title(f"Distributions (Cohen's d = {d_demo:.2f})")
     ax.legend()
 
     # Plot 3: Effect size interpretation
@@ -889,24 +896,28 @@ def main(args):
     interpretations = [interpret_cohens_d(d) for d in d_values]
 
     # Color map
-    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(d_values, [0] * len(d_values), c=colors, s=50, alpha=0.7)
-    ax.set_xlabel('Cohen\'s d')
+    ax.set_xlabel("Cohen's d")
     ax.set_yticks([])
-    ax.set_title('Effect Size Interpretation')
-    ax.axvline(0, color='black', linestyle='-', alpha=0.3)
-    ax.axvline(0.2, color='black', linestyle='--', alpha=0.3)
-    ax.axvline(0.5, color='black', linestyle='--', alpha=0.3)
-    ax.axvline(0.8, color='black', linestyle='--', alpha=0.3)
+    ax.set_title("Effect Size Interpretation")
+    ax.axvline(0, color="black", linestyle="-", alpha=0.3)
+    ax.axvline(0.2, color="black", linestyle="--", alpha=0.3)
+    ax.axvline(0.5, color="black", linestyle="--", alpha=0.3)
+    ax.axvline(0.8, color="black", linestyle="--", alpha=0.3)
 
     # Add labels
-    ax.text(0.1, 0.5, 'Negligible', ha='center', fontsize=9)
-    ax.text(0.35, 0.5, 'Small', ha='center', fontsize=9)
-    ax.text(0.65, 0.5, 'Medium', ha='center', fontsize=9)
-    ax.text(1.15, 0.5, 'Large', ha='center', fontsize=9)
+    ax.text(0.1, 0.5, "Negligible", ha="center", fontsize=9)
+    ax.text(0.35, 0.5, "Small", ha="center", fontsize=9)
+    ax.text(0.65, 0.5, "Medium", ha="center", fontsize=9)
+    ax.text(1.15, 0.5, "Large", ha="center", fontsize=9)
 
     # Plot 4: Sample size vs precision
     ax = axes[1, 1]
@@ -923,17 +934,17 @@ def main(args):
 
         precisions.append(np.std(ds))
 
-    ax.plot(sample_sizes, precisions, 'o-', linewidth=2)
-    ax.set_xlabel('Sample Size (per group)')
-    ax.set_ylabel('Std Dev of Cohen\'s d')
-    ax.set_title('Effect Size Precision vs Sample Size')
+    ax.plot(sample_sizes, precisions, "o-", linewidth=2)
+    ax.set_xlabel("Sample Size (per group)")
+    ax.set_ylabel("Std Dev of Cohen's d")
+    ax.set_title("Effect Size Precision vs Sample Size")
     ax.grid(True, alpha=0.3)
-    ax.set_xscale('log')
+    ax.set_xscale("log")
 
     plt.tight_layout()
 
     # Save
-    stx.io.save(fig, './cohens_d_demo.jpg')
+    stx.io.save(fig, "./cohens_d_demo.jpg")
     logger.info("Visualization saved")
 
     return 0
@@ -942,13 +953,9 @@ def main(args):
 def parse_args():
     """Parse command line arguments."""
     parser = argparse.ArgumentParser(
-        description='Demonstrate Cohen\'s d effect size calculation'
-    )
-    parser.add_argument(
-        '--verbose',
-        action='store_true',
-        help='Enable verbose output'
+        description="Demonstrate Cohen's d effect size calculation"
     )
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
     return parser.parse_args()
 
 
@@ -979,7 +986,7 @@ def run_main():
     )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run_main()
 
 # EOF

scitex/stats/utils/_formatters.py

@@ -29,11 +29,13 @@ from scitex.logging import getLogger
 logger = getLogger(__name__)
 
 """Functions"""
+
+
 def p2stars(
     pvalue: Union[float, np.ndarray, pd.Series, pd.DataFrame],
     thresholds: tuple = (0.001, 0.01, 0.05),
-    symbols: tuple = ('***', '**', '*', 'ns'),
-    ns_symbol: bool = True
+    symbols: tuple = ("***", "**", "*", "ns"),
+    ns_symbol: bool = True,
 ) -> Union[str, np.ndarray, pd.Series, pd.DataFrame]:
     """
     Convert p-values to significance stars.
@@ -94,13 +96,15 @@ def p2stars(
             f"(one more than thresholds)"
         )
 
-    if not all(thresholds[i] < thresholds[i+1] for i in range(len(thresholds)-1)):
+    if not all(thresholds[i] < thresholds[i + 1] for i in range(len(thresholds) - 1)):
         raise ValueError("thresholds must be in ascending order")
 
     # Handle different input types
     if isinstance(pvalue, (pd.DataFrame, pd.Series)):
         # Apply to DataFrame/Series
-        return pvalue.apply(lambda p: _p2stars_scalar(p, thresholds, symbols, ns_symbol))
+        return pvalue.apply(
+            lambda p: _p2stars_scalar(p, thresholds, symbols, ns_symbol)
+        )
     elif isinstance(pvalue, np.ndarray):
         # Vectorized for numpy arrays
         return np.vectorize(
@@ -112,31 +116,30 @@ def p2stars(
 
 
 def _p2stars_scalar(
-    pvalue: float,
-    thresholds: tuple,
-    symbols: tuple,
-    ns_symbol: bool
+    pvalue: float, thresholds: tuple, symbols: tuple, ns_symbol: bool
 ) -> str:
     """Convert single p-value to stars (internal function)."""
     # Handle NaN
     if pd.isna(pvalue):
-        return 'NaN'
+        return "NaN"
 
     # Handle invalid p-values
     if pvalue < 0 or pvalue > 1:
         logger.warning(f"Invalid p-value: {pvalue}. Should be between 0 and 1.")
-        return 'invalid'
+        return "invalid"
 
-    # Find appropriate symbol
+    # Find appropriate symbol (use <= to include boundary values)
     for i, threshold in enumerate(thresholds):
-        if pvalue < threshold:
+        if pvalue <= threshold:
             return symbols[i]
 
     # Non-significant
-    return symbols[-1] if ns_symbol else ''
+    return symbols[-1] if ns_symbol else ""
 
 
 """Main function"""
+
+
 def main(args):
     """Demonstrate p2stars functionality."""
     logger.info("Demonstrating p2stars functionality")
@@ -159,20 +162,20 @@ def main(args):
 
     # Example 3: DataFrame
     logger.info("\n=== Example 3: DataFrame ===")
-    df = pd.DataFrame({
-        'test': ['Test 1', 'Test 2', 'Test 3', 'Test 4'],
-        'pvalue': [0.0001, 0.023, 0.051, 0.15]
-    })
+    df = pd.DataFrame(
+        {
+            "test": ["Test 1", "Test 2", "Test 3", "Test 4"],
+            "pvalue": [0.0001, 0.023, 0.051, 0.15],
+        }
+    )
 
-    df['pstars'] = p2stars(df['pvalue'])
+    df["pstars"] = p2stars(df["pvalue"])
     logger.info(f"\n{df}")
 
     # Example 4: Custom thresholds
     logger.info("\n=== Example 4: Custom thresholds (more stringent) ===")
     custom_stars = p2stars(
-        0.01,
-        thresholds=(0.0001, 0.001, 0.01),
-        symbols=('****', '***', '**', 'ns')
+        0.01, thresholds=(0.0001, 0.001, 0.01), symbols=("****", "***", "**", "ns")
     )
     logger.info(f"p = 0.01 with custom thresholds → {custom_stars}")
 
@@ -191,34 +194,41 @@ def main(args):
     stars = p2stars(pvals)
 
     # Color map for stars
-    color_map = {'***': 'red', '**': 'orange', '*': 'yellow', 'ns': 'lightgray'}
-    colors = [color_map.get(s, 'gray') for s in stars]
+    color_map = {"***": "red", "**": "orange", "*": "yellow", "ns": "lightgray"}
+    colors = [color_map.get(s, "gray") for s in stars]
 
     # Plot
     ax.scatter(pvals, range(len(pvals)), c=colors, alpha=0.6, s=50)
-    ax.set_xscale('log')
-    ax.set_xlabel('P-value')
-    ax.set_ylabel('Test index')
-    ax.set_title('P-value to Stars Conversion')
+    ax.set_xscale("log")
+    ax.set_xlabel("P-value")
+    ax.set_ylabel("Test index")
+    ax.set_title("P-value to Stars Conversion")
 
     # Add vertical lines for thresholds
     for threshold in [0.001, 0.01, 0.05]:
-        ax.axvline(threshold, color='black', linestyle='--', alpha=0.3)
-        ax.text(threshold, len(pvals) * 0.95, f'{threshold}',
-                ha='center', va='bottom', fontsize=10)
+        ax.axvline(threshold, color="black", linestyle="--", alpha=0.3)
+        ax.text(
+            threshold,
+            len(pvals) * 0.95,
+            f"{threshold}",
+            ha="center",
+            va="bottom",
+            fontsize=10,
+        )
 
     # Add legend
     from matplotlib.patches import Patch
+
     legend_elements = [
-        Patch(facecolor='red', label='p < 0.001 (***)'),
-        Patch(facecolor='orange', label='p < 0.01 (**)'),
-        Patch(facecolor='yellow', label='p < 0.05 (*)'),
-        Patch(facecolor='lightgray', label='p ≥ 0.05 (ns)')
+        Patch(facecolor="red", label="p < 0.001 (***)"),
+        Patch(facecolor="orange", label="p < 0.01 (**)"),
+        Patch(facecolor="yellow", label="p < 0.05 (*)"),
+        Patch(facecolor="lightgray", label="p ≥ 0.05 (ns)"),
     ]
-    ax.legend(handles=legend_elements, loc='upper left')
+    ax.legend(handles=legend_elements, loc="upper left")
 
     # Save
-    stx.io.save(fig, './p2stars_demo.jpg')
+    stx.io.save(fig, "./p2stars_demo.jpg")
     logger.info("Visualization saved")
 
     return 0
@@ -227,13 +237,9 @@ def main(args):
 def parse_args():
     """Parse command line arguments."""
     parser = argparse.ArgumentParser(
-        description='Demonstrate p-value to stars conversion'
-    )
-    parser.add_argument(
-        '--verbose',
-        action='store_true',
-        help='Enable verbose output'
+        description="Demonstrate p-value to stars conversion"
     )
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
     return parser.parse_args()
 
 
@@ -264,7 +270,7 @@ def run_main():
     )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run_main()
 
 # EOF

scitex/stats/utils/_normalizers.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -123,12 +124,8 @@ def normalize_result(
     normalized = result.copy()
 
     # Use adjusted pvalue if available, otherwise use raw pvalue
-    pvalue_for_decision = normalized.get(
-        "pvalue_adjusted", normalized.get("pvalue")
-    )
-    alpha_for_decision = normalized.get(
-        "alpha_adjusted", normalized.get("alpha", 0.05)
-    )
+    pvalue_for_decision = normalized.get("pvalue_adjusted", normalized.get("pvalue"))
+    alpha_for_decision = normalized.get("alpha_adjusted", normalized.get("alpha", 0.05))
 
     # Compute pstars based on adjusted pvalue if available
     # Do this BEFORE filling defaults so we compute actual values
@@ -548,7 +545,7 @@ def _get_scitex_signature(format_type="html"):
     elif format_type == "markdown":
         return f"\n\n---\n\n*Generated by **SciTeX Stats** | {timestamp}*\n\n*Professional Statistical Analysis Framework for Scientific Computing*\n"
     elif format_type == "text":
-        return f"\n\n{'='*80}\nGenerated by SciTeX Stats | {timestamp}\nProfessional Statistical Analysis Framework for Scientific Computing\n{'='*80}\n"
+        return f"\n\n{'=' * 80}\nGenerated by SciTeX Stats | {timestamp}\nProfessional Statistical Analysis Framework for Scientific Computing\n{'=' * 80}\n"
     else:
         return f"Generated by SciTeX Stats | {timestamp}"
 
@@ -582,13 +579,9 @@ def _export_report_html(df, path, title, include_summary):
         if pd.isna(val):
             return ""
         if val < 0.001:
-            return (
-                "background-color: #FF6B6B; font-weight: bold; color: white;"
-            )
+            return "background-color: #FF6B6B; font-weight: bold; color: white;"
         elif val < 0.01:
-            return (
-                "background-color: #FFA500; font-weight: bold; color: white;"
-            )
+            return "background-color: #FFA500; font-weight: bold; color: white;"
         elif val < 0.05:
             return "background-color: #FFE66D; font-weight: bold;"
         else:
@@ -652,7 +645,7 @@ def _export_report_html(df, path, title, include_summary):
         {summary_html}
         <h2>Results</h2>
         {table_html}
-        {_get_scitex_signature('html')}
+        {_get_scitex_signature("html")}
     </body>
     </html>
     """