scitex 2.0.0__py2.py3-none-any.whl

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_scatter_hist.py

@@ -0,0 +1,82 @@
+#!/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_scatter_hist.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_scatter_hist.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+
+def _format_plot_scatter_hist(id, tracked_dict, kwargs):
+    """Format data from a plot_scatter_hist call.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to plot_scatter_hist
+        
+    Returns:
+        pd.DataFrame: Formatted scatter histogram data
+    """
+    # 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
+    x = tracked_dict.get('x')
+    y = tracked_dict.get('y')
+    
+    if x is not None and y is not None:
+        # Create base DataFrame with x and y values
+        df = pd.DataFrame({
+            f"{id}_scatter_hist_x": x, 
+            f"{id}_scatter_hist_y": y
+        })
+        
+        # Add histogram data if available
+        hist_x = tracked_dict.get('hist_x')
+        hist_y = tracked_dict.get('hist_y')
+        bin_edges_x = tracked_dict.get('bin_edges_x')
+        bin_edges_y = tracked_dict.get('bin_edges_y')
+        
+        # If we have histogram data
+        if hist_x is not None and bin_edges_x is not None:
+            # Calculate bin centers for x-axis histogram
+            bin_centers_x = 0.5 * (bin_edges_x[1:] + bin_edges_x[:-1])
+            
+            # Create a DataFrame for x histogram data
+            hist_x_df = pd.DataFrame({
+                f"{id}_hist_x_bin_centers": bin_centers_x,
+                f"{id}_hist_x_counts": hist_x
+            })
+            
+            # Add it to the main DataFrame using a MultiIndex
+            for i, (center, count) in enumerate(zip(bin_centers_x, hist_x)):
+                df.loc[f"hist_x_{i}", f"{id}_hist_x_bin"] = center
+                df.loc[f"hist_x_{i}", f"{id}_hist_x_count"] = count
+        
+        # If we have y histogram data
+        if hist_y is not None and bin_edges_y is not None:
+            # Calculate bin centers for y-axis histogram
+            bin_centers_y = 0.5 * (bin_edges_y[1:] + bin_edges_y[:-1])
+            
+            # Create a DataFrame for y histogram data
+            hist_y_df = pd.DataFrame({
+                f"{id}_hist_y_bin_centers": bin_centers_y,
+                f"{id}_hist_y_counts": hist_y
+            })
+            
+            # Add it to the main DataFrame using a MultiIndex
+            for i, (center, count) in enumerate(zip(bin_centers_y, hist_y)):
+                df.loc[f"hist_y_{i}", f"{id}_hist_y_bin"] = center
+                df.loc[f"hist_y_{i}", f"{id}_hist_y_count"] = count
+                
+        return df
+        
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_shaded_line.py

@@ -0,0 +1,58 @@
+#!/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_shaded_line.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_shaded_line.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+def _format_plot_shaded_line(id, tracked_dict, kwargs):
+    """Format data from a plot_shaded_line call.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to plot_shaded_line
+        
+    Returns:
+        pd.DataFrame: Formatted shaded line data
+    """
+    # Check if tracked_dict is empty or not a dictionary
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+        
+    # If we have a plot_df from plotting methods, use that directly
+    if 'plot_df' in tracked_dict and isinstance(tracked_dict['plot_df'], pd.DataFrame):
+        plot_df = tracked_dict['plot_df']
+        # Add the id prefix to all columns
+        return plot_df.add_prefix(f"{id}_")
+        
+    # Try getting the individual components
+    x = tracked_dict.get('x') 
+    y_middle = tracked_dict.get('y_middle')
+    y_lower = tracked_dict.get('y_lower')
+    y_upper = tracked_dict.get('y_upper')
+    
+    # If we have all necessary components
+    if x is not None and y_middle is not None and y_lower is not None:
+        data = {
+            f"{id}_shaded_line_x": x,
+            f"{id}_shaded_line_y": y_middle,
+            f"{id}_shaded_line_lower": y_lower,
+        }
+        
+        if y_upper is not None:
+            data[f"{id}_shaded_line_upper"] = y_upper
+        else:
+            # If only y_lower is provided, assume it's symmetric around y_middle
+            data[f"{id}_shaded_line_upper"] = y_middle + (y_middle - y_lower)
+            
+        return pd.DataFrame(data)
+        
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_violin.py

