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

scitex/_mcp_tools/stats.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-15
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/_mcp_tools/stats.py
+"""Stats module tools for FastMCP unified server."""
+
+from __future__ import annotations
+
+import json
+from typing import List, Optional
+
+
+def _json(data: dict) -> str:
+    return json.dumps(data, indent=2, default=str)
+
+
+def register_stats_tools(mcp) -> None:
+    """Register stats tools with FastMCP server."""
+
+    @mcp.tool()
+    async def stats_recommend_tests(
+        n_groups: int = 2,
+        sample_sizes: Optional[List[int]] = None,
+        outcome_type: str = "continuous",
+        design: str = "between",
+        paired: bool = False,
+        has_control_group: bool = False,
+        top_k: int = 3,
+    ) -> str:
+        """[stats] Recommend appropriate statistical tests based on data characteristics."""
+        from scitex.stats._mcp.handlers import recommend_tests_handler
+
+        result = await recommend_tests_handler(
+            n_groups=n_groups,
+            sample_sizes=sample_sizes,
+            outcome_type=outcome_type,
+            design=design,
+            paired=paired,
+            has_control_group=has_control_group,
+            top_k=top_k,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def stats_run_test(
+        test_name: str,
+        data: List[List[float]],
+        alternative: str = "two-sided",
+    ) -> str:
+        """[stats] Execute a statistical test on provided data."""
+        from scitex.stats._mcp.handlers import run_test_handler
+
+        result = await run_test_handler(
+            test_name=test_name,
+            data=data,
+            alternative=alternative,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def stats_format_results(
+        test_name: str,
+        statistic: float,
+        p_value: float,
+        df: Optional[float] = None,
+        effect_size: Optional[float] = None,
+        effect_size_name: Optional[str] = None,
+        style: str = "apa",
+        ci_lower: Optional[float] = None,
+        ci_upper: Optional[float] = None,
+    ) -> str:
+        """[stats] Format statistical results in journal style (APA, Nature, etc.)."""
+        from scitex.stats._mcp.handlers import format_results_handler
+
+        result = await format_results_handler(
+            test_name=test_name,
+            statistic=statistic,
+            p_value=p_value,
+            df=df,
+            effect_size=effect_size,
+            effect_size_name=effect_size_name,
+            style=style,
+            ci_lower=ci_lower,
+            ci_upper=ci_upper,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def stats_power_analysis(
+        test_type: str = "ttest",
+        effect_size: Optional[float] = None,
+        alpha: float = 0.05,
+        power: float = 0.8,
+        n: Optional[int] = None,
+        n_groups: int = 2,
+        ratio: float = 1.0,
+    ) -> str:
+        """[stats] Calculate statistical power or required sample size."""
+        from scitex.stats._mcp.handlers import power_analysis_handler
+
+        result = await power_analysis_handler(
+            test_type=test_type,
+            effect_size=effect_size,
+            alpha=alpha,
+            power=power,
+            n=n,
+            n_groups=n_groups,
+            ratio=ratio,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def stats_correct_pvalues(
+        pvalues: List[float],
+        method: str = "fdr_bh",
+        alpha: float = 0.05,
+    ) -> str:
+        """[stats] Apply multiple comparison correction to p-values."""
+        from scitex.stats._mcp.handlers import correct_pvalues_handler
+
+        result = await correct_pvalues_handler(
+            pvalues=pvalues,
+            method=method,
+            alpha=alpha,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def stats_describe(
+        data: List[float],
+        percentiles: Optional[List[float]] = None,
+    ) -> str:
+        """[stats] Calculate descriptive statistics for data."""
+        from scitex.stats._mcp.handlers import describe_handler
+
+        result = await describe_handler(
+            data=data,
+            percentiles=percentiles,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def stats_effect_size(
+        group1: List[float],
+        group2: List[float],
+        measure: str = "cohens_d",
+        pooled: bool = True,
+    ) -> str:
+        """[stats] Calculate effect size between groups."""
+        from scitex.stats._mcp.handlers import effect_size_handler
+
+        result = await effect_size_handler(
+            group1=group1,
+            group2=group2,
+            measure=measure,
+            pooled=pooled,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def stats_normality_test(
+        data: List[float],
+        method: str = "shapiro",
+    ) -> str:
+        """[stats] Test whether data follows a normal distribution."""
+        from scitex.stats._mcp.handlers import normality_test_handler
+
+        result = await normality_test_handler(
+            data=data,
+            method=method,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def stats_posthoc_test(
+        groups: List[List[float]],
+        group_names: Optional[List[str]] = None,
+        method: str = "tukey",
+        control_group: int = 0,
+    ) -> str:
+        """[stats] Run post-hoc pairwise comparisons after significant ANOVA/Kruskal."""
+        from scitex.stats._mcp.handlers import posthoc_test_handler
+
+        result = await posthoc_test_handler(
+            groups=groups,
+            group_names=group_names,
+            method=method,
+            control_group=control_group,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def stats_p_to_stars(
+        p_value: float,
+        thresholds: Optional[List[float]] = None,
+    ) -> str:
+        """[stats] Convert p-value to significance stars (*, **, ***, ns)."""
+        from scitex.stats._mcp.handlers import p_to_stars_handler
+
+        result = await p_to_stars_handler(
+            p_value=p_value,
+            thresholds=thresholds,
+        )
+        return _json(result)
+
+
+# EOF

scitex/_mcp_tools/template.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-15
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/_mcp_tools/template.py
+"""Template module tools for FastMCP unified server."""
+
+from __future__ import annotations
+
+import json
+from typing import Optional
+
+
+def _json(data: dict) -> str:
+    return json.dumps(data, indent=2, default=str)
+
+
+def register_template_tools(mcp) -> None:
+    """Register template tools with FastMCP server."""
+
+    @mcp.tool()
+    async def template_list_templates() -> str:
+        """[template] List all available SciTeX project templates with their descriptions."""
+        from scitex.template._mcp.handlers import list_templates_handler
+
+        result = await list_templates_handler()
+        return _json(result)
+
+    @mcp.tool()
+    async def template_get_template_info(template_id: str) -> str:
+        """[template] Get detailed information about a specific project template."""
+        from scitex.template._mcp.handlers import get_template_info_handler
+
+        result = await get_template_info_handler(template_id=template_id)
+        return _json(result)
+
+    @mcp.tool()
+    async def template_clone_template(
+        template_id: str,
+        project_name: str,
+        target_dir: Optional[str] = None,
+        git_strategy: str = "child",
+        branch: Optional[str] = None,
+        tag: Optional[str] = None,
+    ) -> str:
+        """[template] Create a new project by cloning a template."""
+        from scitex.template._mcp.handlers import clone_template_handler
+
+        result = await clone_template_handler(
+            template_id=template_id,
+            project_name=project_name,
+            target_dir=target_dir,
+            git_strategy=git_strategy,
+            branch=branch,
+            tag=tag,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def template_list_git_strategies() -> str:
+        """[template] List available git initialization strategies for template cloning."""
+        from scitex.template._mcp.handlers import list_git_strategies_handler
+
+        result = await list_git_strategies_handler()
+        return _json(result)
+
+
+# EOF

scitex/_mcp_tools/ui.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-15
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/_mcp_tools/ui.py
+"""UI module tools for FastMCP unified server."""
+
+from __future__ import annotations
+
+import json
+from typing import Optional
+
+
+def _json(data: dict) -> str:
+    return json.dumps(data, indent=2, default=str)
+
+
+def register_ui_tools(mcp) -> None:
+    """Register UI tools with FastMCP server."""
+
+    @mcp.tool()
+    async def ui_notify(
+        message: str,
+        title: Optional[str] = None,
+        level: str = "info",
+        backend: Optional[str] = None,
+        backends: Optional[list] = None,
+        timeout: float = 5.0,
+    ) -> str:
+        """[ui] Send a notification via configured backends."""
+        from scitex.ui._mcp.handlers import notify_handler
+
+        result = await notify_handler(
+            message=message,
+            title=title,
+            level=level,
+            backend=backend,
+            backends=backends,
+            timeout=timeout,
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def ui_notify_by_level(
+        message: str,
+        title: Optional[str] = None,
+        level: str = "info",
+    ) -> str:
+        """[ui] Send notification using backends configured for a level."""
+        from scitex.ui._mcp.handlers import notify_by_level_handler
+
+        result = await notify_by_level_handler(
+            message=message, title=title, level=level
+        )
+        return _json(result)
+
+    @mcp.tool()
+    async def ui_list_notification_backends() -> str:
+        """[ui] List all notification backends and their status."""
+        from scitex.ui._mcp.handlers import list_backends_handler
+
+        result = await list_backends_handler()
+        return _json(result)
+
+    @mcp.tool()
+    async def ui_available_notification_backends() -> str:
+        """[ui] Get list of currently available backends."""
+        from scitex.ui._mcp.handlers import available_backends_handler
+
+        result = await available_backends_handler()
+        return _json(result)
+
+    @mcp.tool()
+    async def ui_get_notification_config() -> str:
+        """[ui] Get current notification configuration."""
+        from scitex.ui._mcp.handlers import get_config_handler
+
+        result = await get_config_handler()
+        return _json(result)
+
+
+# EOF

scitex/_mcp_tools/writer.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-20
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/_mcp_tools/writer.py
+"""Writer module tools - delegates to scitex-writer package.
+
+Provides usage instructions for shell-based compilation workflow.
+"""
+
+from __future__ import annotations
+
+
+def register_writer_tools(mcp) -> None:
+    """Register writer tools by delegating to scitex-writer package."""
+    try:
+        from scitex_writer._server import INSTRUCTIONS
+
+        _SCITEX_WRITER_AVAILABLE = True
+    except ImportError:
+        _SCITEX_WRITER_AVAILABLE = False
+        INSTRUCTIONS = None
+
+    if not _SCITEX_WRITER_AVAILABLE:
+
+        @mcp.tool()
+        def writer_usage() -> str:
+            """[writer] Get usage guide for SciTeX Writer (not installed)."""
+            return "scitex-writer is required. Install with: pip install scitex-writer"
+
+        return
+
+    @mcp.tool()
+    def writer_usage() -> str:
+        """[writer] Get usage guide for SciTeX Writer LaTeX manuscript compilation system."""
+        return INSTRUCTIONS
+
+
+# EOF

scitex/ai/_gen_ai/_PARAMS.py

@@ -1,14 +1,10 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Timestamp: "2025-09-30 06:38:18 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex_repo/src/scitex/ai/_gen_ai/_PARAMS.py
-# ----------------------------------------
-from __future__ import annotations
-import os
+# Timestamp: "2026-01-16 04:02:17 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/ai/_gen_ai/_PARAMS.py
+
 
 __FILE__ = __file__
-__DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
 
 THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/ai/_gen_ai/PARAMS.py"
 
@@ -202,6 +198,13 @@ OPENAI_MODELS = [
 # https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching#pricing
 # https://docs.anthropic.com/en/docs/about-claude/models#model-comparison-table
 ANTHROPIC_MODELS = [
+    {
+        "name": "claude-opus-4-5-20251101",
+        "input_cost": 5.00,
+        "output_cost": 25.00,
+        "api_key_env": "ANTHROPIC_API_KEY",
+        "provider": "Anthropic",
+    },
     {
         "name": "claude-opus-4-1-20250805",
         "input_cost": 15.00,