scitex 2.5.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

scitex/plt/_subplots/_AxisWrapperMixins/_UnitAwareMixin.py

@@ -26,23 +26,24 @@ from scitex.errors import SciTeXError
 
 class UnitMismatchError(SciTeXError):
     """Raised when units are incompatible for an operation."""
+
     pass
 
 
 class UnitAwareMixin:
     """Mixin that adds unit awareness to plotting operations."""
-    
+
     def __init__(self):
         """Initialize unit tracking."""
         self._x_unit: Optional[Unit] = None
         self._y_unit: Optional[Unit] = None
         self._z_unit: Optional[Unit] = None
         self._unit_validation_enabled: bool = True
-        
+
     def set_unit_validation(self, enabled: bool) -> None:
         """Enable or disable unit validation."""
         self._unit_validation_enabled = enabled
-        
+
     def set_x_unit(self, unit: Union[str, Unit]) -> None:
         """Set the unit for the x-axis."""
         if isinstance(unit, str):
@@ -52,7 +53,7 @@ class UnitAwareMixin:
             unit = unit_obj
         self._x_unit = unit
         self._update_xlabel_with_unit()
-        
+
     def set_y_unit(self, unit: Union[str, Unit]) -> None:
         """Set the unit for the y-axis."""
         if isinstance(unit, str):
@@ -62,7 +63,7 @@ class UnitAwareMixin:
             unit = unit_obj
         self._y_unit = unit
         self._update_ylabel_with_unit()
-        
+
     def set_z_unit(self, unit: Union[str, Unit]) -> None:
         """Set the unit for the z-axis (for 3D plots)."""
         if isinstance(unit, str):
@@ -72,52 +73,56 @@ class UnitAwareMixin:
             unit = unit_obj
         self._z_unit = unit
         self._update_zlabel_with_unit()
-        
+
     def get_x_unit(self) -> Optional[Unit]:
         """Get the current x-axis unit."""
         return self._x_unit
-        
+
     def get_y_unit(self) -> Optional[Unit]:
         """Get the current y-axis unit."""
         return self._y_unit
-        
+
     def get_z_unit(self) -> Optional[Unit]:
         """Get the current z-axis unit."""
         return self._z_unit
-        
+
     def _update_xlabel_with_unit(self) -> None:
         """Update x-axis label to include unit."""
-        if self._x_unit and hasattr(self, '_axes_mpl'):
+        if self._x_unit and hasattr(self, "_axes_mpl"):
             current_label = self._axes_mpl.get_xlabel()
             # Remove existing unit if present
-            if '[' in current_label and ']' in current_label:
-                current_label = current_label.split('[')[0].strip()
+            if "[" in current_label and "]" in current_label:
+                current_label = current_label.split("[")[0].strip()
             if current_label:
                 self._axes_mpl.set_xlabel(f"{current_label} [{self._x_unit.symbol}]")
-                
+
     def _update_ylabel_with_unit(self) -> None:
         """Update y-axis label to include unit."""
-        if self._y_unit and hasattr(self, '_axes_mpl'):
+        if self._y_unit and hasattr(self, "_axes_mpl"):
             current_label = self._axes_mpl.get_ylabel()
             # Remove existing unit if present
-            if '[' in current_label and ']' in current_label:
-                current_label = current_label.split('[')[0].strip()
+            if "[" in current_label and "]" in current_label:
+                current_label = current_label.split("[")[0].strip()
             if current_label:
                 self._axes_mpl.set_ylabel(f"{current_label} [{self._y_unit.symbol}]")
-                
+
     def _update_zlabel_with_unit(self) -> None:
         """Update z-axis label to include unit (for 3D plots)."""
-        if self._z_unit and hasattr(self, '_axes_mpl') and hasattr(self._axes_mpl, 'set_zlabel'):
+        if (
+            self._z_unit
+            and hasattr(self, "_axes_mpl")
+            and hasattr(self._axes_mpl, "set_zlabel")
+        ):
             current_label = self._axes_mpl.get_zlabel()
             # Remove existing unit if present
