scitex 2.0.0__py2.py3-none-any.whl

scitex/plt/_subplots/_export_as_csv.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-18 18:14:08 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/plt/_subplots/_export_as_csv.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/_subplots/_export_as_csv.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import warnings
+
+import pandas as pd
+
+from ._export_as_csv_formatters import (_format_bar, _format_barh,
+                                        _format_boxplot, _format_contour,
+                                        _format_errorbar, _format_eventplot,
+                                        _format_fill, _format_fill_between,
+                                        _format_hist, _format_imshow,
+                                        _format_imshow2d, _format_plot,
+                                        _format_plot_box,
+                                        _format_plot_conf_mat,
+                                        _format_plot_ecdf, _format_plot_fillv,
+                                        _format_plot_heatmap,
+                                        _format_plot_image,
+                                        _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_hist,
+                                        _format_plot_shaded_line,
+                                        _format_plot_violin, _format_scatter,
+                                        _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_violin,
+                                        _format_violinplot)
+
+from scitex.pd import to_xyz
+
+
+def _to_numpy(data):
+    """Convert various data types to numpy array.
+    
+    Handles torch tensors, pandas Series/DataFrame, and other array-like objects.
+    
+    Parameters
+    ----------
+    data : array-like
+        Data to convert to numpy array
+        
+    Returns
+    -------
+    numpy.ndarray
+        Data as numpy array
+    """
+    if hasattr(data, 'numpy'):  # torch tensor
+        return data.detach().numpy() if hasattr(data, 'detach') else data.numpy()
+    elif hasattr(data, 'values'):  # pandas series/dataframe
+        return data.values
+    else:
+        return np.asarray(data)
+
+
+def export_as_csv(history_records):
+    """Convert plotting history records to a combined DataFrame suitable for CSV export.
+
+    Args:
+        history_records (dict): Dictionary of plotting records.
+
+    Returns:
+        pd.DataFrame: Combined DataFrame containing all plotting data.
+
+    Raises:
+        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.")
+        return pd.DataFrame()  # Return empty DataFrame instead of None
+
+    dfs = []
+    for record in list(history_records.values()):
+        try:
+            formatted_df = format_record(record)
+            if formatted_df is not None and not formatted_df.empty:
+                dfs.append(formatted_df)
+        except Exception as e:
+            warnings.warn(f"Failed to format record {record[0]}: {e}")
+    
+    # If no valid dataframes were created, return an empty one
+    if not dfs:
+        warnings.warn("No valid data found to export.")
+        return pd.DataFrame()
+
+    try:
+        df = pd.concat(dfs, axis=1)
+        return df
+    except Exception as e:
+        warnings.warn(f"Failed to combine plotting records: {e}")
+        # Return a DataFrame with metadata about what records were attempted
+        meta_df = pd.DataFrame({
+            "record_id": [r[0] for r in history_records.values()],
+            "method": [r[1] for r in history_records.values()],
+            "has_data": ["Yes" if r[2] and r[2] != {} else "No" for r in history_records.values()]
+        })
+        return meta_df
+
+
+def format_record(record):
+    """Route record to the appropriate formatting function based on plot method.
+
+    Args:
+        record (tuple): Plotting record tuple (id, method, tracked_dict, kwargs).
+
+    Returns:
+        pd.DataFrame: Formatted data for the plot record.
+    """
+    id, method, tracked_dict, kwargs = record
+
+    # Basic Matplotlib functions
+    if method == "plot":
+        return _format_plot(id, tracked_dict, kwargs)
+    elif method == "scatter":
+        return _format_scatter(id, tracked_dict, kwargs)
+    elif method == "bar":
+        return _format_bar(id, tracked_dict, kwargs)
+    elif method == "barh":
+        return _format_barh(id, tracked_dict, kwargs)
+    elif method == "hist":
+        return _format_hist(id, tracked_dict, kwargs)
+    elif method == "boxplot":
+        return _format_boxplot(id, tracked_dict, kwargs)
+    elif method == "contour":
+        return _format_contour(id, tracked_dict, kwargs)
+    elif method == "errorbar":
+        return _format_errorbar(id, tracked_dict, kwargs)
+    elif method == "eventplot":
+        return _format_eventplot(id, tracked_dict, kwargs)
+    elif method == "fill":
+        return _format_fill(id, tracked_dict, kwargs)
+    elif method == "fill_between":
+        return _format_fill_between(id, tracked_dict, kwargs)
+    elif method == "imshow":
+        return _format_imshow(id, tracked_dict, kwargs)
+    elif method == "imshow2d":
+        return _format_imshow2d(id, tracked_dict, kwargs)
+    elif method == "violin":
+        return _format_violin(id, tracked_dict, kwargs)
+    elif method == "violinplot":
+        return _format_violinplot(id, tracked_dict, kwargs)
+
+    # Custom plotting functions
+    elif method == "plot_box":
+        return _format_plot_box(id, tracked_dict, kwargs)
+    elif method == "plot_conf_mat":
+        return _format_plot_conf_mat(id, tracked_dict, kwargs)
+    elif method == "plot_ecdf":
+        return _format_plot_ecdf(id, tracked_dict, kwargs)
+    elif method == "plot_fillv":
+        return _format_plot_fillv(id, tracked_dict, kwargs)
+    elif method == "plot_heatmap":
+        return _format_plot_heatmap(id, tracked_dict, kwargs)
+    elif method == "plot_image":
+        return _format_plot_image(id, tracked_dict, kwargs)
+    elif method == "plot_joyplot":
+        return _format_plot_joyplot(id, tracked_dict, kwargs)
+    elif method == "plot_kde":
+        return _format_plot_kde(id, tracked_dict, kwargs)
+    elif method == "plot_line":
+        return _format_plot_line(id, tracked_dict, kwargs)
+    elif method == "plot_mean_ci":
+        return _format_plot_mean_ci(id, tracked_dict, kwargs)
+    elif method == "plot_mean_std":
+        return _format_plot_mean_std(id, tracked_dict, kwargs)
+    elif method == "plot_median_iqr":
+        return _format_plot_median_iqr(id, tracked_dict, kwargs)
+    elif method == "plot_raster":
+        return _format_plot_raster(id, tracked_dict, kwargs)
+    elif method == "plot_rectangle":
+        return _format_plot_rectangle(id, tracked_dict, kwargs)
+    elif method == "plot_scatter_hist":
+        return _format_plot_scatter_hist(id, tracked_dict, kwargs)
+    elif method == "plot_shaded_line":
+        return _format_plot_shaded_line(id, tracked_dict, kwargs)
+    elif method == "plot_violin":
+        return _format_plot_violin(id, tracked_dict, kwargs)
+
+    # Seaborn functions
+    elif method == "sns_barplot":
+        return _format_sns_barplot(id, tracked_dict, kwargs)
+    elif method == "sns_boxplot":
+        return _format_sns_boxplot(id, tracked_dict, kwargs)
+    elif method == "sns_heatmap":
+        return _format_sns_heatmap(id, tracked_dict, kwargs)
+    elif method == "sns_histplot":
+        return _format_sns_histplot(id, tracked_dict, kwargs)
+    elif method == "sns_jointplot":
+        return _format_sns_jointplot(id, tracked_dict, kwargs)
+    elif method == "sns_kdeplot":
+        return _format_sns_kdeplot(id, tracked_dict, kwargs)
+    elif method == "sns_lineplot":
+        return _format_sns_lineplot(id, tracked_dict, kwargs)
+    elif method == "sns_pairplot":
+        return _format_sns_pairplot(id, tracked_dict, kwargs)
+    elif method == "sns_scatterplot":
+        return _format_sns_scatterplot(id, tracked_dict, kwargs)
+    elif method == "sns_stripplot":
+        return _format_sns_stripplot(id, tracked_dict, kwargs)
+    elif method == "sns_swarmplot":
+        return _format_sns_swarmplot(id, tracked_dict, kwargs)
+    elif method == "sns_violinplot":
+        return _format_sns_violinplot(id, tracked_dict, kwargs)
+    else:
+        # Unknown or unimplemented method
+        raise NotImplementedError(
+            f"CSV export for plot method '{method}' is not yet implemented in the scitex.plt module. "
+            f"Check the feature-request-export-as-csv-functions.md for implementation status."
+        )
+
+# EOF

scitex/plt/_subplots/_export_as_csv_formatters/__init__.py

@@ -0,0 +1,61 @@
+#!/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/__init__.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/__init__.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+# Standard matplotlib formatters
+from ._format_plot import _format_plot
+from ._format_scatter import _format_scatter
+from ._format_bar import _format_bar
+from ._format_barh import _format_barh
+from ._format_hist import _format_hist
+from ._format_boxplot import _format_boxplot
+from ._format_contour import _format_contour
+from ._format_errorbar import _format_errorbar
+from ._format_eventplot import _format_eventplot
+from ._format_fill import _format_fill
+from ._format_fill_between import _format_fill_between
+from ._format_imshow import _format_imshow
+from ._format_imshow2d import _format_imshow2d
+from ._format_violin import _format_violin
+from ._format_violinplot import _format_violinplot
+
+# Custom plotting formatters
+from ._format_plot_box import _format_plot_box
+from ._format_plot_conf_mat import _format_plot_conf_mat
+from ._format_plot_ecdf import _format_plot_ecdf
+from ._format_plot_fillv import _format_plot_fillv
+from ._format_plot_heatmap import _format_plot_heatmap
+from ._format_plot_image import _format_plot_image
+from ._format_plot_joyplot import _format_plot_joyplot
+from ._format_plot_kde import _format_plot_kde
+from ._format_plot_line import _format_plot_line
+from ._format_plot_mean_ci import _format_plot_mean_ci
+from ._format_plot_mean_std import _format_plot_mean_std
+from ._format_plot_median_iqr import _format_plot_median_iqr
+from ._format_plot_raster import _format_plot_raster
+from ._format_plot_rectangle import _format_plot_rectangle
+from ._format_plot_scatter_hist import _format_plot_scatter_hist
+from ._format_plot_shaded_line import _format_plot_shaded_line
+from ._format_plot_violin import _format_plot_violin
+
+# Seaborn formatters
+from ._format_sns_barplot import _format_sns_barplot
+from ._format_sns_boxplot import _format_sns_boxplot
+from ._format_sns_heatmap import _format_sns_heatmap
+from ._format_sns_histplot import _format_sns_histplot
+from ._format_sns_jointplot import _format_sns_jointplot
+from ._format_sns_kdeplot import _format_sns_kdeplot
+from ._format_sns_lineplot import _format_sns_lineplot
+from ._format_sns_pairplot import _format_sns_pairplot
+from ._format_sns_scatterplot import _format_sns_scatterplot
+from ._format_sns_stripplot import _format_sns_stripplot
+from ._format_sns_swarmplot import _format_sns_swarmplot
+from ._format_sns_violinplot import _format_sns_violinplot

scitex/plt/_subplots/_export_as_csv_formatters/_format_bar.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-19 15:45:51 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/plt/_subplots/_export_as_csv_formatters/_format_bar.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_bar.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+import numpy as np
+
+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.
+    
+    Args:
+        id: The identifier for the plot
+        tracked_dict: Dictionary of tracked data
+        kwargs: Original keyword arguments
+        
+    Returns:
+        pd.DataFrame: Formatted data ready for CSV export with just x and y values
+    """
+    # Check if tracked_dict is empty or not a dictionary
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+    
+    # Check if we have the newer format with bar_data
+    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()
+        
+        # Keep only essential columns
+        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]
+            return df
+    
+    # Legacy format - get the args from tracked_dict
+    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
+            data = {
+                f"{id}_x": x_array,
+                f"{id}_y": y_array,
+            }
+                
+            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})
+    
+    # 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']:
+        if x_key in tracked_dict:
+            result[f"{id}_x"] = tracked_dict[x_key]
+            break
+            
+    # Check for y values (might be in different keys)
+    for y_key in ['y', 'ys', 'height', 'heights', 'values']:
+        if y_key in tracked_dict:
+            result[f"{id}_y"] = tracked_dict[y_key]
+            break
+    
+    return pd.DataFrame(result) if result else pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_barh.py

