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

scitex/plt/_subplots/_export_as_csv_formatters/_format_stx_ecdf.py

@@ -6,37 +6,50 @@
 import os
 import pandas as pd
 
+from scitex.plt.utils._csv_column_naming import get_csv_column_name
+from ._format_plot import _parse_tracking_id
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
+
 def _format_plot_ecdf(id, tracked_dict, kwargs):
     """Format data from a stx_ecdf call.
-    
+
     Args:
         id (str): Identifier for the plot
         tracked_dict (dict): Dictionary containing 'ecdf_df' key with ECDF data
         kwargs (dict): Keyword arguments passed to stx_ecdf
-        
+
     Returns:
         pd.DataFrame: Formatted ECDF data
     """
     # Check if tracked_dict is empty or not a dictionary
     if not tracked_dict or not isinstance(tracked_dict, dict):
         return pd.DataFrame()
-    
+
     # Get the ecdf_df from tracked_dict
-    ecdf_df = tracked_dict.get('ecdf_df')
-    
+    ecdf_df = tracked_dict.get("ecdf_df")
+
     if ecdf_df is None or not isinstance(ecdf_df, pd.DataFrame):
         return pd.DataFrame()
-    
+
     # Create a copy to avoid modifying the original
     result = ecdf_df.copy()
-    
+
     # Add prefix to column names if ID is provided
     if id is not None:
-        # Rename columns with ID prefix
-        result.columns = [f"{id}_ecdf_{col}" for col in result.columns]
-    
-    return result
+        # Parse the tracking ID to get axes position and trace ID
+        ax_row, ax_col, trace_id = _parse_tracking_id(id)
+
+        # Rename columns using single source of truth
+        renamed = {}
+        for col in result.columns:
+            # Use the original column name as the variable (e.g., "ecdf_value", "ecdf_prob")
+            renamed[col] = get_csv_column_name(
+                f"ecdf_{col}", ax_row, ax_col, trace_id=trace_id
+            )
+        result = result.rename(columns=renamed)
+
+    return result

