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

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>
     """

scitex/stats/utils/_power.py

@@ -31,14 +31,16 @@ from scitex.logging import getLogger
 logger = getLogger(__name__)
 
 """Functions"""
+
+
 def power_ttest(
     effect_size: float,
     n: Optional[int] = None,
     n1: Optional[int] = None,
     n2: Optional[int] = None,
     alpha: float = 0.05,
-    alternative: Literal['two-sided', 'greater', 'less'] = 'two-sided',
-    test_type: Literal['one-sample', 'two-sample', 'paired'] = 'two-sample'
+    alternative: Literal["two-sided", "greater", "less"] = "two-sided",
+    test_type: Literal["one-sample", "two-sample", "paired"] = "two-sample",
 ) -> float:
     """
     Compute statistical power for t-test.
@@ -112,11 +114,11 @@ def power_ttest(
     0.628...
     """
     # Validate inputs
-    if test_type in ['one-sample', 'paired']:
+    if test_type in ["one-sample", "paired"]:
         if n is None:
             raise ValueError(f"n must be specified for {test_type} test")
         sample_size = n
-    elif test_type == 'two-sample':
+    elif test_type == "two-sample":
         if n1 is None or n2 is None:
             raise ValueError("n1 and n2 must be specified for two-sample test")
         # Use harmonic mean for unequal sample sizes
@@ -125,23 +127,23 @@ def power_ttest(
         raise ValueError(f"Unknown test_type: {test_type}")
 
     # Determine degrees of freedom
-    if test_type == 'two-sample':
+    if test_type == "two-sample":
         df = n1 + n2 - 2
     else:
         df = sample_size - 1
 
     # Determine critical value based on alternative hypothesis
-    if alternative == 'two-sided':
+    if alternative == "two-sided":
         t_crit = stats.t.ppf(1 - alpha / 2, df)
-    elif alternative == 'greater':
+    elif alternative == "greater":
         t_crit = stats.t.ppf(1 - alpha, df)
-    elif alternative == 'less':
+    elif alternative == "less":
         t_crit = stats.t.ppf(alpha, df)
     else:
         raise ValueError(f"Unknown alternative: {alternative}")
 
     # Compute non-centrality parameter
-    if test_type == 'two-sample':
+    if test_type == "two-sample":
         # For two-sample, ncp = d * sqrt(n_eff / 2)
         ncp = effect_size * np.sqrt(sample_size / 2)
     else:
@@ -149,10 +151,10 @@ def power_ttest(
         ncp = effect_size * np.sqrt(sample_size)
 
     # Compute power using non-central t-distribution
-    if alternative == 'two-sided':
+    if alternative == "two-sided":
         # For two-sided, power = P(|T| > t_crit | ncp)
         power = 1 - stats.nct.cdf(t_crit, df, ncp) + stats.nct.cdf(-t_crit, df, ncp)
-    elif alternative == 'greater':
+    elif alternative == "greater":
         # For greater, power = P(T > t_crit | ncp)
         power = 1 - stats.nct.cdf(t_crit, df, ncp)
     else:  # less
@@ -166,9 +168,9 @@ def sample_size_ttest(
     effect_size: float,
     power: float = 0.80,
     alpha: float = 0.05,
-    alternative: Literal['two-sided', 'greater', 'less'] = 'two-sided',
-    test_type: Literal['one-sample', 'two-sample', 'paired'] = 'two-sample',
-    ratio: float = 1.0
+    alternative: Literal["two-sided", "greater", "less"] = "two-sided",
+    test_type: Literal["one-sample", "two-sample", "paired"] = "two-sample",
+    ratio: float = 1.0,
 ) -> Union[int, tuple]:
     """
     Determine required sample size for t-test with desired power.
@@ -213,7 +215,7 @@ def sample_size_ttest(
     n_min = 2
     n_max = 10000
 
-    if test_type == 'two-sample':
+    if test_type == "two-sample":
         # Search for n1
         while n_max - n_min > 1:
             n1_mid = (n_min + n_max) // 2
@@ -225,7 +227,7 @@ def sample_size_ttest(
                 n2=n2_mid,
                 alpha=alpha,
                 alternative=alternative,
-                test_type=test_type
+                test_type=test_type,
             )
 
             if current_power < power:
@@ -246,7 +248,7 @@ def sample_size_ttest(
                 n=n_mid,
                 alpha=alpha,
                 alternative=alternative,
-                test_type=test_type
+                test_type=test_type,
             )
 
             if current_power < power:
@@ -258,6 +260,8 @@ def sample_size_ttest(
 
 
 """Main function"""
+
+
 def main(args):
     """Demonstrate power analysis functionality."""
     logger.info("Demonstrating statistical power analysis")
@@ -272,7 +276,7 @@ def main(args):
     for d in effect_sizes:
         power = power_ttest(effect_size=d, n1=n_per_group, n2=n_per_group)
         logger.info(f"d = {d:.1f}, n = {n_per_group} per group → Power = {power:.3f}")
-        results.append({'effect_size': d, 'power': power})
+        results.append({"effect_size": d, "power": power})
 
     # Example 2: Sample size vs power
     logger.info("\n=== Example 2: Sample Size vs Power ===")
@@ -284,7 +288,7 @@ def main(args):
     for n in sample_sizes:
         power = power_ttest(effect_size=d, n1=n, n2=n)
         logger.info(f"n = {n} per group, d = {d} → Power = {power:.3f}")
-        power_results.append({'n': n, 'power': power})
+        power_results.append({"n": n, "power": power})
 
     # Example 3: Required sample size
     logger.info("\n=== Example 3: Required Sample Size ===")
@@ -302,12 +306,12 @@ def main(args):
 
     d = 0.5
     n = 30
-    power_two = power_ttest(effect_size=d, n1=n, n2=n, alternative='two-sided')
-    power_one = power_ttest(effect_size=d, n1=n, n2=n, alternative='greater')
+    power_two = power_ttest(effect_size=d, n1=n, n2=n, alternative="two-sided")
+    power_one = power_ttest(effect_size=d, n1=n, n2=n, alternative="greater")
 
     logger.info(f"Two-sided test: Power = {power_two:.3f}")
     logger.info(f"One-sided test:  Power = {power_one:.3f}")
-    logger.info(f"One-sided power is {power_one/power_two:.2f}x higher")
+    logger.info(f"One-sided power is {power_one / power_two:.2f}x higher")
 
     # Create visualizations
     logger.info("\n=== Creating visualizations ===")
@@ -317,11 +321,11 @@ def main(args):
     # Plot 1: Effect size vs power
     ax = axes[0, 0]
     df_es = pd.DataFrame(results)
-    ax.plot(df_es['effect_size'], df_es['power'], 'o-', linewidth=2, markersize=8)
-    ax.axhline(0.80, color='red', linestyle='--', alpha=0.5, label='80% power')
-    ax.set_xlabel('Effect Size (Cohen\'s d)')
-    ax.set_ylabel('Statistical Power')
-    ax.set_title(f'Effect Size vs Power (n={n_per_group}/group)')
+    ax.plot(df_es["effect_size"], df_es["power"], "o-", linewidth=2, markersize=8)
+    ax.axhline(0.80, color="red", linestyle="--", alpha=0.5, label="80% power")
+    ax.set_xlabel("Effect Size (Cohen's d)")
+    ax.set_ylabel("Statistical Power")
+    ax.set_title(f"Effect Size vs Power (n={n_per_group}/group)")
     ax.legend()
     ax.grid(True, alpha=0.3)
     ax.set_ylim(0, 1)
@@ -329,14 +333,14 @@ def main(args):
     # Plot 2: Sample size vs power
     ax = axes[0, 1]
     df_ss = pd.DataFrame(power_results)
-    ax.plot(df_ss['n'], df_ss['power'], 'o-', linewidth=2, markersize=8)
-    ax.axhline(0.80, color='red', linestyle='--', alpha=0.5, label='80% power')
-    ax.set_xlabel('Sample Size (per group)')
-    ax.set_ylabel('Statistical Power')
-    ax.set_title(f'Sample Size vs Power (d={d})')
+    ax.plot(df_ss["n"], df_ss["power"], "o-", linewidth=2, markersize=8)
+    ax.axhline(0.80, color="red", linestyle="--", alpha=0.5, label="80% power")
+    ax.set_xlabel("Sample Size (per group)")
+    ax.set_ylabel("Statistical Power")
+    ax.set_title(f"Sample Size vs Power (d={d})")
     ax.legend()
     ax.grid(True, alpha=0.3)
-    ax.set_xscale('log')
+    ax.set_xscale("log")
     ax.set_ylim(0, 1)
 
     # Plot 3: Power curves for different effect sizes
@@ -344,12 +348,12 @@ def main(args):
     ns = np.arange(5, 201, 5)
     for d_val in [0.2, 0.5, 0.8]:
         powers = [power_ttest(effect_size=d_val, n1=n, n2=n) for n in ns]
-        ax.plot(ns, powers, linewidth=2, label=f'd = {d_val}')
+        ax.plot(ns, powers, linewidth=2, label=f"d = {d_val}")
 
-    ax.axhline(0.80, color='black', linestyle='--', alpha=0.3)
-    ax.set_xlabel('Sample Size (per group)')
-    ax.set_ylabel('Statistical Power')
-    ax.set_title('Power Curves for Different Effect Sizes')
+    ax.axhline(0.80, color="black", linestyle="--", alpha=0.3)
+    ax.set_xlabel("Sample Size (per group)")
+    ax.set_ylabel("Statistical Power")
+    ax.set_title("Power Curves for Different Effect Sizes")
     ax.legend()
     ax.grid(True, alpha=0.3)
     ax.set_ylim(0, 1)
@@ -364,24 +368,24 @@ def main(args):
         required_ns.append(n1)
 
     ax.plot(effect_sizes_range, required_ns, linewidth=2)
-    ax.set_xlabel('Effect Size (Cohen\'s d)')
-    ax.set_ylabel('Required Sample Size (per group)')
-    ax.set_title('Sample Size Required for 80% Power')
+    ax.set_xlabel("Effect Size (Cohen's d)")
+    ax.set_ylabel("Required Sample Size (per group)")
+    ax.set_title("Sample Size Required for 80% Power")
     ax.grid(True, alpha=0.3)
-    ax.set_yscale('log')
+    ax.set_yscale("log")
 
     # Add reference lines
-    ax.axvline(0.2, color='gray', linestyle='--', alpha=0.3)
-    ax.axvline(0.5, color='gray', linestyle='--', alpha=0.3)
-    ax.axvline(0.8, color='gray', linestyle='--', alpha=0.3)
-    ax.text(0.2, ax.get_ylim()[1] * 0.9, 'Small', ha='center', fontsize=9)
-    ax.text(0.5, ax.get_ylim()[1] * 0.9, 'Medium', ha='center', fontsize=9)
-    ax.text(0.8, ax.get_ylim()[1] * 0.9, 'Large', ha='center', fontsize=9)
+    ax.axvline(0.2, color="gray", linestyle="--", alpha=0.3)
+    ax.axvline(0.5, color="gray", linestyle="--", alpha=0.3)
+    ax.axvline(0.8, color="gray", linestyle="--", alpha=0.3)
+    ax.text(0.2, ax.get_ylim()[1] * 0.9, "Small", ha="center", fontsize=9)
+    ax.text(0.5, ax.get_ylim()[1] * 0.9, "Medium", ha="center", fontsize=9)
+    ax.text(0.8, ax.get_ylim()[1] * 0.9, "Large", ha="center", fontsize=9)
 
     plt.tight_layout()
 
     # Save
-    stx.io.save(fig, './power_analysis_demo.jpg')
+    stx.io.save(fig, "./power_analysis_demo.jpg")
     logger.info("Visualization saved")
 
     return 0
@@ -390,13 +394,9 @@ def main(args):
 def parse_args():
     """Parse command line arguments."""
     parser = argparse.ArgumentParser(
-        description='Demonstrate statistical power analysis for t-tests'
-    )
-    parser.add_argument(
-        '--verbose',
-        action='store_true',
-        help='Enable verbose output'
+        description="Demonstrate statistical power analysis for t-tests"
     )
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
     return parser.parse_args()
 
 
@@ -427,7 +427,7 @@ def run_main():
     )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run_main()
 
 # EOF

scitex/str/__init__.py

@@ -4,6 +4,7 @@
 # File: /ssh:sp:/home/ywatanabe/proj/SciTeX-Code/src/scitex/str/__init__.py
 # ----------------------------------------
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------

scitex/str/_clean_path.py

@@ -50,12 +50,12 @@ def clean_path(path_string: str) -> str:
     """
     try:
         # Convert Path objects to strings to avoid AttributeError
-        if hasattr(path_string, '__fspath__'):  # Check if it's a path-like object
+        if hasattr(path_string, "__fspath__"):  # Check if it's a path-like object
             path_string = str(path_string)
-        
+
         if not isinstance(path_string, str):
             raise TypeError("Input must be a string")
-            
+
         is_directory = path_string.endswith("/")
 
         if path_string.startswith('f"'):