scitex 2.15.1__py3-none-any.whl → 2.15.2__py3-none-any.whl

scitex/logging/_formatters.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: "2025-10-11 00:17:43 (ywatanabe)"
 # File: /home/ywatanabe/proj/scitex_repo/src/scitex/logging/_formatters.py
 # ----------------------------------------
 from __future__ import annotations
+
 import os
 
 __FILE__ = "./src/scitex/logging/_formatters.py"
@@ -18,12 +18,17 @@ import sys
 
 # Global format configuration via environment variable
 # Options: default, minimal, detailed, debug, full
-# SCITEX_LOG_FORMAT=debug python script.py
-LOG_FORMAT = os.getenv("SCITEX_LOG_FORMAT", "default")
+# SCITEX_LOGGING_FORMAT=debug python script.py
+LOG_FORMAT = os.getenv("SCITEX_LOGGING_FORMAT") or os.getenv(
+    "SCITEX_LOG_FORMAT", "default"
+)
 
 # Force color output even when stdout is not a TTY (e.g., when piping through tee)
-# SCITEX_FORCE_COLOR=1 python script.py | tee output.log
-FORCE_COLOR = os.getenv("SCITEX_FORCE_COLOR", "").lower() in ("1", "true", "yes")
+# SCITEX_LOGGING_FORCE_COLOR=1 python script.py | tee output.log
+_force_color = os.getenv("SCITEX_LOGGING_FORCE_COLOR") or os.getenv(
+    "SCITEX_FORCE_COLOR", ""
+)
+FORCE_COLOR = _force_color.lower() in ("1", "true", "yes")
 
 # Available format templates
 FORMAT_TEMPLATES = {
@@ -107,14 +112,19 @@ class SciTeXConsoleFormatter(logging.Formatter):
             # First line already has prefix from parent formatter
             # Add prefix to each continuation line
             prefix = f"{record.levelname}: "
-            formatted = lines[0] + "\n" + "\n".join(
-                prefix + line if line.strip() else line
-                for line in lines[1:]
+            formatted = (
+                lines[0]
+                + "\n"
+                + "\n".join(
+                    prefix + line if line.strip() else line for line in lines[1:]
+                )
             )
 
         # Check if we can use colors (stdout is a tty and not closed, or forced)
         try:
-            use_colors = FORCE_COLOR or (hasattr(sys.stdout, "isatty") and sys.stdout.isatty())
+            use_colors = FORCE_COLOR or (
+                hasattr(sys.stdout, "isatty") and sys.stdout.isatty()
+            )
         except ValueError:
             # stdout/stderr is closed
             use_colors = FORCE_COLOR

scitex/mcp_server.py

@@ -106,7 +106,7 @@ result = stx.stats.test_anova(*groups, return_as="latex")
 - [scholar] search_papers, enrich_bibtex, download_pdf, fetch_papers
 - [diagram] create_diagram, compile_mermaid, compile_graphviz
 - [canvas] create_canvas, add_panel, export_canvas
-- [template] list_templates, clone_template
+- [template] list_templates, clone_template, get_code_template, list_code_templates
 - [ui] notify, list_notification_backends
 - [writer] usage (LaTeX manuscript compilation)
 - [introspect] signature, docstring, source, members (like IPython's ? and ??)

scitex/os/__init__.py

@@ -1,8 +1,12 @@
 #!/usr/bin/env python3
 """Scitex os module."""
 
+from ._check_host import check_host, is_host, verify_host
 from ._mv import mv
 
 __all__ = [
+    "check_host",
+    "is_host",
     "mv",
+    "verify_host",
 ]

scitex/{gen → os}/_check_host.py

@@ -1,15 +1,14 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Time-stamp: "2024-11-02 13:43:36 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/gen/_check_host.py
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/os/_check_host.py
 
-
-from scitex.sh import sh
+import socket
 import sys
 
 
 def check_host(keyword):
-    return keyword in sh("echo $(hostname)", verbose=False)
+    """Check if the current hostname contains the given keyword."""
+    return keyword in socket.gethostname()
 
 
 is_host = check_host

scitex/plt/__init__.py

@@ -70,34 +70,31 @@ __DIR__ = os.path.dirname(__FILE__)
 # Re-export figrecipe public API with scitex branding
 # ============================================================================
 if _FIGRECIPE_AVAILABLE:
-    # Core functions
+    # Core public API
+    from figrecipe import __version__ as _figrecipe_version
     from figrecipe import (
-        STYLE,
-        align_panels,
-        apply_style,
         compose,
         crop,
-        distribute_panels,
         edit,
-        enable_svg,
         extract_data,
-        get_graph_preset,
         info,
-        list_graph_presets,
         list_presets,
         load_style,
-        register_graph_preset,
         reproduce,
         save,
-        smart_align,
-        sns,
         subplots,
         unload_style,
         validate,
     )
-    from figrecipe import (
-        __version__ as _figrecipe_version,
-    )
+
+    # Internal imports (not part of figrecipe public API)
+    from figrecipe._api._notebook import enable_svg
+    from figrecipe._api._seaborn_proxy import sns
+    from figrecipe._api._style_manager import STYLE, apply_style
+    from figrecipe._composition import align_panels, distribute_panels, smart_align
+    from figrecipe._graph_presets import get_preset as get_graph_preset
+    from figrecipe._graph_presets import list_presets as list_graph_presets
+    from figrecipe._graph_presets import register_preset as register_graph_preset
 
     # Also export load as alias for reproduce
     load = reproduce

scitex/session/__init__.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: "2025-08-21 20:36:45 (ywatanabe)"
 # File: /home/ywatanabe/proj/SciTeX-Code/src/scitex/session/__init__.py
 # ----------------------------------------
 from __future__ import annotations
+
 import os
 
 __FILE__ = __file__
@@ -20,27 +20,46 @@ Usage:
     import sys
     import matplotlib.pyplot as plt
     from scitex import session
-    
+
     # Start a session
     CONFIG, sys.stdout, sys.stderr, plt, COLORS, rng = session.start(sys, plt)
-    
+
     # Your experiment code here
-    
-    # Close the session  
+
+    # Close the session
     session.close(CONFIG)
 
     # Session manager for advanced use cases
     manager = session.SessionManager()
     active_sessions = manager.get_active_sessions()
+
+    # Using INJECTED sentinel for decorator parameters
+    @stx.session
+    def main(CONFIG=stx.session.INJECTED, plt=stx.session.INJECTED):
+        ...
 """
 
+
+# Sentinel object for decorator-injected parameters
+class _InjectedSentinel:
+    """Sentinel value indicating a parameter will be injected by a decorator."""
+
+    def __repr__(self):
+        return "<INJECTED>"
+
+
+INJECTED = _InjectedSentinel()
+
+
 # Import session management functionality
+from ._decorator import run, session
+from ._lifecycle import close, running2finished, start
 from ._manager import SessionManager
-from ._lifecycle import start, close, running2finished
-from ._decorator import session, run
 
 # Export public API
 __all__ = [
+    # Sentinel for injected parameters
+    "INJECTED",
     # Session lifecycle (main functions)
     "start",
     "close",

scitex/session/_decorator.py

@@ -21,7 +21,7 @@ import sys as sys_module
 
 from ._lifecycle import start, close
 from scitex.logging import getLogger
-from scitex import INJECTED
+from . import INJECTED  # Use local INJECTED from session module
 
 # Internal logger for the decorator itself
 _decorator_logger = getLogger(__name__)

scitex/sh/__init__.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 from __future__ import annotations
+
 import os
 
 __FILE__ = __file__
@@ -8,9 +8,9 @@ __DIR__ = os.path.dirname(__FILE__)
 
 from typing import Union
 
-from ._types import CommandInput, ReturnFormat, ShellResult
-from ._security import quote, validate_command
 from ._execute import execute
+from ._security import quote, validate_command
+from ._types import CommandInput, ReturnFormat, ShellResult
 
 
 def sh(
@@ -88,6 +88,9 @@ def sh_run(command: CommandInput, verbose: bool = True) -> ShellResult:
     return execute(command, verbose=verbose)
 
 
-__all__ = ["sh", "sh_run", "quote"]
+# Legacy functions moved from gen module
+from ._shell_legacy import run_shellcommand, run_shellscript
+
+__all__ = ["sh", "sh_run", "quote", "run_shellcommand", "run_shellscript"]
 
 # EOF

scitex/social/__init__.py

@@ -17,13 +17,15 @@ Features
 
 Environment Variables
 ---------------------
-Credentials use SCITEX_ prefix (falls back to SOCIALIA_):
-- SCITEX_X_CONSUMER_KEY, SCITEX_X_CONSUMER_SECRET
-- SCITEX_X_ACCESS_TOKEN, SCITEX_X_ACCESS_TOKEN_SECRET
-- SCITEX_LINKEDIN_ACCESS_TOKEN
-- SCITEX_REDDIT_CLIENT_ID, SCITEX_REDDIT_CLIENT_SECRET
-- SCITEX_YOUTUBE_API_KEY
-- SCITEX_GA_PROPERTY_ID
+Credentials use SCITEX_SOCIAL_ prefix (falls back to SOCIALIA_):
+- SCITEX_SOCIAL_X_CONSUMER_KEY, SCITEX_SOCIAL_X_CONSUMER_KEY_SECRET
+- SCITEX_SOCIAL_X_ACCESS_TOKEN, SCITEX_SOCIAL_X_ACCESS_TOKEN_SECRET
+- SCITEX_SOCIAL_X_BEARER_TOKEN
+- SCITEX_SOCIAL_LINKEDIN_CLIENT_ID, SCITEX_SOCIAL_LINKEDIN_CLIENT_SECRET
+- SCITEX_SOCIAL_LINKEDIN_ACCESS_TOKEN
+- SCITEX_SOCIAL_REDDIT_CLIENT_ID, SCITEX_SOCIAL_REDDIT_CLIENT_SECRET
+- SCITEX_SOCIAL_YOUTUBE_API_KEY
+- SCITEX_SOCIAL_GOOGLE_ANALYTICS_PROPERTY_ID
 
 Usage
 -----
@@ -55,7 +57,7 @@ import os as _os
 
 # Set branding BEFORE importing socialia
 _os.environ.setdefault("SOCIALIA_BRAND", "scitex.social")
-_os.environ.setdefault("SOCIALIA_ENV_PREFIX", "SCITEX")
+_os.environ.setdefault("SOCIALIA_ENV_PREFIX", "SCITEX_SOCIAL")
 
 # Check socialia availability
 try:

scitex/stats/_mcp/_handlers/__init__.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-25
+# File: src/scitex/stats/_mcp/_handlers/__init__.py
+
+"""Stats MCP handler implementations split into modules."""
+
+from ._corrections import correct_pvalues_handler
+from ._descriptive import describe_handler
+from ._effect_size import effect_size_handler
+from ._format import format_results_handler
+from ._normality import normality_test_handler
+from ._posthoc import posthoc_test_handler
+from ._power import power_analysis_handler
+from ._recommend import recommend_tests_handler
+from ._run_test import run_test_handler
+from ._stars import p_to_stars_handler
+
+__all__ = [
+    "recommend_tests_handler",
+    "run_test_handler",
+    "format_results_handler",
+    "power_analysis_handler",
+    "correct_pvalues_handler",
+    "describe_handler",
+    "effect_size_handler",
+    "normality_test_handler",
+    "posthoc_test_handler",
+    "p_to_stars_handler",
+]
+
+# EOF

scitex/stats/_mcp/_handlers/_corrections.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-25
+# File: src/scitex/stats/_mcp/_handlers/_corrections.py
+
+"""P-value correction handler for multiple comparisons."""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime
+
+import numpy as np
+
+__all__ = ["correct_pvalues_handler"]
+
+
+async def correct_pvalues_handler(
+    pvalues: list[float],
+    method: str = "fdr_bh",
+    alpha: float = 0.05,
+) -> dict:
+    """Apply multiple comparison correction to p-values."""
+    try:
+        loop = asyncio.get_event_loop()
+
+        def do_correct():
+            from statsmodels.stats.multitest import multipletests
+
+            # Map method names
+            method_map = {
+                "bonferroni": "bonferroni",
+                "fdr_bh": "fdr_bh",
+                "fdr_by": "fdr_by",
+                "holm": "holm",
+                "sidak": "sidak",
+            }
+            sm_method = method_map.get(method, "fdr_bh")
+
+            pvals = np.array(pvalues)
+            reject, pvals_corrected, _, _ = multipletests(
+                pvals, alpha=alpha, method=sm_method
+            )
+
+            return {
+                "original_pvalues": pvalues,
+                "corrected_pvalues": pvals_corrected.tolist(),
+                "reject_null": reject.tolist(),
+                "n_significant": int(reject.sum()),
+                "n_tests": len(pvalues),
+            }
+
+        result = await loop.run_in_executor(None, do_correct)
+
+        return {
+            "success": True,
+            "method": method,
+            "alpha": alpha,
+            **result,
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    except ImportError:
+        # Fallback implementation without statsmodels
+        try:
+            n = len(pvalues)
+            pvals = np.array(pvalues)
+
+            if method == "bonferroni":
+                corrected = np.minimum(pvals * n, 1.0)
+            elif method == "holm":
+                sorted_idx = np.argsort(pvals)
+                corrected = np.empty(n)
+                cummax = 0.0
+                for rank, idx in enumerate(sorted_idx, start=1):
+                    adj = min((n - rank + 1) * pvals[idx], 1.0)
+                    adj = max(adj, cummax)
+                    corrected[idx] = adj
+                    cummax = adj
+            elif method == "fdr_bh":
+                sorted_idx = np.argsort(pvals)
+                corrected = np.empty(n)
+                prev = 1.0
+                for rank in range(n, 0, -1):
+                    idx = sorted_idx[rank - 1]
+                    bh = pvals[idx] * n / rank
+                    val = min(bh, prev, 1.0)
+                    corrected[idx] = val
+                    prev = val
+            elif method == "sidak":
+                corrected = 1 - (1 - pvals) ** n
+            else:
+                corrected = pvals
+
+            return {
+                "success": True,
+                "method": method,
+                "alpha": alpha,
+                "original_pvalues": pvalues,
+                "corrected_pvalues": corrected.tolist(),
+                "reject_null": (corrected < alpha).tolist(),
+                "n_significant": int((corrected < alpha).sum()),
+                "n_tests": n,
+                "timestamp": datetime.now().isoformat(),
+            }
+
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# EOF

scitex/stats/_mcp/_handlers/_descriptive.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-25
+# File: src/scitex/stats/_mcp/_handlers/_descriptive.py
+
+"""Descriptive statistics handler."""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime
+
+import numpy as np
+
+__all__ = ["describe_handler"]
+
+
+async def describe_handler(
+    data: list[float],
+    percentiles: list[float] | None = None,
+) -> dict:
+    """Calculate descriptive statistics for data."""
+    try:
+        loop = asyncio.get_event_loop()
+
+        def do_describe():
+            arr = np.array(data, dtype=float)
+            arr = arr[~np.isnan(arr)]  # Remove NaN
+
+            if len(arr) == 0:
+                return {"error": "No valid data points"}
+
+            percs = percentiles or [25, 50, 75]
+            percentile_values = np.percentile(arr, percs)
+
+            result = {
+                "n": int(len(arr)),
+                "mean": float(np.mean(arr)),
+                "std": float(np.std(arr, ddof=1)) if len(arr) > 1 else 0.0,
+                "var": float(np.var(arr, ddof=1)) if len(arr) > 1 else 0.0,
+                "sem": (
+                    float(np.std(arr, ddof=1) / np.sqrt(len(arr)))
+                    if len(arr) > 1
+                    else 0.0
+                ),
+                "min": float(np.min(arr)),
+                "max": float(np.max(arr)),
+                "range": float(np.max(arr) - np.min(arr)),
+                "median": float(np.median(arr)),
+                "percentiles": {
+                    str(int(p)): float(v) for p, v in zip(percs, percentile_values)
+                },
+                "iqr": float(np.percentile(arr, 75) - np.percentile(arr, 25)),
+            }
+
+            # Add skewness and kurtosis if scipy available
+            try:
+                from scipy import stats as scipy_stats
+
+                result["skewness"] = float(scipy_stats.skew(arr))
+                result["kurtosis"] = float(scipy_stats.kurtosis(arr))
+            except ImportError:
+                pass
+
+            return result
+
+        result = await loop.run_in_executor(None, do_describe)
+
+        return {
+            "success": True,
+            **result,
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# EOF

scitex/stats/_mcp/_handlers/_effect_size.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-25
+# File: src/scitex/stats/_mcp/_handlers/_effect_size.py
+
+"""Effect size calculation handler."""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime
+
+import numpy as np
+
+__all__ = ["effect_size_handler"]
+
+
+async def effect_size_handler(
+    group1: list[float],
+    group2: list[float],
+    measure: str = "cohens_d",
+    pooled: bool = True,
+) -> dict:
+    """Calculate effect size between groups."""
+    try:
+        from scitex.stats.effect_sizes import (
+            cliffs_delta,
+            cohens_d,
+            interpret_cliffs_delta,
+            interpret_cohens_d,
+        )
+
+        loop = asyncio.get_event_loop()
+
+        def do_effect_size():
+            g1 = np.array(group1, dtype=float)
+            g2 = np.array(group2, dtype=float)
+
+            result = {}
+
+            if measure == "cohens_d":
+                d = cohens_d(g1, g2)
+                result = {
+                    "measure": "Cohen's d",
+                    "value": float(d),
+                    "interpretation": interpret_cohens_d(d),
+                }
+
+            elif measure == "hedges_g":
+                # Hedges' g is Cohen's d with bias correction
+                d = cohens_d(g1, g2)
+                n1, n2 = len(g1), len(g2)
+                correction = 1 - (3 / (4 * (n1 + n2) - 9))
+                g = d * correction
+                result = {
+                    "measure": "Hedges' g",
+                    "value": float(g),
+                    "interpretation": interpret_cohens_d(g),  # Same thresholds
+                }
+
+            elif measure == "glass_delta":
+                # Glass's delta uses only control group std
+                mean_diff = np.mean(g1) - np.mean(g2)
+                delta = mean_diff / np.std(g2, ddof=1)
+                result = {
+                    "measure": "Glass's delta",
+                    "value": float(delta),
+                    "interpretation": interpret_cohens_d(delta),
+                }
+
+            elif measure == "cliffs_delta":
+                delta = cliffs_delta(g1, g2)
+                result = {
+                    "measure": "Cliff's delta",
+                    "value": float(delta),
+                    "interpretation": interpret_cliffs_delta(delta),
+                }
+
+            else:
+                raise ValueError(f"Unknown measure: {measure}")
+
+            # Add confidence interval approximation for Cohen's d
+            if measure in ["cohens_d", "hedges_g", "glass_delta"]:
+                n1, n2 = len(g1), len(g2)
+                se = np.sqrt(
+                    (n1 + n2) / (n1 * n2) + result["value"] ** 2 / (2 * (n1 + n2))
+                )
+                result["ci_lower"] = float(result["value"] - 1.96 * se)
+                result["ci_upper"] = float(result["value"] + 1.96 * se)
+
+            return result
+
+        result = await loop.run_in_executor(None, do_effect_size)
+
+        return {
+            "success": True,
+            "group1_n": len(group1),
+            "group2_n": len(group2),
+            **result,
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# EOF