scitex/plt/_subplots/_export_as_csv_formatters/_format_stx_errorbar.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""CSV formatter for stx_errorbar() calls."""
+
+import pandas as pd
+import numpy as np
+from scitex.plt.utils._csv_column_naming import get_csv_column_name
+from ._format_plot import _parse_tracking_id
+
+
+def _format_stx_errorbar(id, tracked_dict, kwargs):
+    """Format data from stx_errorbar call for CSV export.
+
+    Parameters
+    ----------
+    id : str
+        Tracking identifier
+    tracked_dict : dict
+        Dictionary containing tracked data with 'errorbar_df' key
+    kwargs : dict
+        Additional keyword arguments (may contain yerr, xerr)
+
+    Returns
+    -------
+    pd.DataFrame
+        Formatted errorbar data with standardized column names
+    """
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+
+    ax_row, ax_col, trace_id = _parse_tracking_id(id)
+
+    # Get errorbar_df from tracked data
+    errorbar_df = tracked_dict.get("errorbar_df")
+    if errorbar_df is not None and isinstance(errorbar_df, pd.DataFrame):
+        result = errorbar_df.copy()
+        renamed = {}
+
+        # Map columns to standardized names
+        for col in result.columns:
+            if col == "x":
+                renamed[col] = get_csv_column_name("x", ax_row, ax_col, trace_id=trace_id)
+            elif col == "y":
+                renamed[col] = get_csv_column_name("y", ax_row, ax_col, trace_id=trace_id)
+            elif col == "yerr":
+                # Check if yerr is asymmetric (tuple/list of 2)
+                yerr_value = result[col].iloc[0] if len(result) > 0 else None
+                if isinstance(yerr_value, (list, tuple)) and len(yerr_value) == 2:
+                    # Handle asymmetric yerr separately below
+                    continue
+                else:
+                    renamed[col] = get_csv_column_name("yerr", ax_row, ax_col, trace_id=trace_id)
+            elif col == "xerr":
+                # Check if xerr is asymmetric (tuple/list of 2)
+                xerr_value = result[col].iloc[0] if len(result) > 0 else None
+                if isinstance(xerr_value, (list, tuple)) and len(xerr_value) == 2:
+                    # Handle asymmetric xerr separately below
+                    continue
+                else:
+                    renamed[col] = get_csv_column_name("xerr", ax_row, ax_col, trace_id=trace_id)
+            else:
+                renamed[col] = get_csv_column_name(col, ax_row, ax_col, trace_id=trace_id)
+
+        result = result.rename(columns=renamed)
+
+        # Handle asymmetric error bars if needed from kwargs
+        yerr = kwargs.get("yerr") if kwargs else None
+        xerr = kwargs.get("xerr") if kwargs else None
+
+        if yerr is not None and isinstance(yerr, (list, tuple)) and len(yerr) == 2:
+            col_yerr_neg = get_csv_column_name("yerr-neg", ax_row, ax_col, trace_id=trace_id)
+            col_yerr_pos = get_csv_column_name("yerr-pos", ax_row, ax_col, trace_id=trace_id)
+            result[col_yerr_neg] = yerr[0]
+            result[col_yerr_pos] = yerr[1]
+
+        if xerr is not None and isinstance(xerr, (list, tuple)) and len(xerr) == 2:
+            col_xerr_neg = get_csv_column_name("xerr-neg", ax_row, ax_col, trace_id=trace_id)
+            col_xerr_pos = get_csv_column_name("xerr-pos", ax_row, ax_col, trace_id=trace_id)
+            result[col_xerr_neg] = xerr[0]
+            result[col_xerr_pos] = xerr[1]
+
+        return result
+
+    # Fallback to args if errorbar_df not found
+    args = tracked_dict.get("args", [])
+    if len(args) >= 2:
+        col_x = get_csv_column_name("x", ax_row, ax_col, trace_id=trace_id)
+        col_y = get_csv_column_name("y", ax_row, ax_col, trace_id=trace_id)
+        data = {col_x: args[0], col_y: args[1]}
+
+        # Add error bars if present
+        yerr = kwargs.get("yerr") if kwargs else None
+        xerr = kwargs.get("xerr") if kwargs else None
+
+        if yerr is not None:
+            if isinstance(yerr, (list, tuple)) and len(yerr) == 2:
+                col_yerr_neg = get_csv_column_name("yerr-neg", ax_row, ax_col, trace_id=trace_id)
+                col_yerr_pos = get_csv_column_name("yerr-pos", ax_row, ax_col, trace_id=trace_id)
+                data[col_yerr_neg] = yerr[0]
+                data[col_yerr_pos] = yerr[1]
+            else:
+                col_yerr = get_csv_column_name("yerr", ax_row, ax_col, trace_id=trace_id)
+                data[col_yerr] = yerr
+
+        if xerr is not None:
+            if isinstance(xerr, (list, tuple)) and len(xerr) == 2:
+                col_xerr_neg = get_csv_column_name("xerr-neg", ax_row, ax_col, trace_id=trace_id)
+                col_xerr_pos = get_csv_column_name("xerr-pos", ax_row, ax_col, trace_id=trace_id)
+                data[col_xerr_neg] = xerr[0]
+                data[col_xerr_pos] = xerr[1]
+            else:
+                col_xerr = get_csv_column_name("xerr", ax_row, ax_col, trace_id=trace_id)
+                data[col_xerr] = xerr
+
+        return pd.DataFrame(data)
+
+    return pd.DataFrame()
+
+
+# EOF

scitex/plt/_subplots/_export_as_csv_formatters/_format_stx_fillv.py

@@ -1,45 +1,52 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Timestamp: "2025-05-18 18:14:26 (ywatanabe)"
-# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_fillv.py
-# ----------------------------------------
-import os
-__FILE__ = __file__
-__DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
+# Timestamp: "2025-12-10 12:00:00 (ywatanabe)"
+# File: ./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_stx_fillv.py
+
+"""CSV formatter for stx_fillv() calls - uses standard column naming."""
 
 import numpy as np
 import pandas as pd
 
+from scitex.plt.utils._csv_column_naming import get_csv_column_name
+
+from ._format_plot import _parse_tracking_id
+
+
 def _format_plot_fillv(id, tracked_dict, kwargs):
     """Format data from a stx_fillv call.
-    
+
     Formats data similar to line plot format for better compatibility.
