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

scitex/io/_save.py

@@ -1,17 +1,19 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Timestamp: "2025-05-18 16:49:44 (ywatanabe)"
-# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/io/_save.py
+# Timestamp: "2025-10-16 03:09:46 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/io/_save.py
 # ----------------------------------------
+from __future__ import annotations
 import os
-
-__FILE__ = "./src/scitex/io/_save.py"
+__FILE__ = (
+    "./src/scitex/io/_save.py"
+)
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
-import warnings
+__FILE__ = __file__
 
-THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/io/_save.py"
+import warnings
 
 """
 1. Functionality:
@@ -28,9 +30,11 @@ THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/io/_save.py"
 
 """Imports"""
 import inspect
-import logging
 import os as _os
-from typing import Any
+from pathlib import Path
+from typing import Any, Union
+
+from scitex import logging
 
 from .._sh import sh
 from ..path._clean import clean
@@ -41,119 +45,123 @@ from ..str._readable_bytes import readable_bytes
 
 # Import save functions from the new modular structure
 from ._save_modules import (
+    save_catboost,
     save_csv,
     save_excel,
+    save_hdf5,
+    save_html,
+    save_image,
+    save_joblib,
+    save_json,
+    save_matlab,
+    save_mp4,
     save_npy,
     save_npz,
     save_pickle,
     save_pickle_compressed,
-    save_joblib,
+    save_tex,
+    save_text,
     save_torch,
-    save_json,
     save_yaml,
-    save_hdf5,
-    save_matlab,
-    save_catboost,
-    save_text,
-    save_html,
-    save_image,
-    save_mp4,
-    save_listed_dfs_as_csv,
-    save_listed_scalars_as_csv,
-    save_optuna_study_as_csv_and_pngs,
+    save_zarr,
 )
+from ._save_modules._bibtex import save_bibtex
+
+logger = logging.getLogger()
 
 
 def _get_figure_with_data(obj):
     """
     Extract figure or axes object that may contain plotting data for CSV export.
-    
+
     Parameters
     ----------
     obj : various matplotlib objects
         Could be Figure, Axes, FigWrapper, AxisWrapper, or other matplotlib objects
-        
+
     Returns
     -------
     object or None
         Figure or axes object that has export_as_csv methods, or None if not found
     """
-    import matplotlib.pyplot as plt
-    import matplotlib.figure
     import matplotlib.axes
-    
+    import matplotlib.figure
+    import matplotlib.pyplot as plt
+
     # Check if object already has export methods (SciTeX wrapped objects)
-    if hasattr(obj, 'export_as_csv'):
+    if hasattr(obj, "export_as_csv"):
         return obj
-    
+
     # Handle matplotlib Figure objects
     if isinstance(obj, matplotlib.figure.Figure):
         # Get the current axes that might be wrapped with SciTeX functionality
         current_ax = plt.gca()
-        if hasattr(current_ax, 'export_as_csv'):
+        if hasattr(current_ax, "export_as_csv"):
             return current_ax
-        
+
         # Check all axes in the figure
         for ax in obj.axes:
-            if hasattr(ax, 'export_as_csv'):
+            if hasattr(ax, "export_as_csv"):
                 return ax
-                
+
         return None
-    
-    # Handle matplotlib Axes objects  
+
+    # Handle matplotlib Axes objects
     if isinstance(obj, matplotlib.axes.Axes):
-        if hasattr(obj, 'export_as_csv'):
+        if hasattr(obj, "export_as_csv"):
             return obj
         return None
-    
+
     # Handle FigWrapper or similar SciTeX objects
-    if hasattr(obj, 'figure') and hasattr(obj.figure, 'axes'):
+    if hasattr(obj, "figure") and hasattr(obj.figure, "axes"):
         # Check if the wrapper itself has export methods
-        if hasattr(obj, 'export_as_csv'):
+        if hasattr(obj, "export_as_csv"):
             return obj
-            
+
         # Check the underlying figure's axes
         for ax in obj.figure.axes:
-            if hasattr(ax, 'export_as_csv'):
+            if hasattr(ax, "export_as_csv"):
                 return ax
-                
+
         return None
-    
+
     # Handle AxisWrapper or similar SciTeX objects
-    if hasattr(obj, '_axis_mpl') or hasattr(obj, '_ax'):
-        if hasattr(obj, 'export_as_csv'):
+    if hasattr(obj, "_axis_mpl") or hasattr(obj, "_ax"):
+        if hasattr(obj, "export_as_csv"):
             return obj
         return None
-    
+
     # Try to get the current figure and its axes as fallback
     try:
         current_fig = plt.gcf()
-        current_ax = plt.gca() 
-        
-        if hasattr(current_ax, 'export_as_csv'):
+        current_ax = plt.gca()
+
+        if hasattr(current_ax, "export_as_csv"):
             return current_ax
-        elif hasattr(current_fig, 'export_as_csv'):
+        elif hasattr(current_fig, "export_as_csv"):
             return current_fig
-            
+
         # Check all axes in current figure
         for ax in current_fig.axes:
-            if hasattr(ax, 'export_as_csv'):
+            if hasattr(ax, "export_as_csv"):
                 return ax
-                
+
     except:
         pass
-    
+
     return None
 
 
 def save(
     obj: Any,
-    specified_path: str,
+    specified_path: Union[str, Path],
     makedirs: bool = True,
     verbose: bool = True,
     symlink_from_cwd: bool = False,
+    symlink_to: Union[str, Path] = None,
     dry_run: bool = False,
     no_csv: bool = False,
+    use_caller_path: bool = False,
     **kwargs,
 ) -> None:
     """
