scitex 2.0.0__py2.py3-none-any.whl

scitex/plt/_subplots/_export_as_csv_formatters/_format_eventplot.py

@@ -0,0 +1,72 @@
+#!/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_eventplot.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_eventplot.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+import scitex
+
+def _format_eventplot(id, tracked_dict, kwargs):
+    """Format data from an eventplot 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', [])
+    
+    # Eventplot displays multiple sets of events as parallel lines
+    if len(args) >= 1:
+        positions = args[0]
+
+        try:
+            # Try using scitex.pd.force_df if available
+            try:
+                import scitex.pd
+
+                # If positions is a single array
+                if isinstance(
+                    positions, (list, np.ndarray)
+                ) and not isinstance(positions[0], (list, np.ndarray)):
+                    return pd.DataFrame({f"{id}_eventplot_events": positions})
+
+                # If positions is a list of arrays (multiple event sets)
+                elif isinstance(positions, (list, np.ndarray)):
+                    data = {}
+                    for i, events in enumerate(positions):
+                        data[f"{id}_eventplot_events{i:02d}"] = events
+
+                    # Use force_df to handle different length arrays
+                    return scitex.pd.force_df(data)
+
+            except (ImportError, AttributeError):
+                # Fall back to pandas with manual Series creation
+                # If positions is a single array
+                if isinstance(
+                    positions, (list, np.ndarray)
+                ) and not isinstance(positions[0], (list, np.ndarray)):
+                    return pd.DataFrame({f"{id}_eventplot_events": positions})
+
+                # If positions is a list of arrays (multiple event sets)
+                elif isinstance(positions, (list, np.ndarray)):
+                    # Create a DataFrame where each column is a Series that can handle varying lengths
+                    df = pd.DataFrame()
+                    for i, events in enumerate(positions):
+                        df[f"{id}_eventplot_events{i:02d}"] = pd.Series(events)
+                    return df
+        except Exception as e:
+            # If all else fails, return an empty DataFrame
+            import warnings
+
+            warnings.warn(f"Error formatting eventplot data: {str(e)}")
+            return pd.DataFrame()
+
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_fill.py

@@ -0,0 +1,34 @@
+#!/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_fill.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_fill.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+def _format_fill(id, tracked_dict, kwargs):
+    """Format data from a fill 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', [])
+    
+    # Fill creates a polygon based on points
+    if len(args) >= 2:
+        # First arg is x, remaining args are y values
+        x = args[0]
+        data = {f"{id}_fill_x": x}
+
+        for i, y in enumerate(args[1:]):
+            data[f"{id}_fill_y{i:02d}"] = y
+
+        return pd.DataFrame(data)
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_fill_between.py