@@ -0,0 +1,117 @@
+#!/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_violin.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_violin.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+
+def _format_plot_violin(id, tracked_dict, kwargs):
+    """Format data from a plot_violin call.
+    
+    Formats data in a long-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_violin
+        
+    Returns:
+        pd.DataFrame: Formatted violin plot data in long 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')
+    
+    if data is not None:
+        # If data is a simple array or list
+        if isinstance(data, (np.ndarray, list)) and not isinstance(
+            data[0], (list, np.ndarray, dict)
+        ):
+            # Convert to long format with group and value columns
+            rows = [{'group': '0', 'value': val} for val in data]
+            df = pd.DataFrame(rows)
+            # Prefix columns with id
+            df.columns = [f"{id}_plot_violin_{col}" for col in df.columns]
+            return df
+
+        # If data is a list of arrays (multiple violin plots)
+        elif isinstance(data, (list, tuple)) and all(
+            isinstance(x, (list, np.ndarray)) for x in data
+        ):
+            # Get labels if available
+            labels = tracked_dict.get('labels')
+            
+            # Convert to long format
+            rows = []
+            for i, values in enumerate(data):
+                # Use label if available, otherwise use index
+                group = labels[i] if labels and i < len(labels) else f"group{i:02d}"
+                for val in values:
+                    rows.append({'group': str(group), 'value': val})
+            
+            if rows:
+                df = pd.DataFrame(rows)
+                # Prefix columns with id
+                df.columns = [f"{id}_plot_violin_{col}" for col in df.columns]
+                return df
+
+        # If data is a dictionary
+        elif isinstance(data, dict):
+            # Convert to long format
+            rows = []
+            for group, values in data.items():
+                for val in values:
+                    rows.append({'group': str(group), 'value': val})
+            
+            if rows:
+                df = pd.DataFrame(rows)
+                # Prefix columns with id
+                df.columns = [f"{id}_plot_violin_{col}" for col in df.columns]
+                return df
+
+        # If data is a DataFrame
+        elif isinstance(data, pd.DataFrame):
+            # For DataFrame data with x and y columns
+            x = tracked_dict.get('x')
+            y = tracked_dict.get('y')
+            
+            if x is not None and y is not None and x in data.columns and y in data.columns:
+                # Convert to long format
+                rows = []
+                for group_name, group_data in data.groupby(x):
+                    for val in group_data[y]:
+                        rows.append({'group': str(group_name), 'value': val})
+                
+                if rows:
+                    df = pd.DataFrame(rows)
+                    # Prefix columns with id
+                    df.columns = [f"{id}_plot_violin_{col}" for col in df.columns]
+                    return df
+            else:
+                # For other dataframes, melt to long format
+                try:
+                    # Try to melt to long format
+                    result = pd.melt(data)
+                    # Use variable column as group, value column as values
+                    result.columns = ['group', 'value']
+                    # Prefix columns with id
+                    result.columns = [f"{id}_plot_violin_{col}" for col in result.columns]
+                    return result
+                except Exception:
+                    # If melt fails, just return the original with prefixed columns
+                    result = data.copy()
+                    result.columns = [f"{id}_plot_violin_{col}" for col in result.columns]
+                    return result
+
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_scatter.py

@@ -0,0 +1,30 @@
+#!/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_scatter.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_scatter.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+def _format_scatter(id, tracked_dict, kwargs):
+    """Format data from a scatter 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:
+        x, y = args[0], args[1]
+        df = pd.DataFrame({f"{id}_scatter_x": x, f"{id}_scatter_y": y})
+        return df
+    
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_barplot.py

@@ -0,0 +1,51 @@
+#!/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_sns_barplot.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_barplot.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+
+def _format_sns_barplot(id, tracked_dict, kwargs):
+    """Format data from a sns_barplot call.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to sns_barplot
+        
+    Returns:
+        pd.DataFrame: Formatted data for the plot
+    """
+    # Check if tracked_dict is empty or not a dictionary
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+    
+    # If 'data' key is in tracked_dict, use it
+    if 'data' in tracked_dict:
+        df = tracked_dict['data']
+        if isinstance(df, pd.DataFrame):
+            # Add the id prefix to all columns
+            return df.add_prefix(f"{id}_")
+    
+    # Legacy handling for args
+    if 'args' in tracked_dict:
+        df = tracked_dict['args']
+        if isinstance(df, pd.DataFrame):
+            # When xyhue, without errorbar
+            try:
+                processed_df = pd.DataFrame(pd.Series(np.array(df).diagonal(), index=df.columns)).T
+                return processed_df.add_prefix(f"{id}_")
+            except (ValueError, TypeError, IndexError):
+                # If processing fails, return the original dataframe
+                return df.add_prefix(f"{id}_")
+    
+    # Default empty DataFrame if we can't process the input
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_boxplot.py

