scitex 2.0.0__py2.py3-none-any.whl

scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_kdeplot.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_sns_kdeplot.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_kdeplot.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+
+def _format_sns_kdeplot(id, tracked_dict, kwargs):
+    """Format data from a sns_kdeplot call."""
+    # Kernel density estimate plot
+    if len(args) >= 1:
+        data = args[0]
+        x_var = kwtracked_dict.get("x")
+        y_var = kwtracked_dict.get("y")
+
+        # Handle DataFrame input with x, y variables
+        if isinstance(data, pd.DataFrame) and x_var:
+            if y_var:  # Bivariate KDE
+                result = pd.DataFrame(
+                    {
+                        f"{id}_kde_{x_var}": data[x_var],
+                        f"{id}_kde_{y_var}": data[y_var],
+                    }
+                )
+            else:  # Univariate KDE
+                result = pd.DataFrame({f"{id}_kde_{x_var}": data[x_var]})
+            return result
+
+        # Handle direct data array input
+        elif isinstance(data, (np.ndarray, list)):
+            y_data = (
+                args[1]
+                if len(args) > 1 and isinstance(args[1], (np.ndarray, list))
+                else None
+            )
+
+            if y_data is not None:  # Bivariate KDE
+                return pd.DataFrame(
+                    {f"{id}_kde_x": data, f"{id}_kde_y": y_data}
+                )
+            else:  # Univariate KDE
+                return pd.DataFrame({f"{id}_kde_x": data})
+
+        # Handle DataFrame input without x, y specified
+        elif isinstance(data, pd.DataFrame):
+            result = data.copy()
+            if id is not None:
+                result.columns = [f"{id}_kde_{col}" for col in result.columns]
+            return result
+
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_lineplot.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_sns_lineplot.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_lineplot.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+
+def _format_sns_lineplot(id, tracked_dict, kwargs):
+    """Format data from a sns_lineplot call."""
+    # Line plot with potential error bands from seaborn
+    if len(args) >= 1:
+        data = args[0]
+        x_var = kwtracked_dict.get("x")
+        y_var = kwtracked_dict.get("y")
+
+        # Handle DataFrame input with x, y variables
+        if isinstance(data, pd.DataFrame) and x_var and y_var:
+            result = pd.DataFrame(
+                {
+                    f"{id}_line_{x_var}": data[x_var],
+                    f"{id}_line_{y_var}": data[y_var],
+                }
+            )
+
+            # Add grouping variable if present
+            hue_var = kwtracked_dict.get("hue")
+            if hue_var and hue_var in data.columns:
+                result[f"{id}_line_{hue_var}"] = data[hue_var]
+
+            return result
+
+        # Handle direct x, y data arrays
+        elif (
+            len(args) > 1
+            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}_line_x": x_data, f"{id}_line_y": y_data}
+            )
+
+        # Handle DataFrame input without x, y specified
+        elif isinstance(data, pd.DataFrame):
+            result = data.copy()
+            if id is not None:
+                result.columns = [f"{id}_line_{col}" for col in result.columns]
+            return result
+
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_pairplot.py