@@ -0,0 +1,49 @@
+#!/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_barh.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_barh.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+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()
+    
+    # Get the args from tracked_dict
+    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]
+        
+        # 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")
+    else:
+        # Not enough arguments
+        return pd.DataFrame()
+
+    df = pd.DataFrame(
+        {f"{id}_barh_y": x, f"{id}_barh_x": y}
+    )  # Swap x/y for barh
+
+    if xerr is not None:
+        if isinstance(xerr, (int, float)):
+            xerr = pd.Series(xerr, name="xerr")
+        df[f"{id}_barh_xerr"] = xerr
+    return df

scitex/plt/_subplots/_export_as_csv_formatters/_format_boxplot.py

@@ -0,0 +1,46 @@
+#!/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_boxplot.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_boxplot.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+import scitex
+
+def _format_boxplot(id, tracked_dict, kwargs):
+    """Format data from a boxplot call."""
+    # 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 args from tracked_dict
+    args = tracked_dict.get('args', [])
+    
+    # Extract data if available
+    if len(args) >= 1:
+        x = args[0]
+        
+        # One box plot
+        from scitex.types import is_listed_X as scitex_types_is_listed_X
+        
+        if isinstance(x, np.ndarray) or scitex_types_is_listed_X(x, [float, int]):
+            df = pd.DataFrame(x)
+        else:
+            # Multiple boxes
+            import scitex.pd
+            df = scitex.pd.force_df({i_x: _x for i_x, _x in enumerate(x)})
+        
+        # Add prefix to columns
+        df.columns = [f"{id}_boxplot_{col}_x" for col in df.columns]
+        df = df.apply(lambda col: col.dropna().reset_index(drop=True))
+        return df
+    
+    # No valid data available
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_contour.py