@@ -0,0 +1,93 @@
+#!/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_sns_boxplot.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_boxplot.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+import numpy as np
+
+def _format_sns_boxplot(id, tracked_dict, kwargs):
+    """Format data from a sns_boxplot call.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to sns_boxplot
+        
+    Returns:
+        pd.DataFrame: Formatted boxplot data
+    """
+    # Check if tracked_dict is empty or not a dictionary
+    if not tracked_dict:
+        return pd.DataFrame()
+    
+    # If tracked_dict is a dictionary, try to extract the data from it
+    if isinstance(tracked_dict, dict):
+        # First try to get 'data' key which is used in seaborn functions
+        if 'data' in tracked_dict:
+            data = tracked_dict['data']
+            if isinstance(data, pd.DataFrame):
+                result = data.copy()
+                # Add prefix to column names
+                result.columns = [f"{id}_sns_boxplot_{col}" for col in result.columns]
+                return result
+        
+        # If no 'data' key, try to get data from args
+        args = tracked_dict.get('args', [])
+        if len(args) > 0:
+            # First arg is often the data for seaborn plots
+            data = args[0]
+            if isinstance(data, pd.DataFrame):
+                result = data.copy()
+                # Add prefix to column names
+                result.columns = [f"{id}_sns_boxplot_{col}" for col in result.columns]
+                return result
+            
+            # Handle list or array data
+            elif isinstance(data, (list, np.ndarray)):
+                # Try to convert to DataFrame
+                try:
+                    if all(isinstance(item, (list, np.ndarray)) for item in data):
+                        # For list of lists/arrays (multiple groups)
+                        data_dict = {}
+                        for i, group_data in enumerate(data):
+                            data_dict[f"{id}_sns_boxplot_group{i:02d}"] = group_data
+                        return pd.DataFrame(data_dict)
+                    else:
+                        # For a single list/array
+                        return pd.DataFrame({f"{id}_sns_boxplot_values": data})
+                except:
+                    pass
+    
+    # If tracked_dict is a DataFrame already, use it directly
+    elif isinstance(tracked_dict, pd.DataFrame):
+        result = tracked_dict.copy()
+        # Add prefix to column names
+        result.columns = [f"{id}_sns_boxplot_{col}" for col in result.columns]
+        return result
+    
+    # If tracked_dict is list-like, try to convert it to a DataFrame
+    elif hasattr(tracked_dict, "__iter__") and not isinstance(tracked_dict, str):
+        try:
+            # For list-like data
+            if all(isinstance(item, (list, np.ndarray)) for item in tracked_dict):
+                # For list of lists/arrays (multiple groups)
+                data_dict = {}
+                for i, group_data in enumerate(tracked_dict):
+                    data_dict[f"{id}_sns_boxplot_group{i:02d}"] = group_data
+                return pd.DataFrame(data_dict)
+            else:
+                # For a single list/array
+                return pd.DataFrame({f"{id}_sns_boxplot_values": tracked_dict})
+        except:
+            pass
+    
+    # Return empty DataFrame if we couldn't extract useful data
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_heatmap.py

@@ -0,0 +1,94 @@
+#!/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_sns_heatmap.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_heatmap.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+import numpy as np
+
+def _format_sns_heatmap(id, tracked_dict, kwargs):
+    """Format data from a sns_heatmap call.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to sns_heatmap
+        
+    Returns:
+        pd.DataFrame: Formatted data for the plot
+    """
+    # Check if tracked_dict is empty
+    if not tracked_dict:
+        return pd.DataFrame()
+    
+    # If tracked_dict is a dictionary
+    if isinstance(tracked_dict, dict):
+        # If 'data' key is in tracked_dict, use it
+        if 'data' in tracked_dict:
+            data = tracked_dict['data']
+            
+            # Handle pandas DataFrame
+            if isinstance(data, pd.DataFrame):
+                df = data.copy()
+                # Add the id prefix to all columns
+                return df.add_prefix(f"{id}_sns_heatmap_")
+            
+            # Handle numpy array
+            elif isinstance(data, np.ndarray):
+                # Create DataFrame from array with simple column names
+                rows, cols = data.shape if len(data.shape) >= 2 else (data.shape[0], 1)
+                df = pd.DataFrame(
+                    data,
+                    columns=[f"col_{i}" for i in range(cols)]
+                )
+                # Add the id prefix to all columns
+                return df.add_prefix(f"{id}_sns_heatmap_")
+        
+        # Legacy handling for args
+        args = tracked_dict.get('args', [])
+        if len(args) > 0:
+            data = args[0]  # First arg to sns_heatmap is typically the data matrix
+            
+            # Handle pandas DataFrame
+            if isinstance(data, pd.DataFrame):
+                df = data.copy()
+                # Add the id prefix to all columns
+                return df.add_prefix(f"{id}_sns_heatmap_")
+            
+            # Handle numpy array
+            elif isinstance(data, np.ndarray):
+                # Create DataFrame from array with simple column names
+                rows, cols = data.shape if len(data.shape) >= 2 else (data.shape[0], 1)
+                df = pd.DataFrame(
+                    data,
+                    columns=[f"col_{i}" for i in range(cols)]
+                )
+                # Add the id prefix to all columns
+                return df.add_prefix(f"{id}_sns_heatmap_")
+    
+    # If tracked_dict is a DataFrame directly
+    elif isinstance(tracked_dict, pd.DataFrame):
+        df = tracked_dict.copy()
+        # Add the id prefix to all columns
+        return df.add_prefix(f"{id}_sns_heatmap_")
+    
+    # If tracked_dict is a numpy array directly
+    elif isinstance(tracked_dict, np.ndarray):
+        # Create DataFrame from array with simple column names
+        rows, cols = tracked_dict.shape if len(tracked_dict.shape) >= 2 else (tracked_dict.shape[0], 1)
+        df = pd.DataFrame(
+            tracked_dict,
+            columns=[f"col_{i}" for i in range(cols)]
+        )
+        # Add the id prefix to all columns
+        return df.add_prefix(f"{id}_sns_heatmap_")
+    
+    # Default empty DataFrame if we can't process the input
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_histplot.py