-            if '[' in current_label and ']' in current_label:
-                current_label = current_label.split('[')[0].strip()
+            if "[" in current_label and "]" in current_label:
+                current_label = current_label.split("[")[0].strip()
             if current_label:
                 self._axes_mpl.set_zlabel(f"{current_label} [{self._z_unit.symbol}]")
-                
+
     def plot_with_units(self, x, y, x_unit=None, y_unit=None, **kwargs):
         """Plot with automatic unit handling.
-        
+
         Parameters
         ----------
         x : array-like or Quantity
@@ -130,7 +135,7 @@ class UnitAwareMixin:
             Unit for y-axis (overrides detected unit)
         **kwargs : dict
             Additional plotting parameters
-            
+
         Returns
         -------
         lines : list of Line2D
@@ -139,42 +144,42 @@ class UnitAwareMixin:
         # Extract values and units from Quantity objects
         x_val, x_detected_unit = self._extract_value_and_unit(x)
         y_val, y_detected_unit = self._extract_value_and_unit(y)
-        
+
         # Use provided units or detected units
         if x_unit:
             self.set_x_unit(x_unit)
         elif x_detected_unit and not self._x_unit:
             self.set_x_unit(x_detected_unit)
-            
+
         if y_unit:
             self.set_y_unit(y_unit)
         elif y_detected_unit and not self._y_unit:
             self.set_y_unit(y_detected_unit)
-            
+
         # Validate units if enabled
         if self._unit_validation_enabled:
             self._validate_unit_compatibility(x_detected_unit, self._x_unit, "x")
             self._validate_unit_compatibility(y_detected_unit, self._y_unit, "y")
-            
+
         # Plot using the standard method
         return self.plot(x_val, y_val, **kwargs)
-        
+
     def _extract_value_and_unit(self, data) -> Tuple[np.ndarray, Optional[Unit]]:
         """Extract numerical value and unit from data."""
-        if hasattr(data, 'value') and hasattr(data, 'unit'):
+        if hasattr(data, "value") and hasattr(data, "unit"):
             # It's a Quantity object
             return data.value, data.unit
         else:
             # Regular array
             return np.asarray(data), None
-            
-    def _validate_unit_compatibility(self, data_unit: Optional[Unit], 
-                                   axis_unit: Optional[Unit], 
-                                   axis_name: str) -> None:
+
+    def _validate_unit_compatibility(
+        self, data_unit: Optional[Unit], axis_unit: Optional[Unit], axis_name: str
+    ) -> None:
         """Validate that data unit is compatible with axis unit."""
         if not self._unit_validation_enabled:
             return
-            
+
         if data_unit and axis_unit:
             # Check if units have same dimensions
             if data_unit.dimensions != axis_unit.dimensions:
@@ -183,18 +188,19 @@ class UnitAwareMixin:
                     f"data has unit {data_unit.symbol} {data_unit.dimensions}, "
                     f"but axis expects {axis_unit.symbol} {axis_unit.dimensions}"
                 )
-                
-    def convert_x_units(self, new_unit: Union[str, Unit], 
-                       update_data: bool = True) -> float:
+
+    def convert_x_units(
+        self, new_unit: Union[str, Unit], update_data: bool = True
+    ) -> float:
         """Convert x-axis to new units.
-        
+
         Parameters
         ----------
         new_unit : str or Unit
             Target unit
         update_data : bool
             Whether to update plotted data
-            
+
         Returns
         -------
         float
@@ -202,39 +208,40 @@ class UnitAwareMixin:
         """
         if isinstance(new_unit, str):
             new_unit = getattr(Units, new_unit)
-            
+
         if not self._x_unit:
             raise ValueError("No x-axis unit set")
-            
+
         # Calculate conversion factor
         factor = self._x_unit.scale / new_unit.scale
-        
-        if update_data and hasattr(self, '_axes_mpl'):
+
+        if update_data and hasattr(self, "_axes_mpl"):
             # Update all line data
             for line in self._axes_mpl.lines:
                 xdata = line.get_xdata()
                 line.set_xdata(xdata * factor)
-                
+
             # Update x-axis limits
             xlim = self._axes_mpl.get_xlim()
             self._axes_mpl.set_xlim([x * factor for x in xlim])
-            
+
         # Update unit
         self.set_x_unit(new_unit)
-        
+
         return factor
-        
-    def convert_y_units(self, new_unit: Union[str, Unit], 
-                       update_data: bool = True) -> float:
+
+    def convert_y_units(
+        self, new_unit: Union[str, Unit], update_data: bool = True
+    ) -> float:
         """Convert y-axis to new units.