@@ -0,0 +1,36 @@
+#!/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_fill_between.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_fill_between.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+def _format_fill_between(id, tracked_dict, kwargs):
+    """Format data from a fill_between 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, y1, y2
+    if len(args) >= 3:
+        x, y1, y2 = args[:3]
+
+        df = pd.DataFrame(
+            {
+                f"{id}_fill_between_x": x,
+                f"{id}_fill_between_y1": y1,
+                f"{id}_fill_between_y2": y2,
+            }
+        )
+        return df
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_hist.py

@@ -0,0 +1,79 @@
+#!/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_hist.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_hist.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+
+def _format_hist(id, tracked_dict, kwargs):
+    """
+    Format data from a hist call as a bar plot representation.
+    
+    This formatter extracts both the raw data and the binned data from histogram plots,
+    returning them in a format that can be visualized as a bar plot.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to hist
+        
+    Returns:
+        pd.DataFrame: DataFrame containing both raw data and bin information
+    """
+    # 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', [])
+    
+    # Check if histogram result (bin counts and edges) is available in tracked_dict
+    hist_result = tracked_dict.get('hist_result', None)
+    
+    columns = {}
+    
+    # Extract raw data if available
+    if len(args) >= 1:
+        x = args[0]
+        columns[f"{id}_raw_data"] = x
+    
+    # If we have histogram result (counts and bin edges)
+    if hist_result is not None:
+        counts, bin_edges = hist_result
+        
+        # Calculate bin centers for bar plot representation
+        bin_centers = 0.5 * (bin_edges[:-1] + bin_edges[1:])
+        bin_widths = bin_edges[1:] - bin_edges[:-1]
+        
+        # Add bin information to DataFrame
+        columns[f"{id}_bin_centers"] = bin_centers
+        columns[f"{id}_bin_counts"] = counts
+        columns[f"{id}_bin_widths"] = bin_widths
+        columns[f"{id}_bin_edges_left"] = bin_edges[:-1]
+        columns[f"{id}_bin_edges_right"] = bin_edges[1:]
+        
+        # Create DataFrame with aligned length
+        max_length = max(len(value) for value in columns.values())
+        for key, value in list(columns.items()):
+            if len(value) < max_length:
+                # Pad with NaN if needed
+                if isinstance(value, np.ndarray):
+                    columns[key] = np.pad(value, (0, max_length - len(value)), 
+                                          mode='constant', constant_values=np.nan)
+                else:
+                    padded = list(value) + [np.nan] * (max_length - len(value))
+                    columns[key] = np.array(padded)
+    
+    # Return DataFrame or empty DataFrame if no data
+    if columns:
+        return pd.DataFrame(columns)
+    
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_imshow.py

@@ -0,0 +1,59 @@
+#!/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_imshow.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_imshow.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+def _format_imshow(id, tracked_dict, kwargs):
+    """Format data from an imshow call."""
+
+    if tracked_dict.get("image_df") is not None:
+        return tracked_dict.get("image_df")
+
+    # # Placeholder implementation
+    # # Imshow displays an image (2D array)
+    # if len(args) >= 1:
+    #     img = args[0]
+
+    #     # Convert 2D image to long format
+    #     if isinstance(img, np.ndarray) and img.ndim == 2:
+    #         rows, cols = img.shape
+    #         row_indices, col_indices = np.meshgrid(
+    #             range(rows), range(cols), indexing="ij"
+    #         )
+
+    #         df = pd.DataFrame(
+    #             {
+    #                 f"{id}_imshow_row": row_indices.flatten(),
+    #                 f"{id}_imshow_col": col_indices.flatten(),
+    #                 f"{id}_imshow_value": img.flatten(),
+    #             }
+    #         )
+    #         return df
+
+    #     # Handle RGB/RGBA images
+    #     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"
+    #         )
+
+    #         data = {
+    #             f"{id}_imshow_row": row_indices.flatten(),
+    #             f"{id}_imshow_col": col_indices.flatten(),
+    #         }
+
+    #         # Add channel data
+    #         for c in range(channels):
+    #             data[f"{id}_imshow_channel{c}"] = img[:, :, c].flatten()
+
+    #         return pd.DataFrame(data)
+    # return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_imshow2d.py

@@ -0,0 +1,32 @@
+#!/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_imshow2d.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_imshow2d.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+def _format_imshow2d(id, tracked_dict, kwargs):
+    """Format data from an imshow2d 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 and isinstance(args[0], pd.DataFrame):
+        df = args[0].copy()
+        # Add prefixes to columns and index if needed
+        # df.columns = [f"{id}_imshow2d_{col}" for col in df.columns]
+        # df.index = [f"{id}_imshow2d_{idx}" for idx in df.index]
+        return df
+    
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot.py

@@ -0,0 +1,79 @@
+#!/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.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+from collections import OrderedDict
+import numpy as np
+import pandas as pd
+import xarray as xr
+
+def _format_plot(id, tracked_dict, kwargs):
+    """Format data from a plot call.
+
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to plot
+
+    Returns:
+        pd.DataFrame: Formatted data from plot
+    """
+    # Check if tracked_dict is empty or not a dictionary
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+    
+    # For plot_line, we expect a 'plot_df' key
+    if 'plot_df' in tracked_dict:
+        plot_df = tracked_dict['plot_df']
+        if isinstance(plot_df, pd.DataFrame):
+            # Add the id prefix to all columns
+            return plot_df.add_prefix(f"{id}_")
+    
+    # Legacy handling for tracked args (should be deprecated)
+    if 'args' in tracked_dict:
+        args = tracked_dict['args']
+        if isinstance(args, tuple) and len(args) > 0:
+            if len(args) == 1:
+                args_value = args[0]
+                if hasattr(args_value, 'ndim') and args_value.ndim == 2:
+                    x, y = args_value[:, 0], args_value[:, 1]
+                    df = pd.DataFrame({f"{id}_plot_x": x, f"{id}_plot_y": y})
+                    return df
+
+            elif len(args) == 2:
+                x, y = args
+                if isinstance(y, (np.ndarray, xr.DataArray)):
+                    if y.ndim == 2:
+                        out = OrderedDict()
+                        for ii in range(y.shape[1]):
+                            out[f"{id}_plot_x{ii:02d}"] = x
+                            out[f"{id}_plot_y{ii:02d}"] = y[:, ii]
+                        df = pd.DataFrame(out)
+                        return df
+
+                if isinstance(y, pd.DataFrame):
+                    df = pd.DataFrame(
+                        {
+                            f"{id}_plot_x": x,
+                            **{
+                                f"{id}_plot_y{ii:02d}": np.array(y[col])
+                                for ii, col in enumerate(y.columns)
+                            },
+                        }
+                    )
+                    return df
+
+                if isinstance(y, (np.ndarray, xr.DataArray, list)):
+                    df = pd.DataFrame({f"{id}_plot_x": x, f"{id}_plot_y": y})
+                    return df
+
+    # Default empty DataFrame if we can't process the input
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_box.py