@@ -0,0 +1,92 @@
+#!/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_sns_histplot.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_histplot.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+
+def _format_sns_histplot(id, tracked_dict, kwargs):
+    """
+    Format data from a sns_histplot call as a bar plot representation.
+    
+    This formatter extracts both the raw data and the binned data from seaborn 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 sns_histplot
+        
+    Returns:
+        pd.DataFrame: Formatted data for the plot including 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()
+    
+    columns = {}
+    
+    # Check if histogram result is available in tracked_dict
+    hist_result = tracked_dict.get('hist_result', None)
+    
+    # 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:]
+    
+    # Get raw data if available
+    if 'data' in tracked_dict:
+        df = tracked_dict['data']
+        if isinstance(df, pd.DataFrame):
+            # Extract column data from kwargs if available
+            x_col = kwargs.get('x')
+            if x_col and x_col in df.columns:
+                columns[f"{id}_raw_data"] = df[x_col].values
+    
+    # Legacy handling for args
+    elif 'args' in tracked_dict:
+        args = tracked_dict['args']
+        if len(args) >= 1:
+            # First argument is typically the data
+            x = args[0]
+            if hasattr(x, 'values'):  # pandas Series or DataFrame
+                columns[f"{id}_raw_data"] = x.values
+            else:
+                columns[f"{id}_raw_data"] = x
+    
+    # If we have data to return
+    if columns:
+        # Ensure all arrays are the same length by padding with NaN
+        max_length = max(len(value) for value in columns.values() if hasattr(value, '__len__'))
+        for key, value in list(columns.items()):
+            if hasattr(value, '__len__') and 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 pd.DataFrame(columns)
+    
+    # Default empty DataFrame if we can't process the input
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_jointplot.py

@@ -0,0 +1,65 @@
+#!/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_sns_jointplot.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_jointplot.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+
+def _format_sns_jointplot(id, tracked_dict, kwargs):
+    """Format data from a sns_jointplot 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', [])
+    
+    # Joint distribution plot in seaborn
+    if len(args) >= 1:
+        data = args[0]
+        
+        # Get x and y variables from kwargs
+        x_var = kwargs.get("x")
+        y_var = kwargs.get("y")
+
+        # Handle DataFrame input
+        if isinstance(data, pd.DataFrame) and x_var and y_var:
+            # Extract the relevant columns
+            x_data = data[x_var]
+            y_data = data[y_var]
+
+            result = pd.DataFrame(
+                {f"{id}_joint_{x_var}": x_data, f"{id}_joint_{y_var}": y_data}
+            )
+            return result
+
+        # Handle direct x, y data arrays
+        elif isinstance(data, pd.DataFrame):
+            # If no x, y specified, return the whole dataframe
+            result = data.copy()
+            if id is not None:
+                result.columns = [
+                    f"{id}_joint_{col}" for col in result.columns
+                ]
+            return result
+
+        # Handle numpy arrays directly
+        elif (
+            all(arg in args for arg in range(2))
+            and isinstance(args[0], (np.ndarray, list))
+            and isinstance(args[1], (np.ndarray, list))
+        ):
+            x_data, y_data = args[0], args[1]
+            return pd.DataFrame(
+                {f"{id}_joint_x": x_data, f"{id}_joint_y": y_data}
+            )
+
+    return pd.DataFrame()