@@ -163,16 +171,22 @@ def save(
     ----------
     obj : Any
         The object to be saved. Can be a NumPy array, PyTorch tensor, Pandas DataFrame, or any serializable object.
-    specified_path : str
-        The file name or path where the object should be saved. The file extension determines the format.
+    specified_path : Union[str, Path]
+        The file name or path where the object should be saved. Can be a string or pathlib.Path object. The file extension determines the format.
     makedirs : bool, optional
         If True, create the directory path if it does not exist. Default is True.
     verbose : bool, optional
         If True, print a message upon successful saving. Default is True.
     symlink_from_cwd : bool, optional
         If True, create a _symlink from the current working directory. Default is False.
+    symlink_to : Union[str, Path], optional
+        If specified, create a symlink at this path pointing to the saved file. Default is None.
     dry_run : bool, optional
         If True, simulate the saving process without actually writing files. Default is False.
+    use_caller_path : bool, optional
+        If True, intelligently determine the script path by skipping internal library frames.
+        This is useful when stx.io.save is called from within scitex library code.
+        Default is False.
     **kwargs
         Additional keyword arguments to pass to the underlying save function of the specific format.
 
@@ -221,6 +235,10 @@ def save(
     >>> scitex.io.save(data_dict, "data.json")
     """
     try:
+        # Convert Path objects to strings for consistency
+        if isinstance(specified_path, Path):
+            specified_path = str(specified_path)
+
         ########################################
         # DO NOT MODIFY THIS SECTION
         ########################################
@@ -230,7 +248,10 @@ def save(
         # When called in /path/to/script.py,
         # data will be saved under `/path/to/script.py_out/`
         #
-        # On the other hand, when called in ipython environment,
+        # When called in a Jupyter notebook /path/to/notebook.ipynb,
+        # data will be saved under `/path/to/notebook_out/`
+        #
+        # When called in ipython environment,
         # data will be saved under `/tmp/{_os.getenv("USER")/`
         #
         ########################################
@@ -240,26 +261,29 @@ def save(
         if specified_path.startswith('f"') or specified_path.startswith("f'"):
             # Remove the f prefix and quotes
             path_content = specified_path[2:-1]
-            
+
             # Get the caller's frame to access their local variables
             frame = inspect.currentframe().f_back
             try:
                 # Use string formatting with the caller's locals and globals
                 # This is much safer than eval() as it only does string substitution
                 import re
+
                 # Find all {variable} patterns
-                variables = re.findall(r'\{([^}]+)\}', path_content)
+                variables = re.findall(r"\{([^}]+)\}", path_content)
                 format_dict = {}
                 for var in variables:
                     # Only allow simple variable names, not arbitrary expressions
-                    if re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', var):
+                    if re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", var):
                         if var in frame.f_locals:
                             format_dict[var] = frame.f_locals[var]
                         elif var in frame.f_globals:
                             format_dict[var] = frame.f_globals[var]
                     else:
-                        raise ValueError(f"Invalid variable name in f-string: {var}")
-                
+                        raise ValueError(
+                            f"Invalid variable name in f-string: {var}"
+                        )
+
                 # Use str.format() which is safe
                 specified_path = path_content.format(**format_dict)
             finally:
@@ -271,14 +295,72 @@ def save(
 
         # When relative path
         else:
-            script_path = inspect.stack()[1].filename
-
-            # Fake path if in ipython
-            if ("ipython" in script_path) or ("<stdin>" in script_path):
-                script_path = f'/tmp/{_os.getenv("USER")}'
-
-            sdir = clean_path(_os.path.splitext(script_path)[0] + "_out")
-            spath = _os.path.join(sdir, specified_path)
+            # Import here to avoid circular imports
+            from ..gen._detect_environment import detect_environment
+            from ..gen._get_notebook_path import get_notebook_info_simple
+
+            # Detect the current environment
+            env_type = detect_environment()
+
+            if env_type == "jupyter":
+                # Special handling for Jupyter notebooks
+                notebook_name, notebook_dir = get_notebook_info_simple()
+
+                if notebook_name:
+                    # Remove .ipynb extension and add _out
+                    notebook_base = _os.path.splitext(notebook_name)[0]
+                    sdir = _os.path.join(
+                        notebook_dir or _os.getcwd(), f"{notebook_base}_out"
+                    )
+                else:
+                    # Fallback if we can't detect notebook name
+                    sdir = _os.path.join(_os.getcwd(), "notebook_out")
+
+                spath = _os.path.join(sdir, specified_path)
+
+            elif env_type == "script":
+                # Regular script handling
+                if use_caller_path:
+                    # Smart path detection: skip internal scitex library frames
+                    script_path = None
+                    scitex_src_path = _os.path.join(
+                        _os.path.dirname(__file__), "..", ".."
+                    )
+                    scitex_src_path = _os.path.abspath(scitex_src_path)
+
+                    # Walk through the call stack from caller to find the first non-scitex frame
+                    for frame_info in inspect.stack()[1:]:
+                        frame_path = _os.path.abspath(frame_info.filename)
+                        # Skip frames from scitex library
+                        if not frame_path.startswith(scitex_src_path):
+                            script_path = frame_path
+                            break
+
+                    # Fallback to stack[1] if we couldn't find a non-scitex frame
+                    if script_path is None:
+                        script_path = inspect.stack()[1].filename
+                else:
+                    script_path = inspect.stack()[1].filename
+
+                sdir = clean_path(_os.path.splitext(script_path)[0] + "_out")
+                spath = _os.path.join(sdir, specified_path)
+
+            else:
+                # IPython console or interactive mode
+                script_path = inspect.stack()[1].filename
+
+                if (
+                    ("ipython" in script_path)
+                    or ("<stdin>" in script_path)
+                    or env_type in ["ipython", "interactive"]
+                ):
+                    script_path = f'/tmp/{_os.getenv("USER")}'
+                    sdir = script_path
+                else:
+                    # Unknown environment, use current directory
+                    sdir = _os.path.join(_os.getcwd(), "output")
+
+                spath = _os.path.join(sdir, specified_path)
 
         # Sanitization
         spath_final = clean(spath)
@@ -291,17 +373,27 @@ def save(
         # Removes spath and spath_cwd to prevent potential circular links
         # Skip deletion for CSV files to allow caching to work
         # Also skip deletion for HDF5 files when a key is specified
-        should_skip_deletion = (
-            spath_final.endswith('.csv') or 
-            ((spath_final.endswith('.hdf5') or spath_final.endswith('.h5')) and 'key' in kwargs)
+        should_skip_deletion = spath_final.endswith(".csv") or (
+            (spath_final.endswith(".hdf5") or spath_final.endswith(".h5"))
+            and "key" in kwargs
         )
-        
+
         if not should_skip_deletion:
             for path in [spath_final, spath_cwd]:
                 sh(f"rm -f {path}", verbose=False)
 
         if dry_run:
-            print(color_text(f"\n(dry run) Saved to: {spath_final}", c="yellow"))
+            # Get relative path from current working directory
+            try:
+                rel_path = _os.path.relpath(spath, _os.getcwd())
+            except ValueError:
+                rel_path = spath
+
+            if verbose:
+                print()
+                logger.success(
+                    color_text(f"(dry run) Saved to: ./{rel_path}", c="yellow")
+                )
             return
 
         # Ensure directory exists
@@ -314,20 +406,27 @@ def save(
             spath_final,
             verbose=verbose,
             symlink_from_cwd=symlink_from_cwd,
+            symlink_to=symlink_to,
             dry_run=dry_run,
             no_csv=no_csv,
             **kwargs,
         )
 
-        # Symbolic link
+        # Symbolic links
         _symlink(spath, spath_cwd, symlink_from_cwd, verbose)
+        _symlink_to(spath_final, symlink_to, verbose)
+        return Path(spath)
+        # return True
 
     except Exception as e:
-        logging.error(
-            f"Error occurred while saving: {str(e)}"
-            f"Debug: Initial script_path = {inspect.stack()[1].filename}"
-            f"Debug: Final spath = {spath}"
+        logger.error(
+            f"Error occurred while saving: {str(e)}\n"
+            f"Debug: Initial script_path = {inspect.stack()[1].filename}\n"
+            f"Debug: Final spath = {spath}\n"
+            f"Debug: specified_path type = {type(specified_path)}\n"
+            f"Debug: specified_path = {specified_path}"
         )
+        return False
 
 
 def _symlink(spath, spath_cwd, symlink_from_cwd, verbose):
@@ -337,7 +436,32 @@ def _symlink(spath, spath_cwd, symlink_from_cwd, verbose):
         sh(f"rm -f {spath_cwd}", verbose=False)
         sh(f"ln -sfr {spath} {spath_cwd}", verbose=False)
         if verbose:
-            print(color_text(f"\n(Symlinked to: {spath_cwd})", "yellow"))
+            # Get file extension to provide more informative message
+            ext = _os.path.splitext(spath_cwd)[1].lower()
+            logger.success(color_text(f"(Symlinked to: {spath_cwd})"))
+
+
+def _symlink_to(spath_final, symlink_to, verbose):
+    """Create a symbolic link at the specified path pointing to the saved file."""
+    if symlink_to:
+        # Convert Path objects to strings for consistency
+        if isinstance(symlink_to, Path):
+            symlink_to = str(symlink_to)
+
+        # Clean the symlink path
+        symlink_to = clean(symlink_to)
+
+        # Ensure the symlink directory exists
+        _os.makedirs(_os.path.dirname(symlink_to), exist_ok=True)
+
+        # Remove existing symlink or file
+        sh(f"rm -f {symlink_to}", verbose=False)
+
+        # Create the symlink using relative path for robustness
+        sh(f"ln -sfr {spath_final} {symlink_to}", verbose=False)
+
+        if verbose:
+            print(color_text(f"\n(Symlinked to: {symlink_to})", "yellow"))
 
 
 def _save(
@@ -347,18 +471,40 @@ def _save(
     symlink_from_cwd=False,
     dry_run=False,
     no_csv=False,
+    symlink_to=None,
     **kwargs,
 ):
+    # Don't use object's own save method - use consistent handlers
+    # This ensures all saves go through the same pipeline and get
+    # the yellow confirmation message
+
     # Get file extension
     ext = _os.path.splitext(spath)[1].lower()
-    
+
     # Try dispatch dictionary first for O(1) lookup
     if ext in _FILE_HANDLERS:
         # Check if handler needs special parameters
-        if ext in ['.png', '.jpg', '.jpeg', '.gif', '.tiff', '.tif', '.svc']:
-            _FILE_HANDLERS[ext](obj, spath, no_csv=no_csv, symlink_from_cwd=symlink_from_cwd, dry_run=dry_run, **kwargs)
-        elif ext in ['.hdf5', '.h5']:
-            # HDF5 files may need special 'key' parameter
+        if ext in [
+            ".png",
+            ".jpg",
+            ".jpeg",
+            ".gif",
+            ".tiff",
+            ".tif",
+            ".svg",
+            ".pdf",
+        ]:
+            _FILE_HANDLERS[ext](
+                obj,
+                spath,
+                no_csv=no_csv,
+                symlink_from_cwd=symlink_from_cwd,
+                symlink_to=symlink_to,
+                dry_run=dry_run,
+                **kwargs,
+            )
+        elif ext in [".hdf5", ".h5", ".zarr"]:
+            # HDF5 and Zarr files may need special 'key' parameter
             _FILE_HANDLERS[ext](obj, spath, **kwargs)
         else:
             _FILE_HANDLERS[ext](obj, spath, **kwargs)
@@ -375,165 +521,277 @@ def _save(
         if _os.path.exists(spath):
             file_size = getsize(spath)
             file_size = readable_bytes(file_size)
-            print(color_text(f"\nSaved to: {spath} ({file_size})", c="yellow"))
+            # Get relative path from current working directory
+            try:
+                rel_path = _os.path.relpath(spath, _os.getcwd())
+            except ValueError:
+                rel_path = spath
 
+            print()
+            logger.success(f"Saved to: ./{rel_path} ({file_size})")
 
-def _save_separate_legends(obj, spath, symlink_from_cwd=False, dry_run=False, **kwargs):
+
+def _save_separate_legends(
+    obj, spath, symlink_from_cwd=False, dry_run=False, **kwargs
+):
     """Save separate legend files if ax.legend('separate') was used."""
-    import matplotlib.pyplot as plt
+    if dry_run:
+        return
+
     import matplotlib.figure
-    
+    import matplotlib.pyplot as plt
+
     # Get the matplotlib figure object
     fig = None
     if isinstance(obj, matplotlib.figure.Figure):
         fig = obj
-    elif hasattr(obj, '_fig_mpl'):
+    elif hasattr(obj, "_fig_mpl"):
         fig = obj._fig_mpl
-    elif hasattr(obj, 'figure'):
+    elif hasattr(obj, "figure"):
         if isinstance(obj.figure, matplotlib.figure.Figure):
             fig = obj.figure
-        elif hasattr(obj.figure, '_fig_mpl'):
+        elif hasattr(obj.figure, "_fig_mpl"):
             fig = obj.figure._fig_mpl
-    
+
     if fig is None:
         return
-    
+
     # Check if there are separate legend parameters stored
-    if not hasattr(fig, '_separate_legend_params'):
+    if not hasattr(fig, "_separate_legend_params"):
         return
-    
+
     # Save each legend as a separate file
     base_path = _os.path.splitext(spath)[0]
     ext = _os.path.splitext(spath)[1]
-    
+
     for legend_params in fig._separate_legend_params:
         # Create a new figure for the legend
-        legend_fig = plt.figure(figsize=legend_params['figsize'])
+        legend_fig = plt.figure(figsize=legend_params["figsize"])
         legend_ax = legend_fig.add_subplot(111)
-        
+
         # Create the legend
         legend = legend_ax.legend(
-            legend_params['handles'],
-            legend_params['labels'],
-            loc='center',
-            frameon=legend_params['frameon'],
-            fancybox=legend_params['fancybox'],
-            shadow=legend_params['shadow'],
-            **legend_params['kwargs']
+            legend_params["handles"],
+            legend_params["labels"],
+            loc="center",
+            frameon=legend_params["frameon"],
+            fancybox=legend_params["fancybox"],
+            shadow=legend_params["shadow"],
+            **legend_params["kwargs"],
         )
-        
+
         # Remove axes
-        legend_ax.axis('off')
-        
+        legend_ax.axis("off")
+
         # Adjust layout to fit the legend
         legend_fig.tight_layout()
-        
+
         # Save the legend figure
         legend_filename = f"{base_path}_{legend_params['axis_id']}_legend{ext}"
         save_image(legend_fig, legend_filename, **kwargs)
-        
+
         # Close the legend figure to free memory
         plt.close(legend_fig)
-        
+
         if not dry_run and _os.path.exists(legend_filename):
             file_size = getsize(legend_filename)
             file_size = readable_bytes(file_size)
-            print(color_text(f"\nSaved legend to: {legend_filename} ({file_size})", c="yellow"))
+            print(
+                color_text(
+                    f"\nSaved legend to: {legend_filename} ({file_size})",
+                    c="yellow",
+                )
+            )
 
 
-def _handle_image_with_csv(obj, spath, no_csv=False, symlink_from_cwd=False, dry_run=False, **kwargs):
+def _handle_image_with_csv(
+    obj,
+    spath,
+    no_csv=False,
+    symlink_from_cwd=False,
+    dry_run=False,
+    symlink_to=None,
+    **kwargs,
+):
     """Handle image file saving with optional CSV export."""
+    if dry_run:
+        return
+
     save_image(obj, spath, **kwargs)
-    
+
     # Handle separate legend saving
-    _save_separate_legends(obj, spath, symlink_from_cwd=symlink_from_cwd, dry_run=dry_run, **kwargs)
-    
+    _save_separate_legends(
+        obj,
+        spath,
+        symlink_from_cwd=symlink_from_cwd,
+        dry_run=dry_run,
+        **kwargs,
+    )
+
     if not no_csv:
         ext = _os.path.splitext(spath)[1].lower()
         ext_wo_dot = ext.replace(".", "")
-        
+
         try:
             # Get the figure object that may contain plot data
             fig_obj = _get_figure_with_data(obj)
-            
+
             if fig_obj is not None:
                 # Save regular CSV if export method exists
-                if hasattr(fig_obj, 'export_as_csv'):
+                if hasattr(fig_obj, "export_as_csv"):
                     csv_data = fig_obj.export_as_csv()
                     if csv_data is not None and not csv_data.empty:
-                        save(
+                        # Save CSV in same directory as image with .csv extension
+                        # Example: ./path/to/output/fig.jpg -> ./path/to/output/fig.csv
+                        csv_path = _os.path.splitext(spath)[0] + ".csv"
+                        # Ensure parent directory exists (should already exist from image save)
+                        _os.makedirs(_os.path.dirname(csv_path), exist_ok=True)
+                        # Save directly using _save to avoid path doubling
+                        # Don't pass image-specific kwargs to CSV save
+                        _save(
                             csv_data,
-                            spath.replace(ext_wo_dot, "csv"),
-                            symlink_from_cwd=symlink_from_cwd,
+                            csv_path,
+                            verbose=True,
+                            symlink_from_cwd=False,  # Will handle symlink manually
                             dry_run=dry_run,
                             no_csv=True,
-                            **kwargs,
                         )
-                
+
+                        # Create symlink_to for CSV if it was specified for the image
+                        if symlink_to:
+                            csv_symlink_to = (
+                                _os.path.splitext(symlink_to)[0] + ".csv"
+                            )
+                            _symlink_to(csv_path, csv_symlink_to, True)
+
+                        # Create symlink for CSV manually if needed
+                        if symlink_from_cwd:
+                            # Get the relative path from the original specified path
+                            # This preserves the directory structure for the symlink
+                            import inspect
+
+                            frame_info = inspect.stack()
+                            # Find the original specified_path from the parent save() call
+                            for frame in frame_info:
+                                if "specified_path" in frame.frame.f_locals:
+                                    original_path = frame.frame.f_locals[
+                                        "specified_path"
+                                    ]
+                                    if isinstance(original_path, str):
+                                        # Replace extension to get CSV path structure
+                                        csv_relative = original_path.replace(
+                                            _os.path.splitext(original_path)[
+                                                1
+                                            ],
+                                            ".csv",
+                                        )
+                                        csv_cwd = _os.path.join(
+                                            _os.getcwd(), csv_relative
+                                        )
+                                        _symlink(csv_path, csv_cwd, True, True)
+                                        break
+                            else:
+                                # Fallback to basename if we can't find the original path
+                                csv_cwd = (
+                                    _os.getcwd()
+                                    + "/"
+                                    + _os.path.basename(csv_path)
+                                )
+                                _symlink(csv_path, csv_cwd, True, True)
+
                 # Save SigmaPlot CSV if method exists
-                if hasattr(fig_obj, 'export_as_csv_for_sigmaplot'):
+                if hasattr(fig_obj, "export_as_csv_for_sigmaplot"):
                     sigmaplot_data = fig_obj.export_as_csv_for_sigmaplot()
                     if sigmaplot_data is not None and not sigmaplot_data.empty:
-                        save(
+                        # For CSV files, we want them in the same directory as the image
+                        csv_sigmaplot_path = spath.replace(
+                            ext_wo_dot, "csv"
+                        ).replace(".csv", "_for_sigmaplot.csv")
+                        # Save directly using _save to avoid path doubling
+                        # Don't pass image-specific kwargs to CSV save
+                        _save(
                             sigmaplot_data,
-                            spath.replace(ext_wo_dot, "csv").replace(".csv", "_for_sigmaplot.csv"),
-                            symlink_from_cwd=symlink_from_cwd,
+                            csv_sigmaplot_path,
+                            verbose=True,
+                            symlink_from_cwd=False,  # Will handle symlink manually
                             dry_run=dry_run,
                             no_csv=True,
-                            **kwargs,
                         )
-        except Exception:
-            pass
+
+                        # Create symlink_to for SigmaPlot CSV if it was specified for the image
+                        if symlink_to:
+                            csv_sigmaplot_symlink_to = (
+                                _os.path.splitext(symlink_to)[0]
+                                + "_for_sigmaplot.csv"
+                            )
+                            _symlink_to(
+                                csv_sigmaplot_path,
+                                csv_sigmaplot_symlink_to,
+                                True,
+                            )
+
+                        # Create symlink for SigmaPlot CSV manually if needed
+                        if symlink_from_cwd:
+                            csv_cwd = (
+                                _os.getcwd()
+                                + "/"
+                                + _os.path.basename(csv_sigmaplot_path)
+                            )
+                            _symlink(csv_sigmaplot_path, csv_cwd, True, True)
+        except Exception as e:
+            import warnings
+
+            warnings.warn(f"CSV export failed: {e}")
+            import traceback
+
+            traceback.print_exc()
 
 
 # Dispatch dictionary for O(1) file format lookup
 _FILE_HANDLERS = {
     # Excel formats
-    '.xlsx': save_excel,
-    '.xls': save_excel,
-    
+    ".xlsx": save_excel,
+    ".xls": save_excel,
     # NumPy formats
-    '.npy': save_npy,
-    '.npz': save_npz,
-    
+    ".npy": save_npy,
+    ".npz": save_npz,
     # Pickle formats
-    '.pkl': save_pickle,
-    '.pickle': save_pickle,
-    '.pkl.gz': save_pickle_compressed,
-    
+    ".pkl": save_pickle,
+    ".pickle": save_pickle,
+    ".pkl.gz": save_pickle_compressed,
     # Other binary formats
-    '.joblib': save_joblib,
-    '.pth': save_torch,
-    '.pt': save_torch,
-    '.mat': save_matlab,
-    '.cbm': save_catboost,
-    
+    ".joblib": save_joblib,
+    ".pth": save_torch,
+    ".pt": save_torch,
+    ".mat": save_matlab,
+    ".cbm": save_catboost,
     # Text formats
-    '.json': save_json,
-    '.yaml': save_yaml,
-    '.yml': save_yaml,
-    '.txt': save_text,
-    '.md': save_text,
-    '.py': save_text,
-    '.css': save_text,
-    '.js': save_text,
-    
+    ".json": save_json,
+    ".yaml": save_yaml,
+    ".yml": save_yaml,
+    ".txt": save_text,
+    ".md": save_text,
+    ".py": save_text,
+    ".css": save_text,
+    ".js": save_text,
+    ".tex": save_tex,
+    # Bibliography
+    ".bib": save_bibtex,
     # Data formats
-    '.html': save_html,
-    '.hdf5': save_hdf5,
-    '.h5': save_hdf5,
-    
+    ".html": save_html,
+    ".hdf5": save_hdf5,
+    ".h5": save_hdf5,
+    ".zarr": save_zarr,
     # Media formats
-    '.mp4': save_mp4,
-    '.png': _handle_image_with_csv,
-    '.jpg': _handle_image_with_csv,
-    '.jpeg': _handle_image_with_csv,
-    '.gif': _handle_image_with_csv,
-    '.tiff': _handle_image_with_csv,
-    '.tif': _handle_image_with_csv,
-    '.svg': _handle_image_with_csv,
-    '.pdf': _handle_image_with_csv,
+    ".mp4": save_mp4,
+    ".png": _handle_image_with_csv,
+    ".jpg": _handle_image_with_csv,
+    ".jpeg": _handle_image_with_csv,
+    ".gif": _handle_image_with_csv,
+    ".tiff": _handle_image_with_csv,
+    ".tif": _handle_image_with_csv,
+    ".svg": _handle_image_with_csv,
+    ".pdf": _handle_image_with_csv,
 }
 
-
 # EOF