scitex 2.0.0__py2.py3-none-any.whl

scitex/plt/_subplots/_FigWrapper.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-19 02:53:28 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/plt/_subplots/_FigWrapper.py.new
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/_subplots/_FigWrapper.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+from functools import wraps
+import warnings
+import numpy as np
+import pandas as pd
+
+
+class FigWrapper:
+    def __init__(self, fig_mpl):
+        self._fig_mpl = fig_mpl
+        self._last_saved_info = None
+        self._not_saved_yet_flag = True
+        self._called_from_mng_io_save = False
+
+    @property
+    def figure(
+        self,
+    ):
+        return self._fig_mpl
+
+    def __getattr__(self, attr):
+        # print(f"Attribute of FigWrapper: {attr}")
+        attr_mpl = getattr(self._fig_mpl, attr)
+
+        if callable(attr_mpl):
+
+            @wraps(attr_mpl)
+            def wrapper(*args, track=None, id=None, **kwargs):
+                results = attr_mpl(*args, **kwargs)
+                # self._track(track, id, attr, args, kwargs)
+                return results
+
+            return wrapper
+
+        else:
+            return attr_mpl
+
+    def __dir__(self):
+        # Combine attributes from both self and the wrapped matplotlib figure
+        attrs = set(dir(self.__class__))
+        attrs.update(object.__dir__(self))
+        attrs.update(dir(self._fig_mpl))
+        return sorted(attrs)
+
+    # def savefig(self, fname, *args, **kwargs):
+    #     if not self._called_from_mng_io_save:
+    #         warnings.warn(
+    #             f"Instead of `FigWrapper.savefig({fname})`, use `scitex.io.save(fig, {fname}, symlink_from_cwd=True)` to handle symlink and export as csv.",
+    #             UserWarning,
+    #         )
+    #         self._called_from_mng_io_save = False
+    #     self._fig_mpl.savefig(fname, *args, **kwargs)
+
+    def export_as_csv(self):
+        """Export plotted data from all axes.
+        
+        This method collects data from all axes in the figure and combines 
+        them into a single DataFrame with appropriate axis identifiers in 
+        the column names.
+        
+        Returns:
+            pd.DataFrame: Combined DataFrame with data from all axes,
+                          with axis ID prefixes for each column.
+        """
+        dfs = []
+        
+        # Use the _traverse_axes helper method to iterate through all axes
+        # regardless of their structure (single, array, list, etc.)
+        for ii, ax in enumerate(self._traverse_axes()):
+            # Try different ways to access the export_as_csv method
+            df = None
+            try:
+                if hasattr(ax, '_axis_mpl') and hasattr(ax._axis_mpl, 'export_as_csv'):
+                    # If it's a nested structure with _axis_mpl having export_as_csv
+                    df = ax._axis_mpl.export_as_csv()
+                elif hasattr(ax, 'export_as_csv'):
+                    # Direct AxisWrapper object
+                    df = ax.export_as_csv()
+                else:
+                    # Skip if no export method available
+                    continue
+            except Exception:
+                continue
+            
+            # Process the DataFrame if it's not empty
+            if df is not None and not df.empty:
+                # Add axis ID prefix to column names if not already present
+                prefix = f"ax_{ii:02d}_"
+                df.columns = [
+                    col if col.startswith(prefix) else f"{prefix}{col}" 
+                    for col in df.columns
+                ]
+                dfs.append(df)
+        
+        # Return concatenated DataFrame or empty DataFrame if no data
+        return pd.concat(dfs, axis=1) if dfs else pd.DataFrame()
+    
+    def _traverse_axes(self):
+        """Helper method to traverse all axis wrappers in the figure."""
+        if hasattr(self, 'axes'):
+            # Check if we're dealing with an AxesWrapper instance
+            if hasattr(self.axes, '_axes_scitex') and hasattr(self.axes._axes_scitex, 'flat'):
+                # This is an AxesWrapper, get the individual AxisWrapper objects
+                for ax in self.axes._axes_scitex.flat:
+                    yield ax
+            elif not hasattr(self.axes, '__iter__'):
+                # Single axis case
+                yield self.axes
+            else:
+                # Multiple axes case
+                if hasattr(self.axes, 'flat'):
+                    # 2D array of axes
+                    for ax in self.axes.flat:
+                        yield ax
+                elif hasattr(self.axes, 'ravel'):
+                    # Numpy array
+                    for ax in self.axes.ravel():
+                        yield ax
+                elif isinstance(self.axes, (list, tuple)):
+                    # List of axes
+                    for ax in self.axes:
+                        yield ax
+
+    def legend(self, *args, loc="upper left", **kwargs):
+        """Legend with upper left by default for all axes."""
+        for ax in self._traverse_axes():
+            try:
+                ax.legend(*args, loc=loc, **kwargs)
+            except Exception as e:
+                pass
+
+    def supxyt(self, x=False, y=False, t=False):
+        """Wrapper for supxlabel, supylabel, and suptitle"""
+        if x is not False:
+            self._fig_mpl.supxlabel(x)
+        if y is not False:
+            self._fig_mpl.supylabel(y)
+        if t is not False:
+            self._fig_mpl.suptitle(t)
+        return self._fig_mpl
+
+    def tight_layout(self, *, rect=[0, 0.03, 1, 0.95], **kwargs):
+        """Wrapper for tight_layout with rect=[0, 0.03, 1, 0.95] by default.
+        
+        Handles cases where certain axes (like colorbars) are incompatible
+        with tight_layout. If the figure is using constrained_layout, this
+        method does nothing as constrained_layout handles spacing automatically.
+        """
+        import warnings
+        
+        # Check if figure is already using constrained_layout
+        if hasattr(self._fig_mpl, 'get_constrained_layout') and self._fig_mpl.get_constrained_layout():
+            # Figure is using constrained_layout, which handles colorbars better
+            # No need to call tight_layout
+            return
+        
+        try:
+            with warnings.catch_warnings():
+                # Suppress the specific warning about incompatible axes
+                warnings.filterwarnings("ignore", 
+                                      message="This figure includes Axes that are not compatible with tight_layout")
+                self._fig_mpl.tight_layout(rect=rect, **kwargs)
+        except Exception:
+            # If tight_layout fails completely, try constrained_layout as fallback
+            try:
+                self._fig_mpl.set_constrained_layout(True)
+                self._fig_mpl.set_constrained_layout_pads(w_pad=0.04, h_pad=0.04)
+            except Exception:
+                # If both fail, do nothing - figure will use default layout
+                pass
+
+    def adjust_layout(self, **kwargs):
+        """Adjust the constrained layout parameters.
+        
+        Parameters
+        ----------
+        w_pad : float, optional
+            Width padding around axes (default: 0.05)
+        h_pad : float, optional
+            Height padding around axes (default: 0.05)
+        wspace : float, optional
+            Width space between subplots (default: 0.02)
+        hspace : float, optional
+            Height space between subplots (default: 0.02)
+        rect : list of 4 floats, optional
+            Rectangle in normalized figure coordinates to fit the whole layout
+            [left, bottom, right, top] (default: [0, 0, 1, 1])
+        """
+        if hasattr(self._fig_mpl, 'get_constrained_layout') and self._fig_mpl.get_constrained_layout():
+            # Update constrained layout parameters
+            self._fig_mpl.set_constrained_layout_pads(**kwargs)
+        else:
+            # Fall back to tight_layout with rect parameter if provided
+            if 'rect' in kwargs:
+                self.tight_layout(rect=kwargs['rect'])
+    
+    def close(self):
+        """Close the underlying matplotlib figure"""
+        import matplotlib.pyplot as plt
+        plt.close(self._fig_mpl)
+    
+    @property 
+    def number(self):
+        """Return the figure number for matplotlib.pyplot.close() compatibility"""
+        return self._fig_mpl.number
+
+    def __del__(self):
+        """Cleanup when FigWrapper is deleted"""
+        try:
+            import matplotlib.pyplot as plt
+            plt.close(self._fig_mpl)
+        except:
+            pass
+
+
+# EOF

