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

scitex/gen/_title_case.py

@@ -1,89 +0,0 @@
-#!./env/bin/python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2024-04-24 15:05:34"
-# Author: Yusuke Watanabe (ywatanabe@scitex.ai)
-
-
-"""
-This script does XYZ.
-"""
-
-"""
-Imports
-"""
-import sys
-
-import matplotlib.pyplot as plt
-
-
-"""
-Config
-"""
-# CONFIG = scitex.gen.load_configs()
-
-
-"""
-Functions & Classes
-"""
-
-
-def title_case(text):
-    """
-    Converts a string to title case while keeping certain prepositions, conjunctions, and articles in lowercase,
-    and ensuring words detected as potential acronyms (all uppercase) are fully capitalized.
-
-    Parameters:
-    - text (str): The text to convert to title case.
-
-    Returns:
-    - str: The converted text in title case with certain words in lowercase and potential acronyms fully capitalized.
-
-    Examples:
-    --------
-        print(title_case("welcome to the world of ai and using CPUs for gaming"))  # Welcome to the World of AI and Using CPUs for Gaming
-    """
-    # List of words to keep in lowercase
-    lowercase_words = [
-        "a",
-        "an",
-        "the",
-        "and",
-        "but",
-        "or",
-        "nor",
-        "at",
-        "by",
-        "to",
-        "in",
-        "with",
-        "of",
-        "on",
-    ]
-
-    words = text.split()
-    final_words = []
-    for word in words:
-        # Check if the word is fully in uppercase and more than one character, suggesting an acronym
-        if word.isupper() and len(word) > 1:
-            final_words.append(word)
-        elif word.lower() in lowercase_words:
-            final_words.append(word.lower())
-        else:
-            final_words.append(word.capitalize())
-    return " ".join(final_words)
-
-
-def main():
-    # Example usage:
-    text = "welcome to the world of ai and using CPUs for gaming"
-    print(title_case(text))
-
-
-if __name__ == "__main__":
-    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.session.start(
-        sys, plt, verbose=False
-    )
-    main()
-    scitex.session.close(CONFIG, verbose=False, notify=False)
-
-# EOF

scitex/plt/_mcp/__init__.py

@@ -1,4 +0,0 @@
-#!/usr/bin/env python3
-# File: __init__.py
-"""MCP server components."""
-

scitex/plt/_mcp/_handlers_annotation.py

