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

scitex/plt/_subplots/_export_as_csv.py

@@ -5,50 +5,53 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
-import warnings
-
 import numpy as np
 import pandas as pd
 from scitex.pd import to_xyz
 
+from scitex import logging
+
+logger = logging.getLogger(__name__)
+
 # Global warning registry to track which warnings have been shown
 _warning_registry = set()
 
 # Mapping of matplotlib/seaborn methods to their scitex equivalents
 _METHOD_ALTERNATIVES = {
     # Matplotlib methods
-    'imshow': 'plot_imshow',
-    'plot': 'plot',  # already tracked
-    'scatter': 'plot_scatter',  # already tracked
-    'bar': 'plot_bar',  # already tracked
-    'barh': 'plot_barh',  # already tracked
-    'hist': 'hist',  # already tracked
-    'boxplot': 'stx_box or plot_boxplot',
-    'violinplot': 'stx_violin or plot_violinplot',
-    'fill_between': 'plot_fill_between',
-    'errorbar': 'plot_errorbar',
-    'contour': 'plot_contour',
-    'heatmap': 'stx_heatmap',
-
+    "imshow": "plot_imshow",
+    "plot": "plot",  # already tracked
+    "scatter": "plot_scatter",  # already tracked
+    "bar": "plot_bar",  # already tracked
+    "barh": "plot_barh",  # already tracked
+    "hist": "hist",  # already tracked
+    "boxplot": "stx_box or plot_boxplot",
+    "violinplot": "stx_violin or plot_violinplot",
+    "fill_between": "plot_fill_between",
+    "errorbar": "plot_errorbar",
+    "contour": "plot_contour",
+    "heatmap": "stx_heatmap",
     # Seaborn methods (accessed via ax.sns_*)
-    'scatterplot': 'sns_scatterplot',
-    'lineplot': 'sns_lineplot',
-    'barplot': 'sns_barplot',
-    'boxplot_sns': 'sns_boxplot',
-    'violinplot_sns': 'sns_violinplot',
-    'stripplot': 'sns_stripplot',
-    'swarmplot': 'sns_swarmplot',
-    'histplot': 'sns_histplot',
-    'kdeplot': 'sns_kdeplot',
-    'heatmap_sns': 'sns_heatmap',
-    'jointplot': 'sns_jointplot',
-    'pairplot': 'sns_pairplot',
+    "scatterplot": "sns_scatterplot",
+    "lineplot": "sns_lineplot",
+    "barplot": "sns_barplot",
+    "boxplot_sns": "sns_boxplot",
+    "violinplot_sns": "sns_violinplot",
+    "stripplot": "sns_stripplot",
+    "swarmplot": "sns_swarmplot",
+    "histplot": "sns_histplot",
+    "kdeplot": "sns_kdeplot",
+    "heatmap_sns": "sns_heatmap",
+    "jointplot": "sns_jointplot",
+    "pairplot": "sns_pairplot",
 }
 
+
 def _warn_once(message, category=UserWarning):
     """Show a warning only once per runtime.
 
@@ -58,30 +61,77 @@ def _warn_once(message, category=UserWarning):
     """
     if message not in _warning_registry:
         _warning_registry.add(message)