-        
+
         Parameters
         ----------
         new_unit : str or Unit
             Target unit
         update_data : bool
             Whether to update plotted data
-            
+
         Returns
         -------
         float
@@ -242,31 +249,31 @@ class UnitAwareMixin:
         """
         if isinstance(new_unit, str):
             new_unit = getattr(Units, new_unit)
-            
+
         if not self._y_unit:
             raise ValueError("No y-axis unit set")
-            
+
         # Calculate conversion factor
         factor = self._y_unit.scale / new_unit.scale
-        
-        if update_data and hasattr(self, '_axes_mpl'):
+
+        if update_data and hasattr(self, "_axes_mpl"):
             # Update all line data
             for line in self._axes_mpl.lines:
                 ydata = line.get_ydata()
                 line.set_ydata(ydata * factor)
-                
+
             # Update y-axis limits
             ylim = self._axes_mpl.get_ylim()
             self._axes_mpl.set_ylim([y * factor for y in ylim])
-            
+
         # Update unit
         self.set_y_unit(new_unit)
-        
+
         return factor
-        
+
     def set_xlabel(self, label: str, unit: Optional[Union[str, Unit]] = None) -> None:
         """Set x-axis label with optional unit.
-        
+
         Parameters
         ----------
         label : str
@@ -276,15 +283,15 @@ class UnitAwareMixin:
         """
         if unit:
             self.set_x_unit(unit)
-            
+
         if self._x_unit:
             label = f"{label} [{self._x_unit.symbol}]"
-            
+
         self._axes_mpl.set_xlabel(label)
-        
+
     def set_ylabel(self, label: str, unit: Optional[Union[str, Unit]] = None) -> None:
         """Set y-axis label with optional unit.
-        
+
         Parameters
         ----------
         label : str
@@ -294,15 +301,15 @@ class UnitAwareMixin:
         """
         if unit:
             self.set_y_unit(unit)
-            
+
         if self._y_unit:
             label = f"{label} [{self._y_unit.symbol}]"
-            
+
         self._axes_mpl.set_ylabel(label)
-        
+
     def set_zlabel(self, label: str, unit: Optional[Union[str, Unit]] = None) -> None:
         """Set z-axis label with optional unit (for 3D plots).
-        
+
         Parameters
         ----------
         label : str
@@ -310,13 +317,13 @@ class UnitAwareMixin:
         unit : str or Unit, optional
             Unit to display
         """
-        if not hasattr(self._axes_mpl, 'set_zlabel'):
+        if not hasattr(self._axes_mpl, "set_zlabel"):
             raise ValueError("Z-axis labels only available for 3D plots")
-            
+
         if unit:
             self.set_z_unit(unit)
-            
+
         if self._z_unit:
             label = f"{label} [{self._z_unit.symbol}]"
-            
-        self._axes_mpl.set_zlabel(label)
+
+        self._axes_mpl.set_zlabel(label)

scitex/plt/_subplots/_FigWrapper.py

@@ -39,14 +39,19 @@ class FigWrapper:
             def wrapper(*args, track=None, id=None, **kwargs):
                 # Suppress constrained_layout warnings for certain operations
                 import warnings
+
                 with warnings.catch_warnings():
-                    if attr in ['subplots_adjust', 'tight_layout']:
-                        warnings.filterwarnings('ignore', 
-                                              message='.*constrained_layout.*',
-                                              category=UserWarning)
-                        warnings.filterwarnings('ignore',
-                                              message='.*layout engine.*incompatible.*',
-                                              category=UserWarning)
+                    if attr in ["subplots_adjust", "tight_layout"]:
+                        warnings.filterwarnings(
+                            "ignore",
+                            message=".*constrained_layout.*",
+                            category=UserWarning,
+                        )
+                        warnings.filterwarnings(
+                            "ignore",
+                            message=".*layout engine.*incompatible.*",
+                            category=UserWarning,
+                        )
                     results = attr_mpl(*args, **kwargs)
                 # self._track(track, id, attr, args, kwargs)
                 return results
@@ -103,63 +108,83 @@ class FigWrapper:
         >>> fig.savefig('result.png', embed_metadata=False)
         """
         # Check if this is a format that can have metadata (PNG/JPEG/TIFF/PDF)