scitex/plt/_subplots/_SubplotsWrapper.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-29 03:46:53 (ywatanabe)"
+# File: /ssh:ywatanabe@sp:/home/ywatanabe/proj/scitex_repo/src/scitex/plt/_subplots/_SubplotsWrapper.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/_subplots/_SubplotsWrapper.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+from collections import OrderedDict
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from ._AxesWrapper import AxesWrapper
+from ._AxisWrapper import AxisWrapper
+from ._FigWrapper import FigWrapper
+
+
+class SubplotsWrapper:
+    """
+    A wrapper class monitors data plotted using the ax methods from matplotlib.pyplot.
+    This data can be converted into a CSV file formatted for SigmaPlot compatibility.
+    """
+
+    def __init__(self):
+        self._subplots_wrapper_history = OrderedDict()
+        self._fig_scitex = None
+        self._counter_part = plt.subplots
+
+    def __call__(self, *args, track=True, sharex=False, sharey=False, constrained_layout=None, **kwargs):
+
+        # If constrained_layout is not specified, use it by default for better colorbar handling
+        if constrained_layout is None and 'layout' not in kwargs:
+            # Use a dict to set padding parameters for better spacing
+            # Increased w_pad to prevent colorbar overlap
+            kwargs['constrained_layout'] = {'w_pad': 0.1, 'h_pad': 0.1, 'wspace': 0.05, 'hspace': 0.05}
+            
+        # Start from the original matplotlib figure and axes
+        self._fig_mpl, self._axes_mpl = self._counter_part(
+            *args, sharex=sharex, sharey=sharey, **kwargs
+        )
+
+        # Wrap the figure
+        self._fig_scitex = FigWrapper(self._fig_mpl)
+
+        # Ensure axes_mpl is always an array
+        axes_array_mpl = np.atleast_1d(self._axes_mpl)
+        axes_shape_mpl = axes_array_mpl.shape
+
+        # Handle single axis case
+        if axes_array_mpl.size == 1:
+            # Use squeeze() to get the scalar Axes object if it's a 0-d array
+            ax_mpl_scalar = (
+                axes_array_mpl.item() if axes_array_mpl.ndim == 0 else axes_array_mpl[0]
+            )
+            self._axis_scitex = AxisWrapper(self._fig_scitex, ax_mpl_scalar, track)
+            self._fig_scitex.axes = np.atleast_1d([self._axis_scitex])
+            return self._fig_scitex, self._axis_scitex
+
+        # Handle multiple axes case
+        axes_flat_mpl = axes_array_mpl.ravel()
+        axes_flat_scitex_list = [
+            AxisWrapper(self._fig_scitex, ax_, track) for ax_ in axes_flat_mpl
+        ]
+
+        # Reshape the axes_flat_scitex_list axes to match the original layout
+        axes_array_scitex = np.array(axes_flat_scitex_list).reshape(axes_shape_mpl)
+
+        # Wrap the array of axes
+        self._axes_scitex = AxesWrapper(self._fig_scitex, axes_array_scitex)
+        self._fig_scitex.axes = self._axes_scitex
+        return self._fig_scitex, self._axes_scitex
+
+    # def __getattr__(self, name):
+    #     """
+    #     Fallback to fetch attributes from the original matplotlib.pyplot.subplots function
+    #     if they are not defined directly in this wrapper instance.
+    #     This allows accessing attributes like __name__, __doc__ etc. from the original function.
+    #     """
+    #     print(f"Attribute of SubplotsWrapper: {name}")
+    #     # Check if the attribute exists in the counterpart function
+    #     if hasattr(self._counter_part, name):
+    #         return getattr(self._counter_part, name)
+    #     # Raise the standard error if not found in the wrapper or the counterpart
+    #     raise AttributeError(
+    #         f"'{type(self).__name__}' object and its counterpart '{self._counter_part.__name__}' have no attribute '{name}'"
+    #     )
+
+    def __dir__(
+        self,
+    ):
+        """
+        Provide combined directory for tab completion, including
+        attributes from this wrapper and the original matplotlib.pyplot.subplots function.
+        """
+        # Get attributes defined explicitly in this instance/class
+        local_attrs = set(super().__dir__())
+        # Get attributes from the counterpart function
+        try:
+            counterpart_attrs = set(dir(self._counter_part))
+        except Exception:
+            counterpart_attrs = set()
+        # Return the sorted union
+        return sorted(local_attrs.union(counterpart_attrs))
+
+
+# Instantiate the wrapper. This instance will be imported and used.
+subplots = SubplotsWrapper()
+
+if __name__ == "__main__":
+    import matplotlib
+    import scitex
+
+    matplotlib.use("TkAgg")  # "TkAgg"
+
+    fig, ax = subplots()
+    ax.plot([1, 2, 3], [4, 5, 6], id="plot1")
+    ax.plot([4, 5, 6], [1, 2, 3], id="plot2")
+    scitex.io.save(fig, "/tmp/subplots_demo/plots.png")
+
+    # Behaves like native matplotlib.pyplot.subplots without tracking
+    fig, ax = subplots(track=False)
+    ax.plot([1, 2, 3], [4, 5, 6], id="plot3")
+    ax.plot([4, 5, 6], [1, 2, 3], id="plot4")
+    scitex.io.save(fig, "/tmp/subplots_demo/plots.png")
+
+    fig, ax = subplots()
+    ax.scatter([1, 2, 3], [4, 5, 6], id="scatter1")
+    ax.scatter([4, 5, 6], [1, 2, 3], id="scatter2")
+    scitex.io.save(fig, "/tmp/subplots_demo/scatters.png")
+
+    fig, ax = subplots()
+    ax.boxplot([1, 2, 3], id="boxplot1")
+    scitex.io.save(fig, "/tmp/subplots_demo/boxplot1.png")
+
+    fig, ax = subplots()
+    ax.bar(["A", "B", "C"], [4, 5, 6], id="bar1")
+    scitex.io.save(fig, "/tmp/subplots_demo/bar1.png")
+
+    print(ax.export_as_csv())
+    #    plot1_plot_x  plot1_plot_y  plot2_plot_x  ...  boxplot1_boxplot_x  bar1_bar_x  bar1_bar_y
+    # 0           1.0           4.0           4.0  ...                 1.0           A         4.0
+    # 1           2.0           5.0           5.0  ...                 2.0           B         5.0
+    # 2           3.0           6.0           6.0  ...                 3.0           C         6.0
+
+    print(ax.export_as_csv().keys())  # plot3 and plot 4 are not tracked
+    # [3 rows x 11 columns]
+    # Index(['plot1_plot_x', 'plot1_plot_y', 'plot2_plot_x', 'plot2_plot_y',
+    #        'scatter1_scatter_x', 'scatter1_scatter_y', 'scatter2_scatter_x',
+    #        'scatter2_scatter_y', 'boxplot1_boxplot_x', 'bar1_bar_x', 'bar1_bar_y'],
+    #       dtype='object')
+
+    # If a path is passed, the sigmaplot-friendly dataframe is saved as a csv file.
+    ax.export_as_csv("./tmp/subplots_demo/for_sigmaplot.csv")
+    # Saved to: ./tmp/subplots_demo/for_sigmaplot.csv
+
+"""
+from matplotlib.pyplot import subplots as counter_part
+from scitex.plt import subplots as msubplots
+print(set(dir(msubplots)) - set(dir(counter_part)))
+is_compatible = np.all([kk in set(dir(msubplots)) for kk in set(dir(counter_part))])
+if is_compatible:
+    print(f"{msubplots.__name__} is compatible with {counter_part.__name__}")
+else:
+    print(f"{msubplots.__name__} is incompatible with {counter_part.__name__}")
+"""
+
+# EOF

