scitex 2.0.0__py2.py3-none-any.whl → 2.1.0__py2.py3-none-any.whl

scitex/plt/__init__.py

@@ -4,9 +4,7 @@
 # File: /ssh:sp:/home/ywatanabe/proj/SciTeX-Code/src/scitex/plt/__init__.py
 # ----------------------------------------
 import os
-__FILE__ = (
-    "./src/scitex/plt/__init__.py"
-)
+__FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 """Scitex plt module."""
@@ -14,23 +12,134 @@ __DIR__ = os.path.dirname(__FILE__)
 from ._tpl import termplot
 from . import color
 from . import utils
+from . import ax
 
 # Lazy import for subplots to avoid circular dependencies
 _subplots = None
+_figure = None
 
 def subplots(*args, **kwargs):
     """Lazy-loaded subplots function."""
     global _subplots
     if _subplots is None:
-        from ._subplots._SubplotsWrapper import subplots as _subplots_impl
-        _subplots = _subplots_impl
+        from ._subplots._SubplotsWrapper import subplots as _subplots_func
+        _subplots = _subplots_func
     return _subplots(*args, **kwargs)
 
+def figure(*args, **kwargs):
+    """Lazy-loaded figure function that returns a FigWrapper."""
+    global _figure
+    if _figure is None:
+        import matplotlib.pyplot as plt
+        from ._subplots._FigWrapper import FigWrapper
+        def _figure_func(*args, **kwargs):
+            fig_mpl = plt.figure(*args, **kwargs)
+            return FigWrapper(fig_mpl)
+        _figure = _figure_func
+    return _figure(*args, **kwargs)
+
+def tight_layout(**kwargs):
+    """
+    Wrapper for matplotlib.pyplot.tight_layout that suppresses the layout change warning.
+
+    This function calls tight_layout on the current figure and suppresses the common
+    UserWarning: "The figure layout has changed to tight" which is informational
+    and typically not actionable.
+
+    Parameters
+    ----------
+    **kwargs
+        All keyword arguments are passed to matplotlib.pyplot.tight_layout()
+    """
+    import warnings
+    import matplotlib.pyplot as plt
+
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", message="The figure layout has changed to tight")
+        plt.tight_layout(**kwargs)
+
+
+def colorbar(mappable=None, cax=None, ax=None, **kwargs):
+    """
+    Create a colorbar, automatically unwrapping SciTeX AxisWrapper objects.
+
+    This function handles both regular matplotlib axes and SciTeX AxisWrapper
+    objects transparently, making it a drop-in replacement for plt.colorbar().
+
+    Parameters
+    ----------
+    mappable : ScalarMappable, optional
+        The image, contour set, etc. to which the colorbar applies.
+        If None, uses the current image.
+    cax : Axes, optional
+        Axes into which the colorbar will be drawn.
+    ax : Axes or AxisWrapper or list thereof, optional
+        Parent axes from which space for the colorbar will be stolen.
+        If None, uses current axes.
+    **kwargs
+        Additional keyword arguments passed to matplotlib.pyplot.colorbar()
+
+    Returns
+    -------
+    Colorbar
+        The created colorbar object
+    """
+    import matplotlib.pyplot as plt
+
+    # Unwrap ax if it's a SciTeX AxisWrapper
+    if ax is not None:
+        if hasattr(ax, '__iter__') and not isinstance(ax, str):
+            # Handle list/array of axes
+            ax = [a._axis_mpl if hasattr(a, '_axis_mpl') else a for a in ax]
+        else:
+            # Single axis
+            ax = ax._axis_mpl if hasattr(ax, '_axis_mpl') else ax
+
+    # Unwrap cax if provided
+    if cax is not None:
+        cax = cax._axis_mpl if hasattr(cax, '_axis_mpl') else cax
+
+    # Call matplotlib's colorbar with unwrapped axes
+    return plt.colorbar(mappable=mappable, cax=cax, ax=ax, **kwargs)
+
 __all__ = [
     "termplot",
     "subplots",
+    "figure",
+    "tight_layout",
     "utils",
     "color",
 ]
 