-    
+    Uses standard column naming convention:
+    (ax-row-{r}-col-{c}_trace-id-{id}_variable-{var}).
+
     Args:
         id (str): Identifier for the plot
         tracked_dict (dict): Dictionary containing tracked data
         kwargs (dict): Keyword arguments passed to stx_fillv
-        
+
     Returns:
         pd.DataFrame: Formatted fillv data in a long-format dataframe
     """
     # Check if tracked_dict is empty or not a dictionary
     if not tracked_dict or not isinstance(tracked_dict, dict):
         return pd.DataFrame()
-    
+
+    # Parse tracking ID to get axes position
+    ax_row, ax_col, trace_id = _parse_tracking_id(id)
+
     # Try to get starts/ends directly from tracked_dict first
-    starts = tracked_dict.get('starts')
-    ends = tracked_dict.get('ends')
-    
+    starts = tracked_dict.get("starts")
+    ends = tracked_dict.get("ends")
+
     # If not found, get from args
     if starts is None or ends is None:
-        args = tracked_dict.get('args', [])
-        
+        args = tracked_dict.get("args", [])
+
         # Extract data if available from args
         if len(args) >= 2:
             starts, ends = args[0], args[1]
-    
+
     # If we have valid starts and ends, create a DataFrame in a format similar to line plot
     if starts is not None and ends is not None:
         # Convert to numpy arrays if they're lists for better handling
@@ -47,22 +54,19 @@ def _format_plot_fillv(id, tracked_dict, kwargs):
             starts = np.array(starts)
         if isinstance(ends, list):
             ends = np.array(ends)
-        
+
+        # Get standard column names
+        x_col = get_csv_column_name("x", ax_row, ax_col, trace_id=trace_id)
+        y_col = get_csv_column_name("y", ax_row, ax_col, trace_id=trace_id)
+        type_col = get_csv_column_name("type", ax_row, ax_col, trace_id=trace_id)
+
         # Create a DataFrame with x, y pairs for each fill span
         rows = []
         for start, end in zip(starts, ends):
-            rows.append({
-                f"{id}_x": start,
-                f"{id}_y": 0,
-                f"{id}_type": "start"
-            })
-            rows.append({
-                f"{id}_x": end,
-                f"{id}_y": 0,
-                f"{id}_type": "end"
-            })
-        
+            rows.append({x_col: start, y_col: 0, type_col: "start"})
+            rows.append({x_col: end, y_col: 0, type_col: "end"})
+
         if rows:
             return pd.DataFrame(rows)
-    
-    return pd.DataFrame()
+
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_stx_heatmap.py

@@ -4,6 +4,7 @@
 # File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_heatmap.py
 # ----------------------------------------
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -11,54 +12,63 @@ __DIR__ = os.path.dirname(__FILE__)
 import numpy as np
 import pandas as pd
 
+from scitex.plt.utils._csv_column_naming import get_csv_column_name
+from ._format_plot import _parse_tracking_id
+
+
 def _format_plot_heatmap(id, tracked_dict, kwargs):
     """Format data from a stx_heatmap call.
-    
+
     Exports heatmap data in xyz format (x, y, value) for better compatibility.
-    
+
     Args:
         id (str): Identifier for the plot
         tracked_dict (dict): Dictionary containing tracked data
         kwargs (dict): Keyword arguments passed to stx_heatmap