scitex/plt/_subplots/__init__.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-18 05:22:40 (ywatanabe)"
+# File: /home/ywatanabe/proj/_scitex_repo/src/scitex/plt/_subplots/__init__.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/_subplots/__init__.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+# Import export_as_csv module functions
+from ._export_as_csv import export_as_csv, format_record
+
+# Import formatters for backward compatibility
+from ._export_as_csv_formatters import (
+    _format_plot_kde,
+    _format_plot_line,
+    _format_plot_conf_mat,
+    _format_plot_mean_std,
+    _format_plot_ecdf,
+    _format_plot_raster,
+    _format_plot_joyplot,
+    _format_plot,
+    _format_scatter,
+    _format_bar,
+    _format_hist,
+    _format_boxplot,
+    _format_errorbar,
+    _format_fill_between,
+    _format_imshow,
+    _format_violin,
+    _format_sns_boxplot,
+)
+
+# import importlib
+# import inspect
+
+# # Get the current directory
+# current_dir = os.path.dirname(__file__)
+
+# # Iterate through all Python files in the current directory
+# for filename in os.listdir(current_dir):
+#     if filename.endswith(".py") and not filename.startswith("__"):
+#         module_name = filename[:-3]  # Remove .py extension
+#         module = importlib.import_module(f".{module_name}", package=__name__)
+
+#         # Import only functions and classes from the module
+#         for name, obj in inspect.getmembers(module):
+#             if inspect.isfunction(obj) or inspect.isclass(obj):
+#                 if not name.startswith("_"):
+#                     globals()[name] = obj
+
+# # Clean up temporary variables
+# del (
+#     os,
+#     importlib,
+#     inspect,
+#     current_dir,
+#     filename,
+#     module_name,
+#     module,
+#     name,
+#     obj,
+# )
+
+# ################################################################################
+# # For Matplotlib Compatibility
+# ################################################################################
+# import matplotlib.pyplot.subplots as counter_part
+
+# _local_module_attributes = list(globals().keys())
+# print(_local_module_attributes)
+
+
+# def __getattr__(name):
+#     """
+#     Fallback to fetch attributes from matplotlib.pyplot
+#     if they are not defined directly in this module.
+#     """
+#     try:
+#         # Get the attribute from matplotlib.pyplot
+#         return getattr(counter_part, name)
+#     except AttributeError:
+#         # Raise the standard error if not found in pyplot either
+#         raise AttributeError(
+#             f"module '{__name__}' nor matplotlib.pyplot has attribute '{name}'"
+#         ) from None
+
+
+# def __dir__():
+#     """
+#     Provide combined directory for tab completion, including
+#     attributes from this module and matplotlib.pyplot.
+#     """
+#     # Get attributes defined explicitly in this module
+#     local_attrs = set(_local_module_attributes)
+#     # Get attributes from matplotlib.pyplot
+#     pyplot_attrs = set(dir(counter_part))
+#     # Return the sorted union
+#     return sorted(local_attrs.union(pyplot_attrs))
+
+
+"""
+import matplotlib.pyplot as plt
+import scitex.plt as mplt
+
+print(set(dir(mplt.subplots)) - set(dir(plt.subplots)))
+"""
+
+# EOF