@@ -1,102 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2026-01-13
-# File: src/scitex/plt/_mcp/_handlers_annotation.py
-
-"""Annotation MCP handlers for SciTeX plt module."""
-
-from __future__ import annotations
-
-from typing import Optional
-
-from ._handlers_figure import _get_axes
-
-
-async def add_significance_handler(
-    x1: float,
-    x2: float,
-    y: float,
-    text: str,
-    figure_id: Optional[str] = None,
-    panel: str = "0,0",
-    height: Optional[float] = None,
-) -> dict:
-    """Add significance bracket between two groups."""
-    try:
-        from scitex.plt.styles.presets import SCITEX_STYLE
-        from scitex.plt.utils import mm_to_pt
-
-        fig, ax, fid = _get_axes(figure_id, panel)
-
-        ylim = ax.get_ylim()
-        ylim_range = float(ylim[1]) - float(ylim[0])
-        h = height if height else 0.1 * ylim_range
-
-        # Use SCITEX line width (0.2mm converted to points)
-        line_width_mm = SCITEX_STYLE.get("trace_thickness_mm", 0.2)
-        line_width_pt = mm_to_pt(line_width_mm)
-
-        # Draw bracket with SCITEX styling
-        ax.plot(
-            [x1, x1, x2, x2],
-            [y, y + h, y + h, y],
-            color="black",
-            linewidth=line_width_pt,
-        )
-
-        ax.text(
-            (x1 + x2) / 2,
-            y + h + 0.02 * ylim_range,
-            text,
-            ha="center",
-            va="bottom",
-            fontsize=6,
-        )
-
-        return {
-            "success": True,
-            "figure_id": fid,
-            "panel": panel,
-            "bracket": {"x1": x1, "x2": x2, "y": y, "text": text},
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-async def add_panel_label_handler(
-    label: str,
-    figure_id: Optional[str] = None,
-    panel: str = "0,0",
-    x: float = -0.15,
-    y: float = 1.1,
-    fontsize: float = 10,
-    fontweight: str = "bold",
-) -> dict:
-    """Add panel label (A, B, C, etc.) to a panel."""
-    try:
-        fig, ax, fid = _get_axes(figure_id, panel)
-
-        ax.text(
-            x,
-            y,
-            label,
-            transform=ax.transAxes,
-            fontsize=fontsize,
-            fontweight=fontweight,
-        )
-
-        return {
-            "success": True,
-            "figure_id": fid,
-            "panel": panel,
-            "label": label,
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-__all__ = [
-    "add_significance_handler",
-    "add_panel_label_handler",
-]
-
-# EOF

scitex/plt/_mcp/_handlers_figure.py

@@ -1,195 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2026-01-13
-# File: src/scitex/plt/_mcp/_handlers_figure.py
-
-"""Figure management MCP handlers for SciTeX plt module."""
-
-from __future__ import annotations
-
-import asyncio
-from typing import Any, Optional
-
-# Figure registry for tracking active figures across MCP calls
-_FIGURE_REGISTRY: dict[str, dict[str, Any]] = {}
-
-
-def _get_axes(figure_id: Optional[str], panel: str):
-    """Helper to get axes from figure registry."""
-    if figure_id is None:
-        if not _FIGURE_REGISTRY:
-            raise ValueError("No active figures. Call create_figure first.")
-        figure_id = list(_FIGURE_REGISTRY.keys())[-1]
-
-    if figure_id not in _FIGURE_REGISTRY:
-        raise ValueError(f"Figure '{figure_id}' not found")
-
-    fig_data = _FIGURE_REGISTRY[figure_id]
-    axes = fig_data["axes"]
-
-    if "," in panel:
-        row, col = map(int, panel.split(","))
-        try:
-            ax = axes[row, col]
-        except (TypeError, IndexError):
-            ax = axes
-    else:
-        idx = ord(panel.upper()) - ord("A")
-        if hasattr(axes, "flat"):
-            ax = list(axes.flat)[idx]
-        elif hasattr(axes, "__getitem__"):
-            ax = axes[idx]
-        else:
-            ax = axes
-
-    return fig_data["fig"], ax, figure_id
-
-
-async def create_figure_handler(
-    nrows: int = 1,
-    ncols: int = 1,
-    axes_width_mm: Optional[float] = None,
-    axes_height_mm: Optional[float] = None,
-    space_w_mm: Optional[float] = None,
-    space_h_mm: Optional[float] = None,
-) -> dict:
-    """Create a multi-panel figure canvas with SciTeX style."""
-    import uuid
-
-    try:
-        import scitex.plt as splt
-
-        kwargs = {"nrows": nrows, "ncols": ncols}
-        if axes_width_mm is not None:
-            kwargs["axes_width_mm"] = axes_width_mm
-        if axes_height_mm is not None:
-            kwargs["axes_height_mm"] = axes_height_mm
-        if space_w_mm is not None:
-            kwargs["space_w_mm"] = space_w_mm
-        if space_h_mm is not None:
-            kwargs["space_h_mm"] = space_h_mm
-
-        fig, axes = splt.subplots(**kwargs)
-
-        figure_id = str(uuid.uuid4())[:8]
-
-        _FIGURE_REGISTRY[figure_id] = {
-            "fig": fig,
-            "axes": axes,
-            "nrows": nrows,
-            "ncols": ncols,
-        }
-
-        return {
-            "success": True,
-            "figure_id": figure_id,
-            "nrows": nrows,
-            "ncols": ncols,
-            "message": f"Created {nrows}x{ncols} figure with SciTeX style",
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-async def crop_figure_handler(
-    input_path: str,
-    output_path: Optional[str] = None,
-    margin: int = 12,
-    overwrite: bool = False,
-) -> dict:
-    """Auto-crop whitespace from a saved figure image."""
-    try:
-        from scitex.plt import crop
-
-        loop = asyncio.get_event_loop()
-        result_path = await loop.run_in_executor(
-            None,
-            lambda: crop(
-                input_path=input_path,
-                output_path=output_path,
-                margin=margin,
-                overwrite=overwrite,
-            ),
-        )
-
-        return {
-            "success": True,
-            "input_path": input_path,
-            "output_path": str(result_path),
-            "margin_pixels": margin,
-            "message": f"Cropped figure saved to {result_path}",
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-async def save_figure_handler(
-    output_path: str,
-    figure_id: Optional[str] = None,
-    dpi: int = 300,
-    crop: bool = True,
-) -> dict:
-    """Save the figure to file."""
-    try:
-        if figure_id is None:
-            if not _FIGURE_REGISTRY:
-                raise ValueError("No active figures")
-            figure_id = list(_FIGURE_REGISTRY.keys())[-1]
-
-        if figure_id not in _FIGURE_REGISTRY:
-            raise ValueError(f"Figure '{figure_id}' not found")
-
-        fig = _FIGURE_REGISTRY[figure_id]["fig"]
-
-        fig.savefig(output_path, dpi=dpi, bbox_inches="tight")
-
-        final_path = output_path
-        if crop and output_path.endswith(".png"):
-            from scitex.plt import crop as crop_fn
-
-            final_path = crop_fn(output_path, overwrite=True)
-
-        return {
-            "success": True,
-            "figure_id": figure_id,
-            "output_path": str(final_path),
-            "dpi": dpi,
-            "cropped": crop,
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-async def close_figure_handler(figure_id: Optional[str] = None) -> dict:
-    """Close a figure and free memory."""
-    try:
-        import scitex.plt as splt
-
-        if figure_id is None:
-            if not _FIGURE_REGISTRY:
-                return {"success": True, "message": "No figures to close"}
-            figure_id = list(_FIGURE_REGISTRY.keys())[-1]
-
-        if figure_id in _FIGURE_REGISTRY:
-            fig = _FIGURE_REGISTRY[figure_id]["fig"]
-            splt.close(fig)
-            del _FIGURE_REGISTRY[figure_id]
-
-        return {
-            "success": True,
-            "figure_id": figure_id,
-            "message": f"Closed figure {figure_id}",
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-__all__ = [
-    "_FIGURE_REGISTRY",
-    "_get_axes",
-    "create_figure_handler",
-    "crop_figure_handler",
-    "save_figure_handler",
-    "close_figure_handler",
-]
-
-# EOF

scitex/plt/_mcp/_handlers_plot.py

@@ -1,252 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: 2026-01-13
-# File: src/scitex/plt/_mcp/_handlers_plot.py
-
-"""Plot-related MCP handlers for SciTeX plt module."""
-
-from __future__ import annotations
-
-from typing import Optional
-
-from ._handlers_figure import _get_axes
-
-
-async def plot_bar_handler(
-    x: list[str],
-    y: list[float],
-    figure_id: Optional[str] = None,
-    panel: str = "0,0",
-    yerr: Optional[list[float]] = None,
-    colors: Optional[list[str]] = None,
-    xlabel: Optional[str] = None,
-    ylabel: Optional[str] = None,
-    title: Optional[str] = None,
-) -> dict:
-    """Create a bar plot on specified panel."""
-    try:
-        fig, ax, fid = _get_axes(figure_id, panel)
-
-        if colors is None:
-            from scitex.plt import color as color_module
-
-            params = getattr(color_module, "PARAMS", {})
-            rgba_cycle = params.get("RGBA_NORM_FOR_CYCLE", {})
-            color_list = list(rgba_cycle.values())
-            colors = color_list[: len(x)] if color_list else None
-
-        ax.bar(x, y, yerr=yerr, capsize=3, color=colors)
-
-        if xlabel:
-            ax.set_xlabel(xlabel)
-        if ylabel:
-            ax.set_ylabel(ylabel)
-        if title:
-            ax.set_title(title)
-
-        return {
-            "success": True,
-            "figure_id": fid,
-            "panel": panel,
-            "plot_type": "bar",
-            "n_bars": len(x),
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-async def plot_scatter_handler(
-    x: list[float],
-    y: list[float],
-    figure_id: Optional[str] = None,
-    panel: str = "0,0",
-    color: Optional[str] = None,
-    size: Optional[float] = None,
-    alpha: float = 0.7,
-    add_regression: bool = False,
-    xlabel: Optional[str] = None,
-    ylabel: Optional[str] = None,
-    title: Optional[str] = None,
-) -> dict:
-    """Create a scatter plot on specified panel."""
-    try:
-        import numpy as np
-
-        fig, ax, fid = _get_axes(figure_id, panel)
-
-        if color is None:
-            color = "#c633ff"  # SciTeX purple
-
-        s = (size * 2.83465) ** 2 if size else 15
-
-        ax.scatter(x, y, c=color, s=s, alpha=alpha)
-
-        if add_regression:
-            z = np.polyfit(x, y, 1)
-            p = np.poly1d(z)
-            x_line = np.linspace(min(x), max(x), 100)
-            ax.plot(x_line, p(x_line), color="#e25e33", linestyle="--", linewidth=1)
-
-        if xlabel:
-            ax.set_xlabel(xlabel)
-        if ylabel:
-            ax.set_ylabel(ylabel)
-        if title:
-            ax.set_title(title)
-
-        return {
-            "success": True,
-            "figure_id": fid,
-            "panel": panel,
-            "plot_type": "scatter",
-            "n_points": len(x),
-            "regression_added": add_regression,
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-async def plot_line_handler(
-    x: list[float],
-    y: list[float],
-    figure_id: Optional[str] = None,
-    panel: str = "0,0",
-    yerr: Optional[list[float]] = None,
-    color: Optional[str] = None,
-    label: Optional[str] = None,
-    linestyle: str = "-",
-    xlabel: Optional[str] = None,
-    ylabel: Optional[str] = None,
-    title: Optional[str] = None,
-) -> dict:
-    """Create a line plot on specified panel."""
-    try:
-        fig, ax, fid = _get_axes(figure_id, panel)
-
-        if color is None:
-            color = "#007fbf"  # SciTeX blue
-
-        ax.plot(x, y, color=color, label=label, linestyle=linestyle)
-
-        if yerr:
-            import numpy as np
-
-            y_arr = np.array(y)
-            yerr_arr = np.array(yerr)
-            ax.fill_between(
-                x, y_arr - yerr_arr, y_arr + yerr_arr, alpha=0.3, color=color
-            )
-
-        if xlabel:
-            ax.set_xlabel(xlabel)
-        if ylabel:
-            ax.set_ylabel(ylabel)
-        if title:
-            ax.set_title(title)
-        if label:
-            ax.legend(loc="upper right", frameon=False)
-
-        return {
-            "success": True,
-            "figure_id": fid,
-            "panel": panel,
-            "plot_type": "line",
-            "n_points": len(x),
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-async def plot_box_handler(
-    data: list[list[float]],
-    figure_id: Optional[str] = None,
-    panel: str = "0,0",
-    labels: Optional[list[str]] = None,
-    colors: Optional[list[str]] = None,
-    xlabel: Optional[str] = None,
-    ylabel: Optional[str] = None,
-    title: Optional[str] = None,
-) -> dict:
-    """Create a box plot on specified panel."""
-    try:
-        fig, ax, fid = _get_axes(figure_id, panel)
-
-        bp = ax.boxplot(data, patch_artist=True, widths=0.6)
-
-        if colors is None:
-            colors = ["#007fbf", "#ff4433", "#14b514", "#c633ff", "#e25e33"]
-        for i, box in enumerate(bp["boxes"]):
-            box.set_facecolor(colors[i % len(colors)])
-
-        if labels:
-            ax.set_xticklabels(labels)
-        if xlabel:
-            ax.set_xlabel(xlabel)
-        if ylabel:
-            ax.set_ylabel(ylabel)
-        if title:
-            ax.set_title(title)
-
-        return {
-            "success": True,
-            "figure_id": fid,
-            "panel": panel,
-            "plot_type": "box",
-            "n_groups": len(data),
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-async def plot_violin_handler(
-    data: list[list[float]],
-    figure_id: Optional[str] = None,
-    panel: str = "0,0",
-    labels: Optional[list[str]] = None,
-    colors: Optional[list[str]] = None,
-    xlabel: Optional[str] = None,
-    ylabel: Optional[str] = None,
-    title: Optional[str] = None,
-) -> dict:
-    """Create a violin plot on specified panel."""
-    try:
-        fig, ax, fid = _get_axes(figure_id, panel)
-
-        positions = list(range(1, len(data) + 1))
-        vp = ax.violinplot(data, positions=positions, showmedians=True, widths=0.7)
-
-        if colors is None:
-            colors = ["#007fbf", "#ff4433", "#14b514", "#c633ff", "#e25e33"]
-        for i, body in enumerate(vp["bodies"]):
-            body.set_facecolor(colors[i % len(colors)])
-            body.set_alpha(0.6)
-
-        if labels:
-            ax.set_xticks(positions)
-            ax.set_xticklabels(labels)
-        if xlabel:
-            ax.set_xlabel(xlabel)
-        if ylabel:
-            ax.set_ylabel(ylabel)
-        if title:
-            ax.set_title(title)
-
-        return {
-            "success": True,
-            "figure_id": fid,
-            "panel": panel,
-            "plot_type": "violin",
-            "n_groups": len(data),
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-__all__ = [
-    "plot_bar_handler",
-    "plot_scatter_handler",
-    "plot_line_handler",
-    "plot_box_handler",
-    "plot_violin_handler",
-]
-
-# EOF