-        
+
     Returns:
         pd.DataFrame: Formatted heatmap data in xyz format
     """
     # Check if tracked_dict is empty or not a dictionary
     if not tracked_dict or not isinstance(tracked_dict, dict):
         return pd.DataFrame()
-        
+
     # Extract data from tracked_dict
-    data = tracked_dict.get('data')
-    x_labels = tracked_dict.get('x_labels')
-    y_labels = tracked_dict.get('y_labels')
-    
+    data = tracked_dict.get("data")
+    x_labels = tracked_dict.get("x_labels")
+    y_labels = tracked_dict.get("y_labels")
+
     if data is not None and hasattr(data, "shape") and len(data.shape) == 2:
         rows, cols = data.shape
-        row_indices, col_indices = np.meshgrid(
-            range(rows), range(cols), indexing="ij"
-        )
-        
-        # Format data in xyz format (x, y, value)
+        row_indices, col_indices = np.meshgrid(range(rows), range(cols), indexing="ij")
+
+        # Parse the tracking ID to get axes position and trace ID
+        ax_row, ax_col, trace_id = _parse_tracking_id(id)
+
+        # Format data in xyz format (x, y, value) using single source of truth
         df = pd.DataFrame(
             {
-                f"{id}_x": col_indices.flatten(),  # x is column
-                f"{id}_y": row_indices.flatten(),  # y is row
-                f"{id}_value": data.flatten(),     # z is intensity/value
+                get_csv_column_name("x", ax_row, ax_col, trace_id=trace_id): col_indices.flatten(),  # x is column
+                get_csv_column_name("y", ax_row, ax_col, trace_id=trace_id): row_indices.flatten(),  # y is row
+                get_csv_column_name("value", ax_row, ax_col, trace_id=trace_id): data.flatten(),  # z is intensity/value
             }
         )
-        
+
         # Add label information if available
         if x_labels is not None and len(x_labels) == cols:
             # Map column indices to x labels (columns are x)
             x_label_map = {i: label for i, label in enumerate(x_labels)}
-            df[f"{id}_x_label"] = df[f"{id}_x"].map(x_label_map)
-            
+            x_col_name = get_csv_column_name("x", ax_row, ax_col, trace_id=trace_id)
+            x_label_col_name = get_csv_column_name("x_label", ax_row, ax_col, trace_id=trace_id)
+            df[x_label_col_name] = df[x_col_name].map(x_label_map)
+
         if y_labels is not None and len(y_labels) == rows:
             # Map row indices to y labels (rows are y)
             y_label_map = {i: label for i, label in enumerate(y_labels)}
-            df[f"{id}_y_label"] = df[f"{id}_y"].map(y_label_map)
-            
+            y_col_name = get_csv_column_name("y", ax_row, ax_col, trace_id=trace_id)
+            y_label_col_name = get_csv_column_name("y_label", ax_row, ax_col, trace_id=trace_id)
+            df[y_label_col_name] = df[y_col_name].map(y_label_map)
+
         return df
-        
-    return pd.DataFrame()
+
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_stx_image.py

@@ -7,28 +7,35 @@ import os
 import numpy as np
 import pandas as pd
 
+from scitex.plt.utils._csv_column_naming import get_csv_column_name
+from ._format_plot import _parse_tracking_id
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
+
 def _format_plot_image(id, tracked_dict, kwargs):
     """Format data from a stx_image call.
-    
+
     Exports image data in long-format xyz format for better compatibility.
     Also saves channel data for RGB/RGBA images.
-    
+
     Args:
         id (str or int): Identifier for the plot
         tracked_dict (dict): Dictionary containing tracked data
         kwargs (dict): Keyword arguments passed to stx_image