@@ -0,0 +1,45 @@
+#!/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_pairplot.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_pairplot.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+def _format_sns_pairplot(id, tracked_dict, kwargs):
+    """Format data from a sns_pairplot 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', [])
+    
+    # Grid of plots showing pairwise relationships
+    if len(args) >= 1:
+        data = args[0]
+
+        # Handle DataFrame input
+        if isinstance(data, pd.DataFrame):
+            # For pairplot, just return the full DataFrame since it uses all variables
+            result = data.copy()
+            if id is not None:
+                result.columns = [f"{id}_pair_{col}" for col in result.columns]
+
+            # Add vars or hue columns if specified
+            vars_list = kwargs.get("vars")
+            if vars_list and all(var in data.columns for var in vars_list):
+                # Keep only the specified columns
+                result = pd.DataFrame(
+                    {f"{id}_pair_{col}": data[col] for col in vars_list}
+                )
+
+            return result
+
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_scatterplot.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_sns_scatterplot.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_scatterplot.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+
+def _format_sns_scatterplot(id, tracked_dict, kwargs=None):
+    """Format data from a sns_scatterplot call.
+    
+    Args:
+        id (str): Identifier for the plot (already unpacked from the record tuple)
+        tracked_dict (dict): Tracked data dictionary from the record tuple
+        kwargs (dict): Keyword arguments from the record tuple
+        
+    Returns:
+        pd.DataFrame: Formatted data for the plot
+    """
+    # Look for the DataFrame in the kwargs dictionary if provided
+    if kwargs and isinstance(kwargs, dict) and 'data' in kwargs:
+        data = kwargs['data']
+        if isinstance(data, pd.DataFrame):
+            # Use the DataFrame provided in kwargs
+            result = pd.DataFrame()
+            
+            # If x and y variables are specified in kwargs, use them to extract columns
+            x_var = kwargs.get('x')
+            y_var = kwargs.get('y')
+            
+            if x_var and y_var and x_var in data.columns and y_var in data.columns:
+                # Extract these specific columns
+                result[f"{id}_x"] = data[x_var]
+                result[f"{id}_y"] = data[y_var]
+                
+                # Also extract hue, size, style if they are specified
+                for extra_var in ['hue', 'size', 'style']:
+                    var_name = kwargs.get(extra_var)
+                    if var_name and var_name in data.columns:
+                        result[f"{id}_{extra_var}"] = data[var_name]
+                
+                return result
+            else:
+                # If columns aren't specified, include all columns
+                for col in data.columns:
+                    result[f"{id}_{col}"] = data[col]
+                return result
+    
+    # Alternative: try to find a DataFrame in tracked_dict
+    if tracked_dict and isinstance(tracked_dict, dict):
+        # Search for 'data' key
+        if 'data' in tracked_dict and isinstance(tracked_dict['data'], pd.DataFrame):
+            data = tracked_dict['data']
+            result = pd.DataFrame()
+            
+            # Just copy all columns from the data
+            for col in data.columns:
+                result[f"{id}_{col}"] = data[col]
+            
+            return result
+    
+    # If all else fails, return an empty DataFrame
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_stripplot.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_sns_stripplot.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_stripplot.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+def _format_sns_stripplot(id, tracked_dict, kwargs):
+    """Format data from a sns_stripplot call.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to sns_stripplot
+        
+    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:
+        data = tracked_dict['data']
+        
+        # Handle DataFrame input with x and/or y variables
+        if isinstance(data, pd.DataFrame):
+            result = pd.DataFrame()
+            
+            # Extract variables from kwargs
+            x_var = kwargs.get("x")
+            y_var = kwargs.get("y")
+            
+            # Add x variable if specified
+            if x_var and x_var in data.columns:
+                result[f"{id}_strip_{x_var}"] = data[x_var]
+                
+            # Add y variable if specified
+            if y_var and y_var in data.columns:
+                result[f"{id}_strip_{y_var}"] = data[y_var]
+                
+            # Add grouping variable if present
+            hue_var = kwargs.get("hue")
+            if hue_var and hue_var in data.columns:
+                result[f"{id}_strip_{hue_var}"] = data[hue_var]
+                
+            # If we've added columns, return the result
+            if not result.empty:
+                return result
+                
+            # If no columns were explicitly specified, return all columns
+            result = data.copy()
+            result.columns = [f"{id}_strip_{col}" for col in result.columns]
+            return result
+    
+    # Legacy handling for args
+    if 'args' in tracked_dict and len(tracked_dict['args']) >= 1:
+        data = tracked_dict['args'][0]
+        
+        # Handle DataFrame input
+        if isinstance(data, pd.DataFrame):
+            result = data.copy()
+            result.columns = [f"{id}_strip_{col}" for col in result.columns]
+            return result
+    
+    # Default empty DataFrame if we can't process the input
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_swarmplot.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_sns_swarmplot.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_swarmplot.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+def _format_sns_swarmplot(id, tracked_dict, kwargs):
+    """Format data from a sns_swarmplot call.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to sns_swarmplot
+        
+    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:
+        data = tracked_dict['data']
+        
+        # Handle DataFrame input with x and/or y variables
+        if isinstance(data, pd.DataFrame):
+            result = pd.DataFrame()
+            
+            # Extract variables from kwargs
+            x_var = kwargs.get("x")
+            y_var = kwargs.get("y")
+            
+            # Add x variable if specified
+            if x_var and x_var in data.columns:
+                result[f"{id}_swarm_{x_var}"] = data[x_var]
+                
+            # Add y variable if specified
+            if y_var and y_var in data.columns:
+                result[f"{id}_swarm_{y_var}"] = data[y_var]
+                
+            # Add grouping variable if present
+            hue_var = kwargs.get("hue")
+            if hue_var and hue_var in data.columns:
+                result[f"{id}_swarm_{hue_var}"] = data[hue_var]
+                
+            # If we've added columns, return the result
+            if not result.empty:
+                return result
+                
+            # If no columns were explicitly specified, return all columns
+            result = data.copy()
+            result.columns = [f"{id}_swarm_{col}" for col in result.columns]
+            return result
+    
+    # Legacy handling for args
+    if 'args' in tracked_dict and len(tracked_dict['args']) >= 1:
+        data = tracked_dict['args'][0]
+        
+        # Handle DataFrame input
+        if isinstance(data, pd.DataFrame):
+            result = data.copy()
+            result.columns = [f"{id}_swarm_{col}" for col in result.columns]
+            return result
+    
+    # Default empty DataFrame if we can't process the input
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_violinplot.py

@@ -0,0 +1,155 @@
+#!/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_violinplot.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_sns_violinplot.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+import numpy as np
+
+def _format_sns_violinplot(id, tracked_dict, kwargs):
+    """Format data from a sns_violinplot call.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to sns_violinplot
+        
+    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):
+        # First try to get data from the 'data' key
+        if 'data' in tracked_dict:
+            data = tracked_dict['data']
+            
+            # Handle pandas DataFrame
+            if isinstance(data, pd.DataFrame):
+                try:
+                    df = data.copy()
+                    # Add the id prefix to all columns
+                    result_df = pd.DataFrame()
+                    # Copy columns one by one to avoid ambiguity errors
+                    for col in df.columns:
+                        result_df[f"{id}_sns_violin_{col}"] = df[col]
+                    return result_df
+                except Exception:
+                    # In case of any errors, try to convert to a simpler format
+                    try:
+                        # Extract x and y variables if available in kwargs
+                        x_var = kwargs.get('x')
+                        y_var = kwargs.get('y')
+                        
+                        # If we have both x and y variables, extract just those columns
+                        if x_var in data.columns and y_var in data.columns:
+                            return pd.DataFrame({
+                                f"{id}_sns_violin_{x_var}": data[x_var],
+                                f"{id}_sns_violin_{y_var}": data[y_var]
+                            })
+                        # Otherwise, just return the first column
+                        elif len(data.columns) > 0:
+                            first_col = data.columns[0]
+                            return pd.DataFrame({
+                                f"{id}_sns_violin_values": data[first_col]
+                            })
+                    except Exception:
+                        # If all else fails, return an empty DataFrame
+                        return pd.DataFrame()
+            
+            # Handle list or numpy array
+            elif isinstance(data, (list, np.ndarray)):
+                # Try to convert to DataFrame
+                try:
+                    if isinstance(data, list) and len(data) > 0 and all(isinstance(item, (list, np.ndarray)) for item in data):
+                        # For list of lists/arrays (multiple violins)
+                        result = pd.DataFrame()
+                        for i, group_data in enumerate(data):
+                            result[f"{id}_sns_violin_group{i:02d}"] = pd.Series(group_data)
+                        return result
+                    else:
+                        # For a single list/array
+                        return pd.DataFrame({f"{id}_sns_violin_values": data})
+                except:
+                    # Return empty DataFrame if conversion fails
+                    return pd.DataFrame()
+        
+        # Legacy handling for args
+        args = tracked_dict.get('args', [])
+        if len(args) > 0:
+            data = args[0]  # First arg to sns_violinplot is typically the 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_violin_")
+            
+            # Handle list or numpy array
+            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 violins)
+                        result = pd.DataFrame()
+                        for i, group_data in enumerate(data):
+                            result[f"{id}_sns_violin_group{i:02d}"] = pd.Series(group_data)
+                        return result
+                    else:
+                        # For a single list/array
+                        return pd.DataFrame({f"{id}_sns_violin_values": data})
+                except:
+                    # Return empty DataFrame if conversion fails
+                    return pd.DataFrame()
+    
+    # If tracked_dict is a DataFrame directly
+    elif isinstance(tracked_dict, pd.DataFrame):
+        try:
+            df = tracked_dict.copy()
+            # Add the id prefix to all columns, column by column to avoid ambiguity
+            result_df = pd.DataFrame()
+            for col in df.columns:
+                result_df[f"{id}_sns_violin_{col}"] = df[col]
+            return result_df
+        except Exception:
+            # In case of any errors, try a simpler approach
+            try:
+                # Just take the first column if possible
+                if len(tracked_dict.columns) > 0:
+                    first_col = tracked_dict.columns[0]
+                    return pd.DataFrame({
+                        f"{id}_sns_violin_values": tracked_dict[first_col]
+                    })
+            except Exception:
+                # If all else fails, return an empty DataFrame
+                return pd.DataFrame()
+    
+    # If tracked_dict is a list or numpy array directly
+    elif isinstance(tracked_dict, (list, np.ndarray)):
+        # Try to convert to DataFrame
+        try:
+            if all(isinstance(item, (list, np.ndarray)) for item in tracked_dict):
+                # For list of lists/arrays (multiple violins)
+                result = pd.DataFrame()
+                for i, group_data in enumerate(tracked_dict):
+                    result[f"{id}_sns_violin_group{i:02d}"] = pd.Series(group_data)
+                return result
+            else:
+                # For a single list/array
+                return pd.DataFrame({f"{id}_sns_violin_values": tracked_dict})
+        except:
+            # Return empty DataFrame if conversion fails
+            return pd.DataFrame()
+    
+    # Default empty DataFrame if we can't process the input
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_violin.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_violin.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_violin.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+
+def _format_violin(id, tracked_dict, kwargs):
+    """Format data from a 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 violin plot
+        
+    Returns:
+        pd.DataFrame: Formatted violin 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()
+    
+    # Get the args from tracked_dict
+    args = tracked_dict.get('args', [])
+    
+    # Similar to boxplot but shows probability density
+    if len(args) >= 1:
+        data = args[0]
+        
+        # Handle case when data is a simple array or list
+        if isinstance(data, (list, np.ndarray)) 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}_violin_{col}" for col in df.columns]
+            return df
+            
+        # Handle case when data is a dictionary
+        elif isinstance(data, dict):
+            # Convert to long format with group and value columns
+            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}_violin_{col}" for col in df.columns]
+                return df
+    
+    # If we get here, either no data or unsupported format
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_violinplot.py

@@ -0,0 +1,77 @@
+#!/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_violinplot.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_violinplot.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+
+def _format_violinplot(id, tracked_dict, kwargs):
+    """Format data from a violinplot 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 violinplot
+        
+    Returns:
+        pd.DataFrame: Formatted violinplot 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()
+    
+    # Get the args from tracked_dict
+    args = tracked_dict.get('args', [])
+    
+    # Similar to violin plot
+    if len(args) >= 1:
+        data = args[0]
+        
+        # Handle case when data is a simple array or list
+        if isinstance(data, (list, np.ndarray)) 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}_violinplot_{col}" for col in df.columns]
+            return df
+            
+        # Handle case when data is a dictionary
+        elif isinstance(data, dict):
+            # Convert to long format with group and value columns
+            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}_violinplot_{col}" for col in df.columns]
+                return df
+            
+        # Handle case when data is a list of arrays
+        elif isinstance(data, (list, tuple)) and all(isinstance(x, (list, np.ndarray)) for x in data):
+            rows = []
+            for i, values in enumerate(data):
+                for val in values:
+                    rows.append({'group': str(i), 'value': val})
+            
+            if rows:
+                df = pd.DataFrame(rows)
+                # Prefix columns with id
+                df.columns = [f"{id}_violinplot_{col}" for col in df.columns]
+                return df
+    
+    # If we get here, either no data or unsupported format
+    return pd.DataFrame()