scitex 2.0.0__py2.py3-none-any.whl

scitex/plt/ax/_plot/_plot_violin.py

@@ -0,0 +1,343 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-02 22:01:54 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/ax/_plot/_plot_violin.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/ax/_plot/_plot_violin.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from ....plt.utils import assert_valid_axis
+
+
+def plot_violin(
+    ax,
+    data_list,
+    labels=None,
+    colors=None,
+    half=False,
+    **kwargs,
+):
+    """
+    Plot a violin plot using seaborn.
+
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper
+        The axes to plot on
+    data_list : list
+        List of arrays to plot as violins
+    labels : list, optional
+        Labels for each array in data_list
+    colors : list, optional
+        Colors for each violin
+    half : bool, optional
+        If True, plots only the left half of the violins, default False
+    **kwargs
+        Additional keyword arguments passed to seaborn.violinplot
+
+    Returns
+    -------
+    ax : matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper
+        The axes object with the plot
+    """
+    # Convert list-style data to DataFrame
+    all_values = []
+    all_groups = []
+
+    for idx, values in enumerate(data_list):
+        all_values.extend(values)
+        group_label = labels[idx] if labels and idx < len(labels) else f"x {idx}"
+        all_groups.extend([group_label] * len(values))
+
+    # Create DataFrame
+    df = pd.DataFrame({"x": all_groups, "y": all_values})
+
+    # Setup colors if provided
+    if colors:
+        if isinstance(colors, list):
+            kwargs["palette"] = {
+                group: color
+                for group, color in zip(set(all_groups), colors[: len(set(all_groups))])
+            }
+        else:
+            kwargs["palette"] = colors
+
+    # Call seaborn-based function
+    return sns_plot_violin(ax, data=df, x="x", y="y", hue="x", half=half, **kwargs)
+
+
+def sns_plot_violin(ax, data=None, x=None, y=None, hue=None, half=False, **kwargs):
+    """
+    Plot a violin plot with option for half violins.
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper
+        The axes to plot on
+    data : DataFrame
+        The dataframe containing the data
+    x : str
+        Column name for x-axis variable
+    y : str
+        Column name for y-axis variable
+    hue : str, optional
+        Column name for hue variable
+    half : bool, optional
+        If True, plots only the left half of the violins, default False
+    **kwargs
+        Additional keyword arguments passed to seaborn.violinplot
+    Returns
+    -------
+    ax : matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper
+        The axes object with the plot
+    """
+    assert_valid_axis(ax, "First argument must be a matplotlib axis or scitex axis wrapper")
+
+    if not half:
+        # Standard violin plot
+        return sns.violinplot(data=data, x=x, y=y, hue=hue, ax=ax, **kwargs)
+
+    # Create a copy of the dataframe to avoid modifying the original
+    df = data.copy()
+
+    # If no hue provided, create default hue
+    if hue is None:
+        df["_hue"] = "default"
+        hue = "_hue"
+
+    # Add fake hue for the right side
+    df["_fake_hue"] = df[hue] + "_right"
+
+    # Adjust hue_order and palette if provided
+    if "hue_order" in kwargs:
+        kwargs["hue_order"] = kwargs["hue_order"] + [
+            h + "_right" for h in kwargs["hue_order"]
+        ]
+    else:
+        kwargs["hue_order"] = []
+        for group in df[x].unique().tolist():
+            kwargs["hue_order"].append(group)
+            kwargs["hue_order"].append(group + "_right")
+
+    if "palette" in kwargs:
+        palette = kwargs["palette"]
+        if isinstance(palette, dict):
+            kwargs["palette"] = {
+                **palette,
+                **{k + "_right": v for k, v in palette.items()},
+            }
+        elif isinstance(palette, list):
+            kwargs["palette"] = palette + palette
+
+    # Conc left and right
+    df_left = df[[x, y]]
+    df_right = df[["_fake_hue", y]].rename(columns={"_fake_hue": x})
+    df_right[y] = [np.nan for _ in range(len(df_right))]
+    df_conc = pd.concat([df_left, df_right], axis=0, ignore_index=True)
+    df_conc = df_conc.sort_values(x)
+
+    # Plot
+    sns.violinplot(data=df_conc, x=x, y=y, hue="x", split=True, ax=ax, **kwargs)
+
+    # Remove right half of violins
+    for collection in ax.collections:
+        if isinstance(collection, plt.matplotlib.collections.PolyCollection):
+            collection.set_clip_path(None)
+
+    # Adjust legend
+    if ax.legend_ is not None:
+        handles, labels = ax.get_legend_handles_labels()
+        ax.legend(handles[: len(handles) // 2], labels[: len(labels) // 2])
+
+    return ax
+
+
+# def _plot_half_violin(ax, data=None, x=None, y=None, hue=None, **kwargs):
+
+#     assert isinstance(
+#         ax, matplotlib.axes._axes.Axes
+#     ), "First argument must be a matplotlib axis"
+
+#     # Prepare data
+#     df = data.copy()
+#     if hue is None:
+#         df["_hue"] = "default"
+#         hue = "_hue"
+
+#     # Add fake hue for the right side
+#     df["_fake_hue"] = df[hue] + "_right"
+
+#     # Adjust hue_order and palette if provided
+#     if "hue_order" in kwargs:
+#         kwargs["hue_order"] = kwargs["hue_order"] + [
+#             h + "_right" for h in kwargs["hue_order"]
+#         ]
+
+#     if "palette" in kwargs:
+#         palette = kwargs["palette"]
+#         if isinstance(palette, dict):
+#             kwargs["palette"] = {
+#                 **palette,
+#                 **{k + "_right": v for k, v in palette.items()},
+#             }
+#         elif isinstance(palette, list):
+#             kwargs["palette"] = palette + palette
+
+#     # Plot
+#     sns.violinplot(
+#         data=df, x=x, y=y, hue="_fake_hue", split=True, ax=ax, **kwargs
+#     )
+
+#     # Remove right half of violins
+#     for collection in ax.collections:
+#         if isinstance(collection, plt.matplotlib.collections.PolyCollection):
+#             collection.set_clip_path(None)
+
+#     # Adjust legend
+#     if ax.legend_ is not None:
+#         handles, labels = ax.get_legend_handles_labels()
+#         ax.legend(handles[: len(handles) // 2], labels[: len(labels) // 2])
+
+#     return ax
+
+# import matplotlib
+# import matplotlib.pyplot as plt
+# import seaborn as sns
+
+# def plot_violin_half(ax, data=None, x=None, y=None, hue=None, **kwargs):
+#     """
+#     Plot a half violin plot (showing only the left side of violins).
+
+#     Parameters
+#     ----------
+#     ax : matplotlib.axes.Axes
+#         The axes to plot on
+#     data : DataFrame
+#         The dataframe containing the data
+#     x : str
+#         Column name for x-axis variable
+#     y : str
+#         Column name for y-axis variable
+#     hue : str, optional
+#         Column name for hue variable
+#     **kwargs
+#         Additional keyword arguments passed to seaborn.violinplot
+
+#     Returns
+#     -------
+#     ax : matplotlib.axes.Axes
+#         The axes object with the plot
+#     """
+#     assert isinstance(
+#         ax, matplotlib.axes._axes.Axes
+#     ), "First argument must be a matplotlib axis"
+
+#     # Prepare data
+#     df = data.copy()
+#     if hue is None:
+#         df["_hue"] = "default"
+#         hue = "_hue"
+
+#     # Add fake hue for the right side
+#     df["_fake_hue"] = df[hue] + "_right"
+
+#     # Adjust hue_order and palette if provided
+#     if "hue_order" in kwargs:
+#         kwargs["hue_order"] = kwargs["hue_order"] + [
+#             h + "_right" for h in kwargs["hue_order"]
+#         ]
+#     if "palette" in kwargs:
+#         palette = kwargs["palette"]
+#         if isinstance(palette, dict):
+#             kwargs["palette"] = {
+#                 **palette,
+#                 **{k + "_right": v for k, v in palette.items()},
+#             }
+#         elif isinstance(palette, list):
+#             kwargs["palette"] = palette + palette
+
+#     # Plot
+#     sns.violinplot(
+#         data=df, x=x, y=y, hue="_fake_hue", split=True, ax=ax, **kwargs
+#     )
+
+#     # Remove right half of violins
+#     for collection in ax.collections:
+#         if isinstance(collection, matplotlib.collections.PolyCollection):
+#             collection.set_clip_path(None)
+
+#     # Adjust legend
+#     if ax.legend_ is not None:
+#         handles, labels = ax.get_legend_handles_labels()
+#         ax.legend(handles[: len(handles) // 2], labels[: len(labels) // 2])
+
+#     return ax
+
+
+## Probably working
+def half_violin(ax, data=None, x=None, y=None, hue=None, **kwargs):
+    # Prepare data
+    df = data.copy()
+    if hue is None:
+        df["_hue"] = "default"
+        hue = "_hue"
+
+    # Add fake hue for the right side
+    df["_fake_hue"] = df[hue] + "_right"
+
+    # Adjust hue_order and palette if provided
+    if "hue_order" in kwargs:
+        kwargs["hue_order"] = kwargs["hue_order"] + [
+            h + "_right" for h in kwargs["hue_order"]
+        ]
+
+    if "palette" in kwargs:
+        palette = kwargs["palette"]
+        if isinstance(palette, dict):
+            kwargs["palette"] = {
+                **palette,
+                **{k + "_right": v for k, v in palette.items()},
+            }
+        elif isinstance(palette, list):
+            kwargs["palette"] = palette + palette
+
+    # Plot
+    sns.violinplot(data=df, x=x, y=y, hue="_fake_hue", split=True, ax=ax, **kwargs)
+
+    # Remove right half of violins
+    for collection in ax.collections:
+        if isinstance(collection, plt.matplotlib.collections.PolyCollection):
+            collection.set_clip_path(None)
+
+    # Adjust legend
+    if ax.legend_ is not None:
+        handles, labels = ax.get_legend_handles_labels()
+        ax.legend(handles[: len(handles) // 2], labels[: len(labels) // 2])
+
+    return ax
+
+
+# import scitex
+# import numpy as np
+# fig, ax = scitex.plt.subplots()
+# # Test with list data
+# data_list = [
+#     np.random.normal(0, 1, 100),
+#     np.random.normal(2, 1.5, 100),
+#     np.random.normal(5, 0.8, 100),
+# ]
+# labels = ["x A", "x B", "x C"]
+# colors = ["red", "blue", "green"]
+# half = True
+# ax = half_violin(
+#     ax, data_list, x=""
+# )
+
+# EOF

scitex/plt/ax/_style/__init__.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-02 09:00:59 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/ax/_style/__init__.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/ax/_style/__init__.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+from ._add_marginal_ax import add_marginal_ax
+from ._add_panel import add_panel
+from ._extend import extend
+from ._force_aspect import force_aspect
+from ._format_label import format_label
+from ._hide_spines import hide_spines
+from ._map_ticks import map_ticks
+from ._rotate_labels import rotate_labels
+from ._sci_note import sci_note, OOMFormatter
+from ._set_n_ticks import set_n_ticks
+from ._set_size import set_size
+from ._set_supxyt import set_supxyt, set_supxytc
+from ._set_ticks import set_ticks
+from ._set_xyt import set_xyt, set_xytc
+from ._set_meta import set_meta, set_figure_meta, export_metadata_yaml
+from ._share_axes import (
+    sharexy,
+    sharex,
+    sharey,
+    get_global_xlim,
+    get_global_ylim,
+    set_xlims,
+    set_ylims,
+)
+from ._shift import shift
+
+# EOF

scitex/plt/ax/_style/_add_marginal_ax.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-04-30 20:18:52 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/ax/_add_marginal_ax.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/ax/_add_marginal_ax.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import matplotlib
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+from ....plt.utils import assert_valid_axis
+
+
+def add_marginal_ax(axis, place, size=0.2, pad=0.1):
+    """
+    Add a marginal axis to the specified side of an existing axis.
+    
+    Arguments:
+        axis (matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper): The axis to which a marginal axis will be added.
+        place (str): Where to place the marginal axis ('top', 'right', 'bottom', or 'left').
+        size (float, optional): Fractional size of the marginal axis relative to the main axis. Defaults to 0.2.
+        pad (float, optional): Padding between the axes. Defaults to 0.1.
+        
+    Returns:
+        matplotlib.axes.Axes: The newly created marginal axis.
+    """
+    assert_valid_axis(axis, "First argument must be a matplotlib axis or scitex axis wrapper")
+
+    divider = make_axes_locatable(axis)
+
+    size_perc_str = f"{size*100}%"
+    if place in ["left", "right"]:
+        size = 1.0 / size
+
+    axis_marginal = divider.append_axes(place, size=size_perc_str, pad=pad)
+    axis_marginal.set_box_aspect(size)
+
+    return axis_marginal
+
+
+# EOF

scitex/plt/ax/_style/_add_panel.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-04-30 21:24:49 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/ax/_panel.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/ax/_panel.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+# Time-stamp: "2024-02-03 15:34:08 (ywatanabe)"
+
+import matplotlib.pyplot as plt
+from scitex.decorators import deprecated
+
+
+def add_panel(tgt_width_mm=40, tgt_height_mm=None):
+    """Creates a fixed-size ax figure for panels."""
+
+    H_TO_W_RATIO = 0.7
+    MM_TO_INCH_FACTOR = 1 / 25.4
+
+    if tgt_height_mm is None:
+        tgt_height_mm = H_TO_W_RATIO * tgt_width_mm
+
+    # Convert target dimensions from millimeters to inches
+    tgt_width_in = tgt_width_mm * MM_TO_INCH_FACTOR
+    tgt_height_in = tgt_height_mm * MM_TO_INCH_FACTOR
+
+    # Create a figure with the specified dimensions
+    fig = plt.figure(figsize=(tgt_width_in * 2, tgt_height_in * 2))
+
+    # Calculate the position and size of the axes in figure units (0 to 1)
+    left = (fig.get_figwidth() - tgt_width_in) / 2 / fig.get_figwidth()
+    bottom = (fig.get_figheight() - tgt_height_in) / 2 / fig.get_figheight()
+    ax = fig.add_axes(
+        [
+            left,
+            bottom,
+            tgt_width_in / fig.get_figwidth(),
+            tgt_height_in / fig.get_figheight(),
+        ]
+    )
+
+    return fig, ax
+
+
+@deprecated("Use add_panel instead")
+def panel(tgt_width_mm=40, tgt_height_mm=None):
+    """Create a figure panel with specified dimensions (deprecated).
+
+    This function is deprecated and maintained only for backward compatibility.
+    Please use `add_panel` instead.
+
+    Parameters
+    ----------
+    tgt_width_mm : float, optional
+        Target width in millimeters. Default is 40.
+    tgt_height_mm : float or None, optional
+        Target height in millimeters. If None, uses golden ratio.
+        Default is None.
+
+    Returns
+    -------
+    tuple
+        (fig, ax) - matplotlib figure and axes objects
+
+    See Also
+    --------
+    add_panel : The recommended function to use instead
+
+    Examples
+    --------
+    >>> # Deprecated usage
+    >>> fig, ax = panel(tgt_width_mm=40, tgt_height_mm=30)
+
+    >>> # Recommended alternative
+    >>> fig, ax = add_panel(tgt_width_mm=40, tgt_height_mm=30)
+    """
+    return add_panel(tgt_width_mm=40, tgt_height_mm=None)
+
+
+if __name__ == "__main__":
+    # Example usage:
+    fig, ax = panel(tgt_width_mm=40, tgt_height_mm=40 * 0.7)
+    ax.plot([1, 2, 3], [4, 5, 6])
+    ax.scatter([1, 2, 3], [4, 5, 6])
+    # ... compatible with other ax plotting methods as well
+    plt.show()
+
+# EOF

scitex/plt/ax/_style/_extend.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-02 09:00:51 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/ax/_style/_extend.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/ax/_style/_extend.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import matplotlib
+from ....plt.utils import assert_valid_axis
+
+
+def extend(axis, x_ratio=1.0, y_ratio=1.0):
+    """
+    Extend or shrink a matplotlib axis or scitex axis wrapper while maintaining its center position.
+
+    Args:
+        axis (matplotlib.axes._axes.Axes or scitex.plt._subplots.AxisWrapper): The axis to be modified.
+        x_ratio (float, optional): The ratio to scale the width. Default is 1.0.
+        y_ratio (float, optional): The ratio to scale the height. Default is 1.0.
+
+    Returns:
+        matplotlib.axes._axes.Axes or scitex.plt._subplots.AxisWrapper: The modified axis.
+
+    Raises:
+        AssertionError: If the first argument is not a valid axis.
+    """
+
+    assert_valid_axis(axis, "First argument must be a matplotlib axis or scitex axis wrapper")
+
+    assert x_ratio != 0, "x_ratio must not be 0."
+    assert y_ratio != 0, "y_ratio must not be 0."
+
+    ## Original coordinates
+    bbox = axis.get_position()
+    left_orig = bbox.x0
+    bottom_orig = bbox.y0
+    width_orig = bbox.x1 - bbox.x0
+    height_orig = bbox.y1 - bbox.y0
+    g_orig = (left_orig + width_orig / 2.0, bottom_orig + height_orig / 2.0)
+
+    ## Target coordinates
+    g_tgt = g_orig
+    width_tgt = width_orig * x_ratio
+    height_tgt = height_orig * y_ratio
+    left_tgt = g_tgt[0] - width_tgt / 2
+    bottom_tgt = g_tgt[1] - height_tgt / 2
+
+    # Extend the axis
+    axis.set_position(
+        [
+            left_tgt,
+            bottom_tgt,
+            width_tgt,
+            height_tgt,
+        ]
+    )
+    return axis
+
+
+# EOF

scitex/plt/ax/_style/_force_aspect.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-02 09:00:52 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/ax/_style/_force_aspect.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/ax/_style/_force_aspect.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import matplotlib
+from ....plt.utils import assert_valid_axis
+
+
+def force_aspect(axis, aspect=1):
+    """
+    Forces aspect ratio of an axis based on the extent of the image.
+    
+    Arguments:
+        axis (matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper): The axis to adjust.
+        aspect (float, optional): The aspect ratio to apply. Defaults to 1.
+        
+    Returns:
+        matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper: The axis with adjusted aspect ratio.
+    """
+    assert_valid_axis(axis, "First argument must be a matplotlib axis or scitex axis wrapper")
+
+    im = axis.get_images()
+
+    extent = im[0].get_extent()
+
+    axis.set_aspect(abs((extent[1] - extent[0]) / (extent[3] - extent[2])) / aspect)
+    return axis
+
+
+# EOF

scitex/plt/ax/_style/_format_label.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-09-15 09:39:02 (ywatanabe)"
+# /home/ywatanabe/proj/_scitex_repo_openhands/src/scitex/plt/ax/_format_label.py
+
+
+def format_label(label):
+    """
+    Format label by capitalizing first letter and replacing underscores with spaces.
+    """
+
+    # if isinstance(label, str):
+    #     # Replace underscores with spaces
+    #     label = label.replace("_", " ")
+
+    #     # Capitalize first letter of each word
+    #     label = " ".join(word.capitalize() for word in label.split())
+
+    #     # Special case for abbreviations (all caps)
+    #     if label.isupper():
+    #         return label
+
+    return label