-        
+
     Returns:
         pd.DataFrame: Formatted image data in xyz format
     """
     # Check if tracked_dict is not a dictionary or is empty
     if not tracked_dict or not isinstance(tracked_dict, dict):
         return pd.DataFrame()
-        
+
+    # Parse the tracking ID to get axes position and trace ID
+    ax_row, ax_col, trace_id = _parse_tracking_id(id)
+
     # Check if image_df is available and use it if present
     if "image_df" in tracked_dict:
         image_df = tracked_dict.get("image_df")
@@ -36,17 +43,21 @@ def _format_plot_image(id, tracked_dict, kwargs):
             # Add prefix if ID is provided
             if id is not None:
                 image_df = image_df.copy()
-                id_str = str(id)
-                # Convert columns to strings first to handle integer column names
-                image_df.columns = [str(col) for col in image_df.columns]
-                image_df.columns = [f"{id_str}_{col}" if not col.startswith(f"{id_str}_") else col for col in image_df.columns]
+                # Rename columns using single source of truth
+                renamed = {}
+                for col in image_df.columns:
+                    # Convert to string to handle integer column names
+                    col_str = str(col)
+                    renamed[col] = get_csv_column_name(
+                        col_str, ax_row, ax_col, trace_id=trace_id
+                    )
+                image_df = image_df.rename(columns=renamed)
             return image_df
-    
+
     # If we have image data
     if "image" in tracked_dict:
         img = tracked_dict["image"]
-        id_str = str(id) if id is not None else "image"
-        
+
         # Handle 2D grayscale images - create xyz format (x, y, value)
         if isinstance(img, np.ndarray) and img.ndim == 2:
             rows, cols = img.shape
@@ -54,12 +65,12 @@ def _format_plot_image(id, tracked_dict, kwargs):
                 range(rows), range(cols), indexing="ij"
             )
 
-            # Create xyz format
+            # Create xyz format using single source of truth
             df = pd.DataFrame(
                 {
-                    f"{id_str}_x": col_indices.flatten(),  # x is column
-                    f"{id_str}_y": row_indices.flatten(),  # y is row
-                    f"{id_str}_value": img.flatten(),      # z is intensity
+                    get_csv_column_name("x", ax_row, ax_col, trace_id=trace_id): col_indices.flatten(),  # x is column
+                    get_csv_column_name("y", ax_row, ax_col, trace_id=trace_id): row_indices.flatten(),  # y is row
+                    get_csv_column_name("value", ax_row, ax_col, trace_id=trace_id): img.flatten(),  # z is intensity
                 }
             )
             return df
@@ -67,27 +78,32 @@ def _format_plot_image(id, tracked_dict, kwargs):
         # Handle RGB/RGBA images - create xyz format with additional channel information
         elif isinstance(img, np.ndarray) and img.ndim == 3:
             rows, cols, channels = img.shape
-            row_indices, col_indices = np.meshgrid(
-                range(rows), range(cols), indexing="ij"
-            )
 
             # Create a list to hold rows for a long-format DataFrame
             data_rows = []
             channel_names = ["r", "g", "b", "a"]
-            
+
+            # Get column names using single source of truth
+            x_col = get_csv_column_name("x", ax_row, ax_col, trace_id=trace_id)
+            y_col = get_csv_column_name("y", ax_row, ax_col, trace_id=trace_id)
+            channel_col = get_csv_column_name("channel", ax_row, ax_col, trace_id=trace_id)
+            value_col = get_csv_column_name("value", ax_row, ax_col, trace_id=trace_id)
+
             # Create long-format data (x, y, channel, value)
             for r in range(rows):
                 for c in range(cols):
                     for ch in range(min(channels, len(channel_names))):
-                        data_rows.append({
-                            f"{id_str}_x": c,                      # x is column
-                            f"{id_str}_y": r,                      # y is row
-                            f"{id_str}_channel": channel_names[ch],  # channel name
-                            f"{id_str}_value": img[r, c, ch]        # channel value
-                        })
-            
+                        data_rows.append(
+                            {
+                                x_col: c,  # x is column
+                                y_col: r,  # y is row
+                                channel_col: channel_names[ch],  # channel name
+                                value_col: img[r, c, ch],  # channel value
+                            }
+                        )
+
             # Return long-format DataFrame
             return pd.DataFrame(data_rows)
-    
+
     # Skip CSV export if no suitable data format found
-    return pd.DataFrame()
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_stx_imshow.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""CSV formatter for stx_imshow() calls."""
+
+import numpy as np
+import pandas as pd
+from scitex.plt.utils._csv_column_naming import get_csv_column_name
+from ._format_plot import _parse_tracking_id
+
+
+def _format_stx_imshow(id, tracked_dict, kwargs):
+    """Format data from stx_imshow call for CSV export.
+
+    Parameters
+    ----------
+    id : str
+        Identifier for the plot
+    tracked_dict : dict
+        Dictionary containing tracked data with 'imshow_df'
+    kwargs : dict
+        Keyword arguments passed to stx_imshow
+
+    Returns
+    -------
+    pd.DataFrame
+        Formatted imshow data in row, col, value format (or row, col, R, G, B for RGB)
+    """
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+
+    ax_row, ax_col, trace_id = _parse_tracking_id(id)
+
+    # Get imshow_df from tracked_dict
+    imshow_df = tracked_dict.get("imshow_df")
+    if imshow_df is not None and isinstance(imshow_df, pd.DataFrame):
+        # Convert from 2D DataFrame format (with col_0, col_1, ... columns)
+        # to row, col, value format for easier analysis
+        n_rows, n_cols = imshow_df.shape
+
+        # Create row and column indices
+        row_indices = np.repeat(np.arange(n_rows), n_cols)
+        col_indices = np.tile(np.arange(n_cols), n_rows)
+
+        # Get column names from single source of truth
+        col_row = get_csv_column_name("row", ax_row, ax_col, trace_id=trace_id)
+        col_col = get_csv_column_name("col", ax_row, ax_col, trace_id=trace_id)
+        col_value = get_csv_column_name("value", ax_row, ax_col, trace_id=trace_id)
+
+        # Flatten the DataFrame values
+        values = imshow_df.values.flatten()
+
+        result = pd.DataFrame({
+            col_row: row_indices,
+            col_col: col_indices,
+            col_value: values
+        })
+
+        return result
+
+    return pd.DataFrame()
+
+
+# EOF