+def __getattr__(name):
+    """
+    Fallback to matplotlib.pyplot for any missing attributes.
+    This makes scitex.plt a complete drop-in replacement for matplotlib.pyplot.
+    """
+    try:
+        import matplotlib.pyplot as plt
+        if hasattr(plt, name):
+            return getattr(plt, name)
+        else:
+            raise AttributeError(f"module 'scitex.plt' has no attribute '{name}'")
+    except ImportError:
+        raise AttributeError(f"module 'scitex.plt' has no attribute '{name}' (matplotlib not available)")
+
+def __dir__():
+    """
+    Provide comprehensive directory listing including matplotlib.pyplot functions.
+    """
+    # Get local attributes
+    local_attrs = __all__.copy()
+
+    # Add matplotlib.pyplot attributes
+    try:
+        import matplotlib.pyplot as plt
+        mpl_attrs = [attr for attr in dir(plt) if not attr.startswith('_')]
+        local_attrs.extend(mpl_attrs)
+    except ImportError:
+        pass
+
+    return sorted(set(local_attrs))
+
 # EOF

scitex/plt/_subplots/_AxesWrapper.py

@@ -4,9 +4,7 @@
 # File: /ssh:ywatanabe@sp:/home/ywatanabe/proj/scitex_repo/src/scitex/plt/_subplots/_AxesWrapper.py
 # ----------------------------------------
 import os
-__FILE__ = (
-    "./src/scitex/plt/_subplots/_AxesWrapper.py"
-)
+__FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 

scitex/plt/_subplots/_AxisWrapper.py

@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # Timestamp: "2025-05-01 17:11:28 (ywatanabe)"
-# File: /home/ywatanabe/proj/_scitex_repo/src/scitex/plt/_subplots/_AxisWrapper.py
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/_subplots/_AxisWrapper.py
 # ----------------------------------------
 import os
 
-__FILE__ = "./src/scitex/plt/_subplots/_AxisWrapper.py"
+__FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -19,10 +19,11 @@ from ._AxisWrapperMixins import (
     MatplotlibPlotMixin,
     SeabornMixin,
     TrackingMixin,
+    UnitAwareMixin,
 )
 
 
-class AxisWrapper(MatplotlibPlotMixin, SeabornMixin, AdjustmentMixin, TrackingMixin):
+class AxisWrapper(MatplotlibPlotMixin, SeabornMixin, AdjustmentMixin, TrackingMixin, UnitAwareMixin):
     def __init__(self, fig_scitex, axis_mpl, track):
         """Initialize the AxisWrapper.
         
@@ -50,6 +51,9 @@ class AxisWrapper(MatplotlibPlotMixin, SeabornMixin, AdjustmentMixin, TrackingMi
         self.track = track
         self.id = 0
         self._counter_part = matplotlib.axes.Axes
+        
+        # Initialize unit awareness
+        UnitAwareMixin.__init__(self)
 
     def get_figure(self, root=True):
         """Get the figure, compatible with matplotlib 3.8+"""

scitex/plt/_subplots/_AxisWrapperMixins/_AdjustmentMixin.py

@@ -4,9 +4,7 @@
 # File: /ssh:ywatanabe@sp:/home/ywatanabe/proj/.claude-worktree/scitex_repo/src/scitex/plt/_subplots/_AxisWrapperMixins/_AdjustmentMixin.py
 # ----------------------------------------
 import os
-__FILE__ = (
-    "./src/scitex/plt/_subplots/_AxisWrapperMixins/_AdjustmentMixin.py"
-)
+__FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -20,20 +18,55 @@ class AdjustmentMixin:
 
     def rotate_labels(
         self,
-        x: float = 30,
-        y: float = 30,
-        x_ha: str = "right",
-        y_ha: str = "center",
+        x: float = None,
+        y: float = None,
+        x_ha: str = None,
+        y_ha: str = None,
+        x_va: str = None,
+        y_va: str = None,
+        auto_adjust: bool = True,
+        scientific_convention: bool = True,
+        tight_layout: bool = False,
     ) -> None:
+        """Rotate x and y axis labels with automatic positioning.
+        
+        Parameters
+        ----------
+        x : float or None, optional
+            Rotation angle for x-axis labels in degrees. 
+            If None or 0, x-axis labels are not rotated. Default is None.
+        y : float or None, optional
+            Rotation angle for y-axis labels in degrees.
+            If None or 0, y-axis labels are not rotated. Default is None.
+        x_ha : str or None, optional
+            Horizontal alignment for x-axis labels. If None, automatically determined.
+        y_ha : str or None, optional
+            Horizontal alignment for y-axis labels. If None, automatically determined.
+        x_va : str or None, optional
+            Vertical alignment for x-axis labels. If None, automatically determined.
+        y_va : str or None, optional
+            Vertical alignment for y-axis labels. If None, automatically determined.
+        auto_adjust : bool, optional
+            Whether to automatically adjust alignment. Default is True.
+        scientific_convention : bool, optional
+            Whether to follow scientific conventions. Default is True.
+        tight_layout : bool, optional
+            Whether to apply tight_layout to prevent overlapping. Default is False.
+        """
         self._axis_mpl = ax_module.rotate_labels(
-            self._axis_mpl, x=x, y=y, x_ha=x_ha, y_ha=y_ha
+            self._axis_mpl, x=x, y=y, x_ha=x_ha, y_ha=y_ha,
+            x_va=x_va, y_va=y_va, auto_adjust=auto_adjust,
+            scientific_convention=scientific_convention,
+            tight_layout=tight_layout
         )
 
-    def legend(self, loc: str = "upper left", **kwargs) -> None:
+    def legend(self, *args, loc: str = "upper left", **kwargs) -> None:
         """Places legend at specified location, with support for outside positions.
 
         Parameters
         ----------
