scitex 2.0.0__py2.py3-none-any.whl

scitex/plt/_subplots/_AxisWrapperMixins/_SeabornMixin.py

@@ -0,0 +1,368 @@
+#!/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
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/_subplots/_AxisWrapperMixins/_SeabornMixin.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+from functools import wraps
+
+import scitex
+import numpy as np
+import pandas as pd
+import seaborn as sns
+
+from ....plt import ax as ax_module
+
+
+def sns_copy_doc(func):
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        return func(self, *args, **kwargs)
+
+    wrapper.__doc__ = getattr(sns, func.__name__.split("sns_")[-1]).__doc__
+    return wrapper
+
+
+class SeabornMixin:
+
+    def _sns_base(
+        self, method_name, *args, track=True, track_obj=None, id=None, **kwargs
+    ):
+        sns_method_name = method_name.split("sns_")[-1]
+
+        with self._no_tracking():
+            sns_plot_fn = getattr(sns, sns_method_name)
+
+            if kwargs.get("hue_colors"):
+                kwargs = scitex.gen.alternate_kwarg(
+                    kwargs, primary_key="palette", alternate_key="hue_colors"
+                )
+
+            self._axis_mpl = sns_plot_fn(ax=self._axis_mpl, *args, **kwargs)
+
+        # Track the plot if required
+        track_obj = track_obj if track_obj is not None else args
+        # Create a tracked_dict with appropriate structure
+        tracked_dict = {
+            'data': track_obj,  # Use 'data' key for consistency with formatters
+            'args': args        # Keep args for backward compatibility
+        }
+        self._track(track, id, method_name, tracked_dict, kwargs)
+
+    def _sns_base_xyhue(self, method_name, *args, track=True, id=None, **kwargs):
+        """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,
+            *args,
+            track=track,
+            track_obj=track_obj,
+            id=id,
+            **kwargs,
+        )
+
+    def _sns_prepare_xyhue(self, data=None, x=None, y=None, hue=None, **kwargs):
+        """Returns obj to track"""
+        data = data.reset_index()
+
+        if hue is not None:
+            if x is None and y is None:
+
+                return data
+            elif x is None:
+
+                agg_dict = {}
+                for hh in data[hue].unique():
+                    agg_dict[hh] = data.loc[data[hue] == hh, y]
+                df = scitex.pd.force_df(agg_dict)
+                return df
+
+            elif y is None:
+
+                df = pd.concat(
+                    [data.loc[data[hue] == hh, x] for hh in data[hue].unique()],
+                    axis=1,
+                )
+                return df
+            else:
+                pivoted_data = data.pivot_table(
+                    values=y,
+                    index=data.index,
+                    columns=[x, hue],
+                    aggfunc="first",
+                )
+                pivoted_data.columns = [
+                    f"{col[0]}-{col[1]}" for col in pivoted_data.columns
+                ]
+                return pivoted_data
+        else:
+            if x is None and y is None:
+                return data
+
+            elif x is None:
+                return data[[y]]
+
+            elif y is None:
+                return data[[x]]
+
+            else:
+                return data.pivot_table(
+                    values=y, index=data.index, columns=x, aggfunc="first"
+                )
+
+    @sns_copy_doc
+    def sns_barplot(self, data=None, x=None, y=None, track=True, id=None, **kwargs):
+        self._sns_base_xyhue(
+            "sns_barplot", data=data, x=x, y=y, track=track, id=id, **kwargs
+        )
+
+    @sns_copy_doc
+    def sns_boxplot(
+        self,
+        data=None,
+        x=None,
+        y=None,
+        strip=False,
+        track=True,
+        id=None,
+        **kwargs,
+    ):
+        self._sns_base_xyhue(
+            "sns_boxplot", data=data, x=x, y=y, track=track, id=id, **kwargs
+        )
+        if strip:
+            strip_kwargs = kwargs.copy()
+            strip_kwargs.pop("notch", None)  # Remove boxplot-specific kwargs
+            strip_kwargs.pop("whis", None)
+            self.sns_stripplot(
+                data=data,
+                x=x,
+                y=y,
+                track=False,
+                id=f"{id}_strip",
+                **strip_kwargs,
+            )
+
+    @sns_copy_doc
+    def sns_heatmap(self, *args, xyz=False, track=True, id=None, **kwargs):
+        method_name = "sns_heatmap"
+        df = args[0]
+        if xyz:
+            df = scitex.pd.to_xyz(df)
+        self._sns_base(method_name, *args, track=track, track_obj=df, id=id, **kwargs)
+
+    @sns_copy_doc
+    def sns_histplot(
+        self, data=None, x=None, y=None, bins=10, align_bins=True, track=True, id=None, **kwargs
+    ):
+        """
+        Plot a histogram using seaborn with bin alignment support.
+        
+        This method enhances the seaborn histplot with the ability to align
+        bins across multiple histograms on the same axis and export bin data.
+        
+        Args:
+            data: Input data (DataFrame, array, or series)
+            x: Column name for x-axis data
+            y: Column name for y-axis data
+            bins: Bin specification (count or edges)
+            align_bins: Whether to align bins with other histograms on this axis
+            track: Whether to track this operation
+            id: Identifier for tracking
+            **kwargs: Additional keywords passed to seaborn histplot
+        """
+        # Method Name for downstream csv exporting
+        method_name = "sns_histplot"
+        
+        # Get the data to plot for bin alignment
+        plot_data = None
+        if data is not None and x is not None:
+            plot_data = data[x].values if hasattr(data, 'columns') and x in data.columns else None
+        
+        # Get axis and histogram IDs for bin alignment
+        axis_id = str(hash(self._axis_mpl))
+        hist_id = id if id is not None else str(self.id)
+        
+        # Calculate range from data if needed
+        range_value = kwargs.get('binrange', None)
+        
+        # Align bins if requested and data is available
+        if align_bins and plot_data is not None:
+            from ....plt.utils import histogram_bin_manager
+            bins_val, range_val = histogram_bin_manager.register_histogram(
+                axis_id, hist_id, plot_data, bins, range_value
+            )
+            
+            # Update bins in kwargs
+            kwargs['bins'] = bins_val
+            
+            # Update range in kwargs if it was provided
+            if range_value is not None:
+                kwargs['binrange'] = range_val
+        
+        # Plotting with seaborn
+        with self._no_tracking():
+            # Execute the seaborn histplot function
+            # Don't pass bins as a separate parameter since it may already be in kwargs
+            sns_plot = sns.histplot(data=data, x=x, y=y, ax=self._axis_mpl, **kwargs)
+            
+            # Extract bin information from the plotted artists
+            hist_result = None
+            if hasattr(sns_plot, 'patches') and sns_plot.patches:
+                # Get bin information from the plot patches
+                patches = sns_plot.patches
+                if patches:
+                    counts = np.array([p.get_height() for p in patches])
+                    # Extract bin edges from patch positions
+                    bin_edges = []
+                    for p in patches:
+                        bin_edges.append(p.get_x())
+                    # Add the rightmost edge
+                    if patches:
+                        bin_edges.append(patches[-1].get_x() + patches[-1].get_width())
+                        
+                    hist_result = (counts, np.array(bin_edges))
+        
+        # Create a track object for the formatter
+        track_obj = self._sns_prepare_xyhue(data, x, y, kwargs.get("hue"))
+        
+        # Enhanced tracked dict with histogram result
+        tracked_dict = {
+            'data': track_obj,
+            'args': (data, x, y),
+            'hist_result': hist_result
+        }
+        
+        # Track the operation
+        self._track(track, id, method_name, tracked_dict, kwargs)
+        
+        return sns_plot
+
+    @sns_copy_doc
+    def sns_kdeplot(
+        self,
+        data=None,
+        x=None,
+        y=None,
+        xlim=None,
+        ylim=None,
+        track=True,
+        id=None,
+        **kwargs,
+    ):
+        if kwargs.get("hue"):
+            hues = data[kwargs["hue"]]
+
+            if x is not None:
+                lim = xlim
+                for hue in np.unique(hues):
+                    _data = data.loc[hues == hue, x]
+                    self.plot_kde(_data, xlim=lim, label=hue, id=hue, **kwargs)
+
+            if y is not None:
+                lim = ylim
+                for hue in np.unique(hues):
+                    _data = data.loc[hues == hue, y]
+                    self.plot_kde(_data, xlim=lim, label=hue, id=hue, **kwargs)
+
+        else:
+            if x is not None:
+                _data, lim = data[x], xlim
+            if y is not None:
+                _data, lim = data[y], ylim
+            self.plot_kde(_data, xlim=lim, **kwargs)
+
+    @sns_copy_doc
+    def sns_pairplot(self, *args, track=True, id=None, **kwargs):
+        self._sns_base("sns_pairplot", *args, track=track, id=id, **kwargs)
+
+    @sns_copy_doc
+    def sns_scatterplot(self, data=None, x=None, y=None, track=True, id=None, **kwargs):
+        self._sns_base_xyhue(
+            "sns_scatterplot",
+            data=data,
+            x=x,
+            y=y,
+            track=track,
+            id=id,
+            **kwargs,
+        )
+
+    @sns_copy_doc
+    def sns_lineplot(self, data=None, x=None, y=None, track=True, id=None, **kwargs):
+        self._sns_base_xyhue(
+            "sns_lineplot",
+            data=data,
+            x=x,
+            y=y,
+            track=track,
+            id=id,
+            **kwargs,
+        )
+
+    @sns_copy_doc
+    def sns_swarmplot(self, data=None, x=None, y=None, track=True, id=None, **kwargs):
+        self._sns_base_xyhue(
+            "sns_swarmplot", data=data, x=x, y=y, track=track, id=id, **kwargs
+        )
+
+    @sns_copy_doc
+    def sns_stripplot(self, data=None, x=None, y=None, track=True, id=None, **kwargs):
+        self._sns_base_xyhue(
+            "sns_stripplot", data=data, x=x, y=y, track=track, id=id, **kwargs
+        )
+
+    # @sns_copy_doc
+    # def sns_violinplot(
+    #     self, data=None, x=None, y=None, track=True, id=None, **kwargs
+    # ):
+    #     self._sns_base_xyhue(
+    #         "sns_violinplot", data=data, x=x, y=y, track=track, id=id, **kwargs
+    #     )
+
+    @sns_copy_doc
+    def sns_violinplot(
+        self,
+        data=None,
+        x=None,
+        y=None,
+        track=True,
+        id=None,
+        half=False,
+        **kwargs,
+    ):
+        if half:
+            with self._no_tracking():
+                self._axis_mpl = ax_module.plot_half_violin(
+                    self._axis_mpl, data=data, x=x, y=y, **kwargs
+                )
+        else:
+            self._sns_base_xyhue(
+                "sns_violinplot",
+                data=data,
+                x=x,
+                y=y,
+                track=track,
+                id=id,
+                **kwargs,
+            )
+
+        # Tracking
+        track_obj = self._sns_prepare_xyhue(data, x, y, kwargs.get("hue"))
+        self._track(track, id, "sns_violinplot", track_obj, kwargs)
+
+        return self._axis_mpl
+
+    @sns_copy_doc
+    def sns_jointplot(self, *args, track=True, id=None, **kwargs):
+        self._sns_base("sns_jointplot", *args, track=track, id=id, **kwargs)
+
+# EOF

scitex/plt/_subplots/_AxisWrapperMixins/_TrackingMixin.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-04-30 18:40:59 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/_subplots/_AxisWrapperMixins/_TrackingMixin.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/_subplots/_AxisWrapperMixins/_TrackingMixin.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+"""
+Functionality:
+    * Handles tracking and history management for matplotlib plot operations
+Input:
+    * Plot method calls, their arguments, and tracking configuration
+Output:
+    * Tracked plotting history and DataFrame export for analysis
+Prerequisites:
+    * pandas, matplotlib
+"""
+
+from contextlib import contextmanager
+
+import pandas as pd
+
+from .._export_as_csv import export_as_csv as _export_as_csv
+
+
+class TrackingMixin:
+    """Mixin class for tracking matplotlib plotting operations.
+
+    Example
+    -------
+    >>> fig, ax = plt.subplots()
+    >>> ax.track = True
+    >>> ax.id = 0
+    >>> ax._ax_history = OrderedDict()
+    >>> ax.plot([1, 2, 3], [4, 5, 6], id="plot1")
+    >>> print(ax.history)
+    {'plot1': ('plot1', 'plot', {'plot_df': DataFrame, ...}, {})}
+    """
+
+    def _track(self, track, id, method_name, tracked_dict, kwargs=None):
+        """Track plotting operation with auto-generated IDs.
+        
+        Args:
+            track: Whether to track this operation
+            id: Identifier for the plot (can be None)
+            method_name: Name of the plotting method
+            tracked_dict: Dictionary of tracked data
+            kwargs: Original keyword arguments
+        """
+        # Extract id from kwargs and remove it before passing to matplotlib
+        if kwargs is not None and hasattr(kwargs, "get") and "id" in kwargs:
+            id = kwargs.pop("id")
+        
+        # Default kwargs to empty dict if None
+        if kwargs is None:
+            kwargs = {}
+
+        if track is None:
+            track = self.track
+
+        if track:
+            # If no ID was provided, generate one using method_name + counter
+            if id is None:
+                # Initialize method counters if not exist
+                if not hasattr(self, '_method_counters'):
+                    self._method_counters = {}
+                
+                # Get current counter value for this method and increment it
+                counter = self._method_counters.get(method_name, 0)
+                self._method_counters[method_name] = counter + 1
+                
+                # Format ID as method_name_counter (e.g., bar_1, plot_3)
+                id = f"{method_name}_{counter}"
+            
+            # For backward compatibility
+            self.id += 1
+            
+            # Store the tracking record
+            self._ax_history[id] = (id, method_name, tracked_dict, kwargs)
+
+    @contextmanager
+    def _no_tracking(self):
+        """Context manager to temporarily disable tracking."""
+        original_track = self.track
+        self.track = False
+        try:
+            yield
+        finally:
+            self.track = original_track
+
+    @property
+    def history(self):
+        return {k: self._ax_history[k] for k in self._ax_history}
+
+    @property
+    def flat(self):
+        if isinstance(self._axis_mpl, list):
+            return self._axis_mpl
+        else:
+            return [self._axis_mpl]
+
+    def reset_history(self):
+        self._ax_history = {}
+
+    def export_as_csv(self):
+        """
+        Export tracked plotting data to a DataFrame.
+        """
+        df = _export_as_csv(self.history)
+
+        return df if df is not None else pd.DataFrame()
+    
+    def export_as_csv_for_sigmaplot(self, include_visual_params=True):
+        """
+        Export tracked plotting data to a DataFrame in SigmaPlot format.
+        
+        Parameters
+        ----------
+        include_visual_params : bool, optional
+            Whether to include visual parameters (xlabel, ylabel, scales, etc.)
+            at the top of the CSV. Default is True.
+            
+        Returns
+        -------
+        pandas.DataFrame
+            DataFrame containing the plotted data formatted for SigmaPlot.
+            
+        Examples
+        --------
+        >>> fig, ax = scitex.plt.subplots()
+        >>> ax.plot([1, 2, 3], [4, 5, 6])
+        >>> ax.scatter([1, 2, 3], [7, 8, 9])
+        >>> df = ax.export_as_csv_for_sigmaplot()
+        >>> df.to_csv('for_sigmaplot.csv', index=False)
+        """
+        df = _export_as_csv(self.history)
+        
+        return df if df is not None else pd.DataFrame()
+
+    # def _track(
+    #     self,
+    #     track: Optional[bool],
+    #     plot_id: Optional[str],
+    #     method_name: str,
+    #     tracked_dict: Any,
+    #     kwargs: Dict[str, Any]
+    # ) -> None:
+    #     """Tracks plotting operation if tracking is enabled."""
+    #     if track is None:
+    #         track = self.track
+    #     if track:
+    #         plot_id = plot_id if plot_id is not None else self.id
+    #         self.id += 1
+    #         self._ax_history[plot_id] = (plot_id, method_name, tracked_dict, kwargs)
+
+    # @contextmanager
+    # def _no_tracking(self) -> None:
+    #     """Temporarily disables tracking within a context."""
+    #     original_track = self.track
+    #     self.track = False
+    #     try:
+    #         yield
+    #     finally:
+    #         self.track = original_track
+
+    # @property
+    # def history(self) -> Dict[str, Tuple]:
+    #     """Returns the plotting history."""
+    #     return dict(self._ax_history)
+
+    # def reset_history(self) -> None:
+    #     """Clears the plotting history."""
+    #     self._ax_history = OrderedDict()
+
+    # def export_as_csv(self) -> pd.DataFrame:
+    #     """Converts plotting history to a SigmaPlot-compatible DataFrame."""
+    #     df = _export_as_csv(self.history)
+    #     return df if df is not None else pd.DataFrame()
+
+
+# EOF

scitex/plt/_subplots/_AxisWrapperMixins/__init__.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-01 08:54:38 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/_subplots/_AxisWrapperMixins/__init__.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/_subplots/_AxisWrapperMixins/__init__.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+from ._AdjustmentMixin import AdjustmentMixin
+from ._MatplotlibPlotMixin import MatplotlibPlotMixin
+from ._SeabornMixin import SeabornMixin
+from ._TrackingMixin import TrackingMixin
+
+# EOF