-        is_image_format = fname.lower().endswith(('.png', '.jpg', '.jpeg', '.tiff', '.tif', '.pdf'))
+        # Handle both string paths and file-like objects (e.g., BytesIO)
+        if isinstance(fname, str):
+            is_image_format = fname.lower().endswith(
+                (".png", ".jpg", ".jpeg", ".tiff", ".tif", ".pdf")
+            )
+        else:
+            # For file-like objects, check the 'format' kwarg if provided
+            # Otherwise default to False (no metadata embedding for BytesIO etc.)
+            fmt = kwargs.get('format', '').lower() if kwargs.get('format') else ''
+            is_image_format = fmt in ('png', 'jpg', 'jpeg', 'tiff', 'tif', 'pdf')
 
         if is_image_format and embed_metadata:
             # Collect automatic metadata
             auto_metadata = None
 
             # Get first axes if available
+            # Keep the scitex AxisWrapper (for history tracking) separate from matplotlib axes
             ax = None
-            if hasattr(self, 'axes'):
+            ax_scitex = None  # scitex AxisWrapper with history
+            if hasattr(self, "axes"):
                 try:
                     # Try to get first axes from various wrapper types
-                    if hasattr(self.axes, '_ax'):  # AxisWrapper
+                    if hasattr(self.axes, "_ax"):  # AxisWrapper
                         ax = self.axes._ax
-                    elif hasattr(self.axes, '_axis_mpl'):  # Alternative
+                        ax_scitex = self.axes  # Keep the wrapper for history
+                    elif hasattr(self.axes, "_axis_mpl"):  # Alternative
                         ax = self.axes._axis_mpl
-                    elif hasattr(self.axes, 'flatten'):  # AxesWrapper
+                        ax_scitex = self.axes
+                    elif hasattr(self.axes, "flatten"):  # AxesWrapper
                         flat = list(self.axes.flatten())
-                        if flat and hasattr(flat[0], '_ax'):
+                        if flat and hasattr(flat[0], "_ax"):
                             ax = flat[0]._ax
-                        elif flat and hasattr(flat[0], '_axis_mpl'):
+                            ax_scitex = flat[0]  # Keep the wrapper for history
+                        elif flat and hasattr(flat[0], "_axis_mpl"):
                             ax = flat[0]._axis_mpl
+                            ax_scitex = flat[0]
                 except Exception:
                     pass
 
             # If still no axes, try from figure
-            if ax is None and hasattr(self._fig_mpl, 'axes') and len(self._fig_mpl.axes) > 0:
+            if (
+                ax is None
+                and hasattr(self._fig_mpl, "axes")
+                and len(self._fig_mpl.axes) > 0
+            ):
                 ax = self._fig_mpl.axes[0]
 
             # Collect metadata
+            # Pass ax_scitex if available (has history for plot type detection)
             try:
                 from scitex.plt.utils import collect_figure_metadata
-                auto_metadata = collect_figure_metadata(self._fig_mpl, ax)
+
+                auto_metadata = collect_figure_metadata(self._fig_mpl, ax_scitex if ax_scitex else ax)
 
                 # Merge with custom metadata
                 if metadata:
-                    if 'custom' not in auto_metadata:
-                        auto_metadata['custom'] = {}
-                    auto_metadata['custom'].update(metadata)
+                    if "custom" not in auto_metadata:
+                        auto_metadata["custom"] = {}
+                    auto_metadata["custom"].update(metadata)
             except Exception as e:
                 # If metadata collection fails, warn but continue
                 import warnings
+
                 warnings.warn(f"Could not collect metadata: {e}")
                 auto_metadata = metadata
 
             # Use scitex.io.save_image for metadata embedding
             try:
                 from scitex.io._save_modules import save_image
+
                 save_image(
-                    self._fig_mpl,
-                    fname,
-                    metadata=auto_metadata,
-                    *args,
-                    **kwargs
+                    self._fig_mpl, fname, metadata=auto_metadata, *args, **kwargs
                 )
             except Exception as e:
                 # Fallback to regular matplotlib savefig
                 import warnings
+
                 warnings.warn(f"Metadata embedding failed, using regular savefig: {e}")
                 self._fig_mpl.savefig(fname, *args, **kwargs)
         else:
@@ -168,27 +193,27 @@ class FigWrapper:
 
     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 
+
+        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 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'):
+                elif hasattr(ax, "export_as_csv"):
                     # Direct AxisWrapper object
                     df = ax.export_as_csv()
                 else:
@@ -196,19 +221,16 @@ class FigWrapper:
                     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}_"
-                # Make column names unique by appending index if there are duplicates
+                # Column names already include axis position via get_csv_column_name
+                # (single source of truth from _csv_column_naming.py)
+                # Only handle duplicates by adding a counter
                 new_cols = []
                 col_counts = {}
                 for col in df.columns:
-                    # Convert to string and check if already has prefix
-                    col_str = str(col) if not (isinstance(col, str) and col.startswith(prefix)) else col
-                    if not col_str.startswith(prefix):
-                        col_str = f"{prefix}{col_str}"
+                    col_str = str(col)
 
                     # Handle duplicates by adding a counter
                     if col_str in col_counts:
@@ -221,7 +243,7 @@ class FigWrapper:
 
                 df.columns = new_cols
                 dfs.append(df)
-        
+
         # Return concatenated DataFrame or empty DataFrame if no data
         return pd.concat(dfs, axis=1) if dfs else pd.DataFrame()
 
@@ -247,7 +269,7 @@ class FigWrapper:
         """
         # Unwrap axes if it's a SciTeX AxisWrapper
         if ax is not None:
-            ax_mpl = ax._axis_mpl if hasattr(ax, '_axis_mpl') else ax
+            ax_mpl = ax._axis_mpl if hasattr(ax, "_axis_mpl") else ax
         else:
             ax_mpl = None
 
@@ -256,22 +278,24 @@ class FigWrapper:
 
     def _traverse_axes(self):
         """Helper method to traverse all axis wrappers in the figure."""
-        if hasattr(self, 'axes'):
+        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'):
+            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__'):
+            elif not hasattr(self.axes, "__iter__"):
                 # Single axis case
                 yield self.axes
             else:
                 # Multiple axes case
-                if hasattr(self.axes, 'flat'):
+                if hasattr(self.axes, "flat"):
                     # 2D array of axes
                     for ax in self.axes.flat:
                         yield ax
-                elif hasattr(self.axes, 'ravel'):
+                elif hasattr(self.axes, "ravel"):
                     # Numpy array
                     for ax in self.axes.ravel():
                         yield ax
@@ -300,24 +324,29 @@ class FigWrapper:
 
     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():
+        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")
+                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
@@ -328,10 +357,9 @@ class FigWrapper:
                 # 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
@@ -346,20 +374,24 @@ class FigWrapper:
             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():
+        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'])
-    
+            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 
+
+    @property
     def number(self):
         """Return the figure number for matplotlib.pyplot.close() compatibility"""
         return self._fig_mpl.number
@@ -368,6 +400,7 @@ class FigWrapper:
         """Cleanup when FigWrapper is deleted"""
         try:
             import matplotlib.pyplot as plt
+
             plt.close(self._fig_mpl)
         except:
             pass