scitex/plt/_subplots/_export_as_csv_formatters/_format_stx_joyplot.py

@@ -4,6 +4,7 @@
 # File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_joyplot.py
 # ----------------------------------------
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -11,25 +12,31 @@ __DIR__ = os.path.dirname(__FILE__)
 import numpy as np
 import pandas as pd
 from scitex.pd import force_df
+from scitex.plt.utils._csv_column_naming import get_csv_column_name
+from ._format_plot import _parse_tracking_id
+
 
 def _format_plot_joyplot(id, tracked_dict, kwargs):
     """Format data from a stx_joyplot call.
-    
+
     Args:
         id (str): Identifier for the plot
         tracked_dict (dict): Dictionary containing 'joyplot_data' key with joyplot data
         kwargs (dict): Keyword arguments passed to stx_joyplot
-        
+
     Returns:
         pd.DataFrame: Formatted joyplot data
     """
     # Check if tracked_dict is empty or not a dictionary
     if not tracked_dict or not isinstance(tracked_dict, dict):
         return pd.DataFrame()
-    
+
+    # Parse tracking ID to get axes position and trace ID
+    ax_row, ax_col, trace_id = _parse_tracking_id(id)
+
     # Get joyplot_data from tracked_dict
-    data = tracked_dict.get('joyplot_data')
-    
+    data = tracked_dict.get("joyplot_data")
+
     if data is None:
         return pd.DataFrame()
 
@@ -37,16 +44,22 @@ def _format_plot_joyplot(id, tracked_dict, kwargs):
     if isinstance(data, pd.DataFrame):
         # Make a copy to avoid modifying original
         result = data.copy()
-        # Add prefix to column names if ID is provided
+        # Add prefix to column names using single source of truth
         if id is not None:
-            result.columns = [f"{id}_joyplot_{col}" for col in result.columns]
+            result.columns = [
+                get_csv_column_name(f"joyplot-{col}", ax_row, ax_col, trace_id=trace_id)
+                for col in result.columns
+            ]
         return result
 
     elif isinstance(data, dict):
         # Convert dictionary to DataFrame
         result = pd.DataFrame()
         for group, values in data.items():
-            result[f"{id}_joyplot_{group}"] = pd.Series(values)
+            col_name = get_csv_column_name(
+                f"joyplot-{group}", ax_row, ax_col, trace_id=trace_id
+            )
+            result[col_name] = pd.Series(values)
         return result
 
     elif isinstance(data, (list, tuple)) and all(
@@ -55,11 +68,17 @@ def _format_plot_joyplot(id, tracked_dict, kwargs):
         # Convert list of arrays to DataFrame
         result = pd.DataFrame()
         for i, values in enumerate(data):
-            result[f"{id}_joyplot_group{i:02d}"] = pd.Series(values)
+            col_name = get_csv_column_name(
+                f"joyplot-group{i:02d}", ax_row, ax_col, trace_id=trace_id
+            )
+            result[col_name] = pd.Series(values)
         return result
-    
+
     # Try to force to DataFrame as a last resort
     try:
-        return force_df({f"{id}_joyplot_data": data})
+        col_name = get_csv_column_name(
+            "joyplot-data", ax_row, ax_col, trace_id=trace_id
+        )
+        return force_df({col_name: data})
     except:
-        return pd.DataFrame()
+        return pd.DataFrame()