-        warnings.warn(message, category, stacklevel=3)
+        logger.warning(message)
+
 
 from ._export_as_csv_formatters import (
     # Standard matplotlib formatters
-    _format_annotate, _format_bar, _format_barh, _format_boxplot,
-    _format_contour, _format_contourf, _format_errorbar, _format_eventplot,
-    _format_fill, _format_fill_between, _format_hexbin, _format_hist,
-    _format_hist2d, _format_imshow, _format_imshow2d, _format_matshow,
-    _format_pie, _format_plot, _format_quiver, _format_scatter, _format_stem,
-    _format_step, _format_streamplot, _format_text, _format_violin,
+    _format_annotate,
+    _format_bar,
+    _format_barh,
+    _format_boxplot,
+    _format_contour,
+    _format_contourf,
+    _format_errorbar,
+    _format_eventplot,
+    _format_fill,
+    _format_fill_between,
+    _format_hexbin,
+    _format_hist,
+    _format_hist2d,
+    _format_imshow,
+    _format_imshow2d,
+    _format_matshow,
+    _format_pie,
+    _format_plot,
+    _format_quiver,
+    _format_scatter,
+    _format_stem,
+    _format_step,
+    _format_streamplot,
+    _format_text,
+    _format_violin,
     _format_violinplot,
     # Custom scitex formatters
-    _format_plot_box, _format_plot_conf_mat, _format_plot_ecdf,
-    _format_plot_fillv, _format_plot_heatmap, _format_plot_image,
-    _format_plot_imshow, _format_plot_joyplot, _format_plot_kde,
-    _format_plot_line, _format_plot_mean_ci, _format_plot_mean_std,
-    _format_plot_median_iqr, _format_plot_raster, _format_plot_rectangle,
-    _format_plot_scatter, _format_plot_scatter_hist, _format_plot_shaded_line,
+    _format_plot_box,
+    _format_plot_conf_mat,
+    _format_stx_contour,
+    _format_plot_ecdf,
+    _format_plot_fillv,
+    _format_plot_heatmap,
+    _format_plot_image,
+    _format_plot_imshow,
+    _format_stx_imshow,
+    _format_plot_joyplot,
+    _format_plot_kde,
+    _format_plot_line,
+    _format_plot_mean_ci,
+    _format_plot_mean_std,
+    _format_plot_median_iqr,
+    _format_plot_raster,
+    _format_plot_rectangle,
+    _format_plot_scatter,
+    _format_plot_scatter_hist,
+    _format_plot_shaded_line,
     _format_plot_violin,
+    # stx_ aliases formatters
+    _format_stx_scatter,
+    _format_stx_bar,
+    _format_stx_barh,
+    _format_stx_errorbar,
     # Seaborn formatters
-    _format_sns_barplot, _format_sns_boxplot, _format_sns_heatmap,
-    _format_sns_histplot, _format_sns_jointplot, _format_sns_kdeplot,
-    _format_sns_lineplot, _format_sns_pairplot, _format_sns_scatterplot,
-    _format_sns_stripplot, _format_sns_swarmplot, _format_sns_violinplot,
+    _format_sns_barplot,
+    _format_sns_boxplot,
+    _format_sns_heatmap,
+    _format_sns_histplot,
+    _format_sns_jointplot,
+    _format_sns_kdeplot,
+    _format_sns_lineplot,
+    _format_sns_pairplot,
+    _format_sns_scatterplot,
+    _format_sns_stripplot,
+    _format_sns_swarmplot,
+    _format_sns_violinplot,
 )
 
 # Registry mapping method names to their formatter functions