@@ -0,0 +1,75 @@
+#!/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_box.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_box.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+
+def _format_plot_box(id, tracked_dict, kwargs):
+    """Format data from a plot_box call."""
+    # Check if tracked_dict is empty or not a dictionary
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+    
+    # First try to get data directly from tracked_dict
+    data = tracked_dict.get('data')
+    
+    # If no data key, get from args
+    if data is None:
+        args = tracked_dict.get('args', [])
+        if len(args) >= 1:
+            data = args[0]
+        else:
+            return pd.DataFrame()
+    
+    # If data is a simple array or list of values
+    if isinstance(data, (np.ndarray, list)) and len(data) > 0:
+        try:
+            # Check if it's a simple list of values or a list of lists
+            if isinstance(data[0], (int, float, np.number)):
+                return pd.DataFrame({f"{id}_plot_box_values": data})
+                
+            # If data is a list of arrays (multiple box plots)
+            elif isinstance(data, (list, tuple)) and all(
+                isinstance(x, (list, np.ndarray)) for x in data
+            ):
+                result = pd.DataFrame()
+                for i, values in enumerate(data):
+                    try:
+                        result[f"{id}_plot_box_group{i:02d}"] = pd.Series(values)
+                    except:
+                        # Handle case where values may not be convertible to Series
+                        pass
+                return result
+        except (IndexError, TypeError):
+            # Return empty DataFrame if we can't process the data
+            pass
+    
+    # If data is a dictionary
+    elif isinstance(data, dict):
+        result = pd.DataFrame()
+        for label, values in data.items():
+            try:
+                result[f"{id}_plot_box_{label}"] = pd.Series(values)
+            except:
+                # Handle case where values may not be convertible to Series
+                pass
+        return result
+    
+    # If data is a DataFrame
+    elif isinstance(data, pd.DataFrame):
+        result = pd.DataFrame()
+        for col in data.columns:
+            result[f"{id}_plot_box_{col}"] = data[col]
+        return result
+    
+    # Default case: return empty DataFrame if nothing could be processed
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_conf_mat.py

@@ -0,0 +1,64 @@
+#!/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_conf_mat.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_conf_mat.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+
+def _format_plot_conf_mat(id, tracked_dict, kwargs):
+    """Format data from a plot_conf_mat call.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to plot_conf_mat
+        
+    Returns:
+        pd.DataFrame: Formatted confusion matrix 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 args from tracked_dict
+    args = tracked_dict.get('args', [])
+    
+    # Extract confusion matrix if available in args
+    if len(args) >= 1 and isinstance(args[0], (np.ndarray, list)):
+        conf_mat = np.array(args[0])
+        
+        # Convert to DataFrame
+        if conf_mat.ndim == 2:
+            # Create column and index names
+            n_classes = conf_mat.shape[0]
+            columns = [f"Predicted_{i}" for i in range(n_classes)]
+            index = [f"True_{i}" for i in range(n_classes)]
+            
+            # Create DataFrame with proper labels
+            df = pd.DataFrame(conf_mat, columns=columns, index=index)
+            
+            # Reset index to make it a regular column
+            df = df.reset_index().rename(columns={"index": "True_Class"})
+            
+            # Add prefix to all columns
+            df.columns = [f"{id}_conf_mat_{col}" for col in df.columns]
+            
+            return df
+    
+    # Extract balanced accuracy if available as fallback
+    bacc = tracked_dict.get('balanced_accuracy')
+    
+    # Create DataFrame with the balanced accuracy
+    if bacc is not None:
+        df = pd.DataFrame({f"{id}_conf_mat_balanced_accuracy": [bacc]})
+        return df
+    
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_ecdf.py

@@ -0,0 +1,44 @@
+#!/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_ecdf.py
+# ----------------------------------------
+import os
+import pandas as pd
+
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_ecdf.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+def _format_plot_ecdf(id, tracked_dict, kwargs):
+    """Format data from a plot_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 plot_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')
+    
+    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

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_fillv.py

@@ -0,0 +1,70 @@
+#!/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__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_fillv.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+
+def _format_plot_fillv(id, tracked_dict, kwargs):
+    """Format data from a plot_fillv call.
+    
+    Formats data similar to line plot format for better compatibility.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to plot_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()
+    
+    # Try to get starts/ends directly from tracked_dict first
+    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', [])
+        
+        # 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
+        if isinstance(starts, list):
+            starts = np.array(starts)
+        if isinstance(ends, list):
+            ends = np.array(ends)
+        
+        # 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"
+            })
+        
+        if rows:
+            return pd.DataFrame(rows)
+    
+    return pd.DataFrame()