@@ -0,0 +1,39 @@
+#!/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_contour.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_contour.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+def _format_contour(id, tracked_dict, kwargs):
+    """Format data from a contour call."""
+    # 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 args from tracked_dict
+    args = tracked_dict.get('args', [])
+    
+    # Typical args: X, Y, Z where X and Y are 2D coordinate arrays and Z is the height array
+    if len(args) >= 3:
+        X, Y, Z = args[:3]
+        # Convert mesh grids to column vectors for export
+        X_flat = X.flatten()
+        Y_flat = Y.flatten()
+        Z_flat = Z.flatten()
+        df = pd.DataFrame(
+            {
+                f"{id}_contour_x": X_flat,
+                f"{id}_contour_y": Y_flat,
+                f"{id}_contour_z": Z_flat,
+            }
+        )
+        return df
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_errorbar.py

@@ -0,0 +1,125 @@
+#!/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_errorbar.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_errorbar.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+import scitex
+
+def _format_errorbar(id, tracked_dict, kwargs):
+    """Format data from an errorbar call."""
+    # 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 args from tracked_dict
+    args = tracked_dict.get('args', [])
+    
+    # Typical args: x, y
+    # Typical kwargs: xerr, yerr
+    if len(args) >= 2:
+        x, y = args[:2]
+        xerr = kwargs.get("xerr")
+        yerr = kwargs.get("yerr")
+
+        try:
+            # Try using scitex.pd.force_df if available
+            try:
+                import scitex.pd
+
+                data = {f"{id}_errorbar_x": x, f"{id}_errorbar_y": y}
+
+                if xerr is not None:
+                    if isinstance(xerr, (list, tuple)) and len(xerr) == 2:
+                        # Asymmetric error
+                        data[f"{id}_errorbar_xerr_neg"] = xerr[0]
+                        data[f"{id}_errorbar_xerr_pos"] = xerr[1]
+                    else:
+                        # Symmetric error
+                        data[f"{id}_errorbar_xerr"] = xerr
+
+                if yerr is not None:
+                    if isinstance(yerr, (list, tuple)) and len(yerr) == 2:
+                        # Asymmetric error
+                        data[f"{id}_errorbar_yerr_neg"] = yerr[0]
+                        data[f"{id}_errorbar_yerr_pos"] = yerr[1]
+                    else:
+                        # Symmetric error
+                        data[f"{id}_errorbar_yerr"] = yerr
+
+                # Use scitex.pd.force_df to handle different length arrays
+                df = scitex.pd.force_df(data)
+                return df
+            except (ImportError, AttributeError):
+                # Fall back to pandas with manual padding
+                max_len = max(
+                    [
+                        len(arr) if hasattr(arr, "__len__") else 1
+                        for arr in [x, y, xerr, yerr]
+                        if arr is not None
+                    ]
+                )
+
+                # Function to pad arrays to the same length
+                def pad_to_length(arr, length):
+                    if arr is None:
+                        return None
+                    if not hasattr(arr, "__len__"):
+                        # Handle scalar values
+                        return [arr] * length
+                    if len(arr) >= length:
+                        return arr
+                    # Pad with NaN
+                    return np.pad(
+                        arr,
+                        (0, length - len(arr)),
+                        "constant",
+                        constant_values=np.nan,
+                    )
+
+                # Pad all arrays
+                x_padded = pad_to_length(x, max_len)
+                y_padded = pad_to_length(y, max_len)
+
+                data = {
+                    f"{id}_errorbar_x": x_padded,
+                    f"{id}_errorbar_y": y_padded,
+                }
+
+                if xerr is not None:
+                    if isinstance(xerr, (list, tuple)) and len(xerr) == 2:
+                        xerr_neg_padded = pad_to_length(xerr[0], max_len)
+                        xerr_pos_padded = pad_to_length(xerr[1], max_len)
+                        data[f"{id}_errorbar_xerr_neg"] = xerr_neg_padded
+                        data[f"{id}_errorbar_xerr_pos"] = xerr_pos_padded
+                    else:
+                        xerr_padded = pad_to_length(xerr, max_len)
+                        data[f"{id}_errorbar_xerr"] = xerr_padded
+
+                if yerr is not None:
+                    if isinstance(yerr, (list, tuple)) and len(yerr) == 2:
+                        yerr_neg_padded = pad_to_length(yerr[0], max_len)
+                        yerr_pos_padded = pad_to_length(yerr[1], max_len)
+                        data[f"{id}_errorbar_yerr_neg"] = yerr_neg_padded
+                        data[f"{id}_errorbar_yerr_pos"] = yerr_pos_padded
+                    else:
+                        yerr_padded = pad_to_length(yerr, max_len)
+                        data[f"{id}_errorbar_yerr"] = yerr_padded
+
+                return pd.DataFrame(data)
+        except Exception as e:
+            # If all else fails, return an empty DataFrame
+            import warnings
+
+            warnings.warn(f"Error formatting errorbar data: {str(e)}")
+            return pd.DataFrame()
+
+    return pd.DataFrame()