@@ -116,11 +166,13 @@ _FORMATTER_REGISTRY = {
     # Custom scitex methods
     "stx_box": _format_plot_box,
     "stx_conf_mat": _format_plot_conf_mat,
+    "stx_contour": _format_stx_contour,
     "stx_ecdf": _format_plot_ecdf,
     "stx_fillv": _format_plot_fillv,
     "stx_heatmap": _format_plot_heatmap,
     "stx_image": _format_plot_image,
     "plot_imshow": _format_plot_imshow,
+    "stx_imshow": _format_stx_imshow,
     "stx_joyplot": _format_plot_joyplot,
     "stx_kde": _format_plot_kde,
     "stx_line": _format_plot_line,
@@ -133,6 +185,11 @@ _FORMATTER_REGISTRY = {
     "stx_scatter_hist": _format_plot_scatter_hist,
     "stx_shaded_line": _format_plot_shaded_line,
     "stx_violin": _format_plot_violin,
+    # stx_ aliases
+    "stx_scatter": _format_stx_scatter,
+    "stx_bar": _format_stx_bar,
+    "stx_barh": _format_stx_barh,
+    "stx_errorbar": _format_stx_errorbar,
     # Seaborn methods (sns_ prefix)
     "sns_barplot": _format_sns_barplot,
     "sns_boxplot": _format_sns_boxplot,
@@ -165,9 +222,7 @@ def _to_numpy(data):
         Data as numpy array
     """
     if hasattr(data, "numpy"):  # torch tensor
-        return (
-            data.detach().numpy() if hasattr(data, "detach") else data.numpy()
-        )
+        return data.detach().numpy() if hasattr(data, "detach") else data.numpy()
     elif hasattr(data, "values"):  # pandas series/dataframe
         return data.values
     else:
@@ -187,15 +242,15 @@ def export_as_csv(history_records):
         ValueError: If no plotting records are found or they cannot be combined.
     """
     if len(history_records) <= 0:
-        warnings.warn("Plotting records not found. Cannot export empty data.")
+        logger.warning("Plotting records not found. Cannot export empty data.")
         return pd.DataFrame()  # Return empty DataFrame instead of None
 
     dfs = []
     failed_methods = set()  # Track failed methods for helpful warnings
 
-    for record in list(history_records.values()):
+    for record_index, record in enumerate(list(history_records.values())):
         try:
-            formatted_df = format_record(record)
+            formatted_df = format_record(record, record_index=record_index)
             if formatted_df is not None and not formatted_df.empty:
                 dfs.append(formatted_df)
             else:
@@ -229,7 +284,7 @@ def export_as_csv(history_records):
         df = pd.concat(dfs_reset, axis=1)
         return df
     except Exception as e:
-        warnings.warn(f"Failed to combine plotting records: {e}")
+        logger.warning(f"Failed to combine plotting records: {e}")
         # Return a DataFrame with metadata about what records were attempted
         meta_df = pd.DataFrame(
             {
@@ -244,11 +299,13 @@ def export_as_csv(history_records):
         return meta_df
 
 
-def format_record(record):
+def format_record(record, record_index=0):
     """Route record to the appropriate formatting function based on plot method.
 
     Args:
         record (tuple): Plotting record tuple (id, method, tracked_dict, kwargs).
+        record_index (int): Index of this record in the history (used as fallback
+            for trace_id when user doesn't provide an explicit id= kwarg).
 
     Returns:
         pd.DataFrame: Formatted data for the plot record.
@@ -314,6 +371,8 @@ def format_record(record):
         return _format_plot_box(id, tracked_dict, kwargs)
     elif method == "stx_conf_mat":
         return _format_plot_conf_mat(id, tracked_dict, kwargs)
+    elif method == "stx_contour":
+        return _format_stx_contour(id, tracked_dict, kwargs)
     elif method == "stx_ecdf":
         return _format_plot_ecdf(id, tracked_dict, kwargs)
     elif method == "stx_fillv":
@@ -324,6 +383,8 @@ def format_record(record):
         return _format_plot_image(id, tracked_dict, kwargs)
     elif method == "plot_imshow":
         return _format_plot_imshow(id, tracked_dict, kwargs)
+    elif method == "stx_imshow":
+        return _format_stx_imshow(id, tracked_dict, kwargs)
     elif method == "stx_joyplot":
         return _format_plot_joyplot(id, tracked_dict, kwargs)
     elif method == "stx_kde":
@@ -349,6 +410,16 @@ def format_record(record):
     elif method == "stx_violin":
         return _format_plot_violin(id, tracked_dict, kwargs)
 
+    # stx_ aliases
+    elif method == "stx_scatter":
+        return _format_stx_scatter(id, tracked_dict, kwargs)
+    elif method == "stx_bar":
+        return _format_stx_bar(id, tracked_dict, kwargs)
+    elif method == "stx_barh":
+        return _format_stx_barh(id, tracked_dict, kwargs)
+    elif method == "stx_errorbar":
+        return _format_stx_errorbar(id, tracked_dict, kwargs)
+
     # Seaborn functions (sns_ prefix)
     elif method == "sns_barplot":
         return _format_sns_barplot(id, tracked_dict, kwargs)
@@ -381,4 +452,5 @@ def format_record(record):
             f"Check the feature-request-export-as-csv-functions.md for implementation status."
         )
 
+
 # EOF

scitex/plt/_subplots/_export_as_csv_formatters/__init__.py

@@ -4,6 +4,7 @@
 # File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/plt/_subplots/_export_as_csv_formatters/__init__.py
 # ----------------------------------------
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -40,10 +41,12 @@ from ._format_violinplot import _format_violinplot
 from ._format_plot_imshow import _format_plot_imshow
 from ._format_plot_box import _format_plot_box
 from ._format_stx_conf_mat import _format_plot_conf_mat
+from ._format_stx_contour import _format_stx_contour
 from ._format_stx_ecdf import _format_plot_ecdf
 from ._format_stx_fillv import _format_plot_fillv
 from ._format_stx_heatmap import _format_plot_heatmap
 from ._format_stx_image import _format_plot_image
+from ._format_stx_imshow import _format_stx_imshow
 from ._format_stx_joyplot import _format_plot_joyplot
 from ._format_plot_kde import _format_plot_kde
 from ._format_stx_line import _format_plot_line
@@ -57,6 +60,12 @@ from ._format_stx_scatter_hist import _format_plot_scatter_hist
 from ._format_stx_shaded_line import _format_plot_shaded_line
 from ._format_stx_violin import _format_plot_violin
 
+# stx_ aliases formatters
+from ._format_stx_scatter import _format_stx_scatter
+from ._format_stx_bar import _format_stx_bar
+from ._format_stx_barh import _format_stx_barh
+from ._format_stx_errorbar import _format_stx_errorbar
+
 # Seaborn formatters (sns_ prefix)
 from ._format_sns_barplot import _format_sns_barplot
 from ._format_sns_boxplot import _format_sns_boxplot

scitex/plt/_subplots/_export_as_csv_formatters/_format_annotate.py

@@ -5,28 +5,15 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
 import pandas as pd
 
-
-def _make_column_name(id, suffix, method="annotate"):
-    """Create column name with method descriptor, avoiding duplication.
-
-    For example:
-    - id="annotate_0", suffix="x" -> "annotate_0_x"
-    - id="plot_5", suffix="x" -> "plot_5_annotate_x"
-    """
-    # Check if method name is already in the ID
-    id_parts = id.rsplit('_', 1)
-    if len(id_parts) == 2 and id_parts[0].endswith(method):
-        # Method already in ID, don't duplicate
-        return f"{id}_{suffix}"
-    else:
-        # Method not in ID, add it for clarity
-        return f"{id}_{method}_{suffix}"
+from scitex.plt.utils._csv_column_naming import get_csv_column_name
+from ._format_plot import _parse_tracking_id
 
 
 def _format_annotate(id, tracked_dict, kwargs):
@@ -41,6 +28,9 @@ def _format_annotate(id, tracked_dict, kwargs):
     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)
+
     # Get the args from tracked_dict
     args = tracked_dict.get("args", [])
 
@@ -50,15 +40,15 @@ def _format_annotate(id, tracked_dict, kwargs):
         xy = args[1]
 
         # xy should be a tuple (x, y)
-        if hasattr(xy, '__len__') and len(xy) >= 2:
+        if hasattr(xy, "__len__") and len(xy) >= 2:
             x, y = xy[0], xy[1]
         else:
             return pd.DataFrame()
 
         data = {
-            _make_column_name(id, "x"): [x],
-            _make_column_name(id, "y"): [y],
-            _make_column_name(id, "content"): [text_content]
+            get_csv_column_name("x", ax_row, ax_col, trace_id=trace_id): [x],
+            get_csv_column_name("y", ax_row, ax_col, trace_id=trace_id): [y],
+            get_csv_column_name("content", ax_row, ax_col, trace_id=trace_id): [text_content],
         }
 
         # Check if xytext was provided (either as third arg or in kwargs)
@@ -68,9 +58,9 @@ def _format_annotate(id, tracked_dict, kwargs):
         elif "xytext" in kwargs:
             xytext = kwargs["xytext"]
 
-        if xytext is not None and hasattr(xytext, '__len__') and len(xytext) >= 2:
-            data[_make_column_name(id, "text_x")] = [xytext[0]]
-            data[_make_column_name(id, "text_y")] = [xytext[1]]
+        if xytext is not None and hasattr(xytext, "__len__") and len(xytext) >= 2:
+            data[get_csv_column_name("text_x", ax_row, ax_col, trace_id=trace_id)] = [xytext[0]]
+            data[get_csv_column_name("text_y", ax_row, ax_col, trace_id=trace_id)] = [xytext[1]]
 
         # Create DataFrame with proper column names (use dict with list values)
         df = pd.DataFrame(data)
@@ -78,4 +68,5 @@ def _format_annotate(id, tracked_dict, kwargs):
 
     return pd.DataFrame()
 
+
 # EOF

scitex/plt/_subplots/_export_as_csv_formatters/_format_bar.py

@@ -4,6 +4,7 @@
 # File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/plt/_subplots/_export_as_csv_formatters/_format_bar.py
 # ----------------------------------------
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -11,78 +12,127 @@ __DIR__ = os.path.dirname(__FILE__)
 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_bar(id, tracked_dict, kwargs):
     """Format data from a bar call for CSV export.
-    
-    Simplified to focus only on essential x and y values.
-    
+
+    Includes x, y values and optional yerr for error bars.
+
     Args:
         id: The identifier for the plot
         tracked_dict: Dictionary of tracked data
-        kwargs: Original keyword arguments
-        
+        kwargs: Original keyword arguments (may contain yerr)
+
     Returns:
-        pd.DataFrame: Formatted data ready for CSV export with just x and y values
+        pd.DataFrame: Formatted data ready for CSV export with x, y, and optional yerr
     """
     # 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 structured column names
+    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)
+    col_yerr = get_csv_column_name("yerr", ax_row, ax_col, trace_id=trace_id)
+
+    # Extract yerr from kwargs if present
+    yerr = kwargs.get("yerr") if kwargs else None
+
     # Check if we have the newer format with bar_data
-    if 'bar_data' in tracked_dict and isinstance(tracked_dict['bar_data'], pd.DataFrame):
+    if "bar_data" in tracked_dict and isinstance(
+        tracked_dict["bar_data"], pd.DataFrame
+    ):
         # Use the pre-formatted DataFrame but keep only x and height (y)
-        df = tracked_dict['bar_data'].copy()
-        
+        df = tracked_dict["bar_data"].copy()
+
         # Keep only essential columns
-        essential_cols = [col for col in df.columns if col in ['x', 'height']]
+        essential_cols = [col for col in df.columns if col in ["x", "height"]]
         if essential_cols:
             df = df[essential_cols]
-            
-            # Rename height to y for consistency
-            if 'height' in df.columns:
-                df = df.rename(columns={'height': 'y'})
-                
-            # Add identifier to column names
-            df.columns = [f"{id}_{col}" for col in df.columns]
+
+            # Rename using structured naming
+            rename_map = {}
+            if "x" in df.columns:
+                rename_map["x"] = col_x
+            if "height" in df.columns:
+                rename_map["height"] = col_y
+
+            df = df.rename(columns=rename_map)
+
+            # Add yerr if present
+            if yerr is not None:
+                try:
+                    yerr_array = np.asarray(yerr)
+                    if len(yerr_array) == len(df):
+                        df[col_yerr] = yerr_array
+                except (TypeError, ValueError):
+                    pass
+
             return df
-    
+
     # Legacy format - get the args from tracked_dict
-    args = tracked_dict.get('args', [])
-    
+    args = tracked_dict.get("args", [])
+
     # Extract x and y data if available
     if len(args) >= 2:
         x, y = args[0], args[1]
-        
+
         # Convert to arrays if possible for consistent handling
         try:
             x_array = np.asarray(x)
             y_array = np.asarray(y)
-            
-            # Create DataFrame with just x and y data
+
+            # Create DataFrame with structured column names
             data = {
-                f"{id}_x": x_array,
-                f"{id}_y": y_array,
+                col_x: x_array,
+                col_y: y_array,
             }
-                
+
+            # Add yerr if present
+            if yerr is not None:
+                try:
+                    yerr_array = np.asarray(yerr)
+                    if len(yerr_array) == len(x_array):
+                        data[col_yerr] = yerr_array
+                except (TypeError, ValueError):
+                    pass
+
             return pd.DataFrame(data)
-            
+
         except (TypeError, ValueError):
             # Fall back to direct values if conversion fails
-            return pd.DataFrame({f"{id}_x": x, f"{id}_y": y})
-    
+            result = {col_x: x, col_y: y}
+            if yerr is not None:
+                result[col_yerr] = yerr
+            return pd.DataFrame(result)
+
     # If we have tracked data in another format (like our MatplotlibPlotMixin bar method)
     result = {}
-    
+
     # Check for x position (might be in different keys)
-    for x_key in ['x', 'xs', 'positions']:
+    for x_key in ["x", "xs", "positions"]:
         if x_key in tracked_dict:
-            result[f"{id}_x"] = tracked_dict[x_key]
+            result[col_x] = tracked_dict[x_key]
             break
-            
+
     # Check for y values (might be in different keys)
-    for y_key in ['y', 'ys', 'height', 'heights', 'values']:
+    for y_key in ["y", "ys", "height", "heights", "values"]:
         if y_key in tracked_dict:
-            result[f"{id}_y"] = tracked_dict[y_key]
+            result[col_y] = tracked_dict[y_key]
             break
-    
-    return pd.DataFrame(result) if result else pd.DataFrame()
+
+    # Add yerr if present in kwargs
+    if yerr is not None and result:
+        try:
+            yerr_array = np.asarray(yerr)
+            result[col_yerr] = yerr_array
+        except (TypeError, ValueError):
+            pass
+
+    return pd.DataFrame(result) if result else pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_barh.py

@@ -4,61 +4,55 @@
 # File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/plt/_subplots/_export_as_csv_formatters/_format_barh.py
 # ----------------------------------------
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
 import pandas as pd
 
-def _make_column_name(id, suffix, method="barh"):
-    """Create column name with method descriptor, avoiding duplication.
+from scitex.plt.utils._csv_column_naming import get_csv_column_name
+from ._format_plot import _parse_tracking_id
 
-    For example:
-    - id="barh_0", suffix="x" -> "barh_0_barh_x"
-    - id="plot_5", suffix="x" -> "plot_5_barh_x"
-    """
-    # Check if method name is already in the ID
-    id_parts = id.rsplit('_', 1)
-    if len(id_parts) == 2 and id_parts[0].endswith(method):
-        # Method already in ID, don't duplicate
-        return f"{id}_{suffix}"
-    else:
-        # Method not in ID, add it for clarity
-        return f"{id}_{method}_{suffix}"
 
 def _format_barh(id, tracked_dict, kwargs):
     """Format data from a barh call."""
     # 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 the args from tracked_dict
-    args = tracked_dict.get('args', [])
-    
+    args = tracked_dict.get("args", [])
+
     # Extract x and y data if available
     if len(args) >= 2:
-        # Note: in barh, x is height, y is width (visually transposed from bar)
-        x, y = args[0], args[1]
-        
+        # Note: in barh, first arg is y positions, second is widths (x values)
+        y_pos, x_width = args[0], args[1]
+
         # Get xerr from kwargs
         xerr = kwargs.get("xerr")
-        
+
         # Convert single values to Series
-        if isinstance(x, (int, float)):
-            x = pd.Series(x, name="x")
-        if isinstance(y, (int, float)):
-            y = pd.Series(y, name="y")
+        if isinstance(y_pos, (int, float)):
+            y_pos = pd.Series(y_pos, name="y")
+        if isinstance(x_width, (int, float)):
+            x_width = pd.Series(x_width, name="x")
     else:
         # Not enough arguments
         return pd.DataFrame()
 
-    # Use helper to create descriptive column names without duplication
-    df = pd.DataFrame(
-        {_make_column_name(id, "y"): x, _make_column_name(id, "x"): y}
-    )  # Swap x/y for barh
+    # Use structured column naming: ax-row-{row}-col-{col}_trace-id-{id}_variable-{var}
+    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)
+
+    df = pd.DataFrame({col_y: y_pos, col_x: x_width})
 
     if xerr is not None:
         if isinstance(xerr, (int, float)):
             xerr = pd.Series(xerr, name="xerr")
-        df[_make_column_name(id, "xerr")] = xerr
-    return df
+        col_xerr = get_csv_column_name("xerr", ax_row, ax_col, trace_id=trace_id)
+        df[col_xerr] = xerr
+    return df