+        *args : tuple
+            Positional arguments (handles, labels) as in matplotlib
         loc : str
             Legend position. Standard matplotlib positions plus:
             - "outer": Automatically place legend outside plot area (right side)
@@ -47,12 +80,13 @@ class AdjustmentMixin:
             For "separate": can include 'filename' (default: 'legend.png')
         """
         import matplotlib.pyplot as plt
-        
+
         # Handle special cases
         if loc == "outer":
             # Place legend outside on the right, adjusting figure to make room
             legend = self._axis_mpl.legend(
-                loc='center left', 
+                *args,
+                loc='center left',
                 bbox_to_anchor=(1.02, 0.5),
                 **kwargs
             )
@@ -170,8 +204,8 @@ class AdjustmentMixin:
 
         if loc in outside_positions:
             location, bbox = outside_positions[loc]
-            return self._axis_mpl.legend(loc=location, bbox_to_anchor=bbox, **kwargs)
-        return self._axis_mpl.legend(loc=loc, **kwargs)
+            return self._axis_mpl.legend(*args, loc=location, bbox_to_anchor=bbox, **kwargs)
+        return self._axis_mpl.legend(*args, loc=loc, **kwargs)
 
     def set_xyt(
         self,

scitex/plt/_subplots/_AxisWrapperMixins/_MatplotlibPlotMixin.py

@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # Timestamp: "2025-05-18 17:51:44 (ywatanabe)"
-# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/plt/_subplots/_AxisWrapperMixins/_MatplotlibPlotMixin.py
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/_subplots/_AxisWrapperMixins/_MatplotlibPlotMixin.py
 # ----------------------------------------
 import os
 
-__FILE__ = "./src/scitex/plt/_subplots/_AxisWrapperMixins/_MatplotlibPlotMixin.py"
+__FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -893,4 +893,162 @@ class MatplotlibPlotMixin:
 
         return self._axis_mpl, plot_df
 
+    # Standard matplotlib plot methods with plot_ prefix
+    def plot_bar(self, *args, track: bool = True, id: Optional[str] = None, **kwargs):
+        """Wrapper for matplotlib bar plot with tracking support."""
+        method_name = "plot_bar"
+
+        with self._no_tracking():
+            result = self._axis_mpl.bar(*args, **kwargs)
+
+        # Track bar data
+        if len(args) >= 2:
+            tracked_dict = {"bar_df": pd.DataFrame({"x": args[0], "height": args[1]})}
+            self._track(track, id, method_name, tracked_dict, None)
+
+        return result
+
+    def plot_barh(self, *args, track: bool = True, id: Optional[str] = None, **kwargs):
+        """Wrapper for matplotlib horizontal bar plot with tracking support."""
+        method_name = "plot_barh"
+
+        with self._no_tracking():
+            result = self._axis_mpl.barh(*args, **kwargs)
+
+        # Track bar data
+        if len(args) >= 2:
+            tracked_dict = {"barh_df": pd.DataFrame({"y": args[0], "width": args[1]})}
+            self._track(track, id, method_name, tracked_dict, None)
+
+        return result
+
+    def plot_scatter(self, *args, track: bool = True, id: Optional[str] = None, **kwargs):
+        """Wrapper for matplotlib scatter plot with tracking support."""
+        method_name = "plot_scatter"
+
+        with self._no_tracking():
+            result = self._axis_mpl.scatter(*args, **kwargs)
+
+        # Track scatter data
+        if len(args) >= 2:
+            tracked_dict = {"scatter_df": pd.DataFrame({"x": args[0], "y": args[1]})}
+            self._track(track, id, method_name, tracked_dict, None)
+
+        return result
+
+    def plot_errorbar(self, *args, track: bool = True, id: Optional[str] = None, **kwargs):
+        """Wrapper for matplotlib errorbar plot with tracking support."""
+        method_name = "plot_errorbar"
+
+        with self._no_tracking():
+            result = self._axis_mpl.errorbar(*args, **kwargs)
+
+        # Track errorbar data
+        if len(args) >= 2:
+            df_dict = {"x": args[0], "y": args[1]}
+            if "yerr" in kwargs:
+                df_dict["yerr"] = kwargs["yerr"]
+            if "xerr" in kwargs:
+                df_dict["xerr"] = kwargs["xerr"]
+            tracked_dict = {"errorbar_df": pd.DataFrame(df_dict)}
+            self._track(track, id, method_name, tracked_dict, None)
+
+        return result
+
+    def plot_fill_between(self, *args, track: bool = True, id: Optional[str] = None, **kwargs):
+        """Wrapper for matplotlib fill_between with tracking support."""
+        method_name = "plot_fill_between"
+
+        with self._no_tracking():
+            result = self._axis_mpl.fill_between(*args, **kwargs)
+
+        # Track fill_between data
+        if len(args) >= 3:
+            tracked_dict = {"fill_between_df": pd.DataFrame({
+                "x": args[0],
+                "y1": args[1],
+                "y2": args[2] if len(args) > 2 else 0
+            })}
+            self._track(track, id, method_name, tracked_dict, None)
+
+        return result
+
+    def plot_contour(self, *args, track: bool = True, id: Optional[str] = None, **kwargs):
+        """Wrapper for matplotlib contour plot with tracking support."""
+        method_name = "plot_contour"
+
+        with self._no_tracking():
+            result = self._axis_mpl.contour(*args, **kwargs)
+
+        # Track contour data
+        if len(args) >= 3:
+            # Flatten 2D arrays for CSV export
+            X, Y, Z = args[0], args[1], args[2]
+            tracked_dict = {"contour_df": pd.DataFrame({
+                "X": np.ravel(X),
+                "Y": np.ravel(Y),
+                "Z": np.ravel(Z)
+            })}
+            self._track(track, id, method_name, tracked_dict, None)
+
+        return result
+
+    def plot_imshow(self, *args, track: bool = True, id: Optional[str] = None, **kwargs):
+        """Wrapper for matplotlib imshow with tracking support."""
+        method_name = "plot_imshow"
+
+        with self._no_tracking():
+            result = self._axis_mpl.imshow(*args, **kwargs)
+
+        # Track image data
+        if len(args) >= 1:
+            # Create DataFrame with unique column names to avoid duplicates
+            img_data = args[0]
+            if hasattr(img_data, 'shape') and len(img_data.shape) == 2:
+                n_rows, n_cols = img_data.shape
+                # Use column names like "col_0", "col_1", etc. instead of just integers
+                df = pd.DataFrame(img_data, columns=[f"col_{i}" for i in range(n_cols)])
+            else:
+                df = pd.DataFrame(args[0])
+            tracked_dict = {"imshow_df": df}
+            self._track(track, id, method_name, tracked_dict, None)
+
+        return result
+
+    def plot_boxplot(self, *args, track: bool = True, id: Optional[str] = None, **kwargs):
+        """Wrapper for matplotlib boxplot with tracking support."""
+        method_name = "plot_boxplot"
+
+        with self._no_tracking():
+            result = self._axis_mpl.boxplot(*args, **kwargs)
+
+        # Track boxplot data
+        if len(args) >= 1:
+            data = args[0]
+            if isinstance(data, list):
+                tracked_dict = {"boxplot_df": pd.DataFrame(data)}
+            else:
+                tracked_dict = {"boxplot_df": pd.DataFrame({"data": data})}
+            self._track(track, id, method_name, tracked_dict, None)
+
+        return result
+
+    def plot_violinplot(self, *args, track: bool = True, id: Optional[str] = None, **kwargs):
+        """Wrapper for matplotlib violinplot with tracking support."""
+        method_name = "plot_violinplot"
+
+        with self._no_tracking():
+            result = self._axis_mpl.violinplot(*args, **kwargs)
+
+        # Track violin data
+        if len(args) >= 1:
+            data = args[0]
+            if isinstance(data, list):
+                tracked_dict = {"violinplot_df": pd.DataFrame(data)}
+            else:
+                tracked_dict = {"violinplot_df": pd.DataFrame({"data": data})}
+            self._track(track, id, method_name, tracked_dict, None)
+
+        return result
+
 # EOF

scitex/plt/_subplots/_AxisWrapperMixins/_SeabornMixin.py

@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # Timestamp: "2025-05-18 16:26:18 (ywatanabe)"
-# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/plt/_subplots/_AxisWrapperMixins/_SeabornMixin.py
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/_subplots/_AxisWrapperMixins/_SeabornMixin.py
 # ----------------------------------------
 import os
 
-__FILE__ = "./src/scitex/plt/_subplots/_AxisWrapperMixins/_SeabornMixin.py"
+__FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -43,7 +43,29 @@ class SeabornMixin:
                     kwargs, primary_key="palette", alternate_key="hue_colors"
                 )
 
-            self._axis_mpl = sns_plot_fn(ax=self._axis_mpl, *args, **kwargs)
+            # Suppress matplotlib's categorical units warning and info messages
+            import warnings
+            from scitex import logging
+            
+            # Temporarily suppress matplotlib's INFO level logging
+            mpl_logger = logging.getLogger('matplotlib')
+            original_level = mpl_logger.level
+            mpl_logger.setLevel(logging.WARNING)
+            
+            try:
+                with warnings.catch_warnings():
+                    warnings.filterwarnings('ignore', 
+                                          message='.*categorical units.*parsable as floats or dates.*',
+                                          category=UserWarning)
+                    warnings.filterwarnings('ignore',
+                                          message='.*Using categorical units.*',
+                                          module='matplotlib.*')
+                    warnings.simplefilter('ignore', UserWarning)
+                    
+                    self._axis_mpl = sns_plot_fn(ax=self._axis_mpl, *args, **kwargs)
+            finally:
+                # Restore original logging level
+                mpl_logger.setLevel(original_level)
 
         # Track the plot if required
         track_obj = track_obj if track_obj is not None else args
@@ -58,7 +80,7 @@ class SeabornMixin:
         """Formats data passed to sns functions with (data=data, x=x, y=y) keyword arguments"""
         df = kwargs.get("data")
         x, y, hue = kwargs.get("x"), kwargs.get("y"), kwargs.get("hue")
-
+        
         track_obj = self._sns_prepare_xyhue(df, x, y, hue) if df is not None else None
         self._sns_base(
             method_name,