scitex 2.0.0__py2.py3-none-any.whl

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_heatmap.py

@@ -0,0 +1,66 @@
+#!/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_heatmap.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_heatmap.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+
+def _format_plot_heatmap(id, tracked_dict, kwargs):
+    """Format data from a plot_heatmap call.
+    
+    Exports heatmap data in xyz format (x, y, value) for better compatibility.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to plot_heatmap
+        
+    Returns:
+        pd.DataFrame: Formatted heatmap data in xyz 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')
+    x_labels = tracked_dict.get('x_labels')
+    y_labels = tracked_dict.get('y_labels')
+    
+    if data is not None and hasattr(data, "shape") and len(data.shape) == 2:
+        rows, cols = data.shape
+        row_indices, col_indices = np.meshgrid(
+            range(rows), range(cols), indexing="ij"
+        )
+        
+        # Format data in xyz format (x, y, value)
+        df = pd.DataFrame(
+            {
+                f"{id}_x": col_indices.flatten(),  # x is column
+                f"{id}_y": row_indices.flatten(),  # y is row
+                f"{id}_value": data.flatten(),     # z is intensity/value
+            }
+        )
+        
+        # Add label information if available
+        if x_labels is not None and len(x_labels) == cols:
+            # Map column indices to x labels (columns are x)
+            x_label_map = {i: label for i, label in enumerate(x_labels)}
+            df[f"{id}_x_label"] = df[f"{id}_x"].map(x_label_map)
+            
+        if y_labels is not None and len(y_labels) == rows:
+            # Map row indices to y labels (rows are y)
+            y_label_map = {i: label for i, label in enumerate(y_labels)}
+            df[f"{id}_y_label"] = df[f"{id}_y"].map(y_label_map)
+            
+        return df
+        
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_image.py

@@ -0,0 +1,95 @@
+#!/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_image.py
+# ----------------------------------------
+import os
+import numpy as np
+import pandas as pd
+
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_image.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+def _format_plot_image(id, tracked_dict, kwargs):
+    """Format data from a plot_image call.
+    
+    Exports image data in long-format xyz format for better compatibility.
+    Also saves channel data for RGB/RGBA images.
+    
+    Args:
+        id (str or int): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to plot_image
+        
+    Returns:
+        pd.DataFrame: Formatted image data in xyz format
+    """
+    # Check if tracked_dict is not a dictionary or is empty
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+        
+    # Check if image_df is available and use it if present
+    if "image_df" in tracked_dict:
+        image_df = tracked_dict.get("image_df")
+        if isinstance(image_df, pd.DataFrame):
+            # Add prefix if ID is provided
+            if id is not None:
+                image_df = image_df.copy()
+                id_str = str(id)
+                # Convert columns to strings first to handle integer column names
+                image_df.columns = [str(col) for col in image_df.columns]
+                image_df.columns = [f"{id_str}_{col}" if not col.startswith(f"{id_str}_") else col for col in image_df.columns]
+            return image_df
+    
+    # If we have image data
+    if "image" in tracked_dict:
+        img = tracked_dict["image"]
+        id_str = str(id) if id is not None else "image"
+        
+        # Handle 2D grayscale images - create xyz format (x, y, value)
+        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"
+            )
+
+            # Create xyz format
+            df = pd.DataFrame(
+                {
+                    f"{id_str}_x": col_indices.flatten(),  # x is column
+                    f"{id_str}_y": row_indices.flatten(),  # y is row
+                    f"{id_str}_value": img.flatten(),      # z is intensity
+                }
+            )
+            return df
+
+        # Handle RGB/RGBA images - create xyz format with additional channel information
+        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"
+            )
+
+            # Create a list to hold rows for a long-format DataFrame
+            data_rows = []
+            channel_names = ["r", "g", "b", "a"]
+            
+            # Create long-format data (x, y, channel, value)
+            for r in range(rows):
+                for c in range(cols):
+                    for ch in range(min(channels, len(channel_names))):
+                        data_rows.append({
+                            f"{id_str}_x": c,                      # x is column
+                            f"{id_str}_y": r,                      # y is row
+                            f"{id_str}_channel": channel_names[ch],  # channel name
+                            f"{id_str}_value": img[r, c, ch]        # channel value
+                        })
+            
+            # Return long-format DataFrame
+            return pd.DataFrame(data_rows)
+    
+    # Skip CSV export if no suitable data format found
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_joyplot.py

@@ -0,0 +1,67 @@
+#!/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_joyplot.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_joyplot.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+from scitex.pd import force_df
+
+def _format_plot_joyplot(id, tracked_dict, kwargs):
+    """Format data from a plot_joyplot call.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing 'joyplot_data' key with joyplot data
+        kwargs (dict): Keyword arguments passed to plot_joyplot
+        
+    Returns:
+        pd.DataFrame: Formatted joyplot 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 joyplot_data from tracked_dict
+    data = tracked_dict.get('joyplot_data')
+    
+    if data is None:
+        return pd.DataFrame()
+
+    # Handle different data types
+    if isinstance(data, pd.DataFrame):
+        # Make a copy to avoid modifying original
+        result = data.copy()
+        # Add prefix to column names if ID is provided
+        if id is not None:
+            result.columns = [f"{id}_joyplot_{col}" for col in result.columns]
+        return result
+
+    elif isinstance(data, dict):
+        # Convert dictionary to DataFrame
+        result = pd.DataFrame()
+        for group, values in data.items():
+            result[f"{id}_joyplot_{group}"] = pd.Series(values)
+        return result
+
+    elif isinstance(data, (list, tuple)) and all(
+        isinstance(x, (np.ndarray, list)) for x in data
+    ):
+        # Convert list of arrays to DataFrame
+        result = pd.DataFrame()
+        for i, values in enumerate(data):
+            result[f"{id}_joyplot_group{i:02d}"] = pd.Series(values)
+        return result
+    
+    # Try to force to DataFrame as a last resort
+    try:
+        return force_df({f"{id}_joyplot_data": data})
+    except:
+        return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_kde.py

@@ -0,0 +1,52 @@
+#!/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_kde.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_kde.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+from scitex.pd import force_df
+
+def _format_plot_kde(id, tracked_dict, kwargs):
+    """Format data from a plot_kde call.
+    
+    Processes kernel density estimation plot data.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing 'x', 'kde', and 'n' keys
+        kwargs (dict): Keyword arguments passed to plot_kde
+        
+    Returns:
+        pd.DataFrame: Formatted KDE data
+    """
+    # Check if tracked_dict is empty or not a dictionary
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+    
+    x = tracked_dict.get('x')
+    kde = tracked_dict.get('kde')
+    n = tracked_dict.get('n')
+    
+    if x is None or kde is None:
+        return pd.DataFrame()
+    
+    df = pd.DataFrame({
+        f"{id}_kde_x": x,
+        f"{id}_kde_density": kde
+    })
+    
+    # Add sample count if available
+    if n is not None:
+        # If n is a scalar, create a list with the same length as x
+        if not hasattr(n, '__len__'):
+            n = [n] * len(x)
+        df[f"{id}_kde_n"] = n
+        
+    return df

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_line.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_plot_line.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_line.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+def _format_plot_line(id, tracked_dict, kwargs):
+    """Format data from a plot_line call.
+    
+    Processes plot_line data for CSV export.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing 'plot_df' key with plot data
+        kwargs (dict): Keyword arguments passed to plot_line
+        
+    Returns:
+        pd.DataFrame: Formatted line plot 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 plot_df from tracked_dict
+    plot_df = tracked_dict.get('plot_df')
+    
+    if plot_df is None or not isinstance(plot_df, pd.DataFrame):
+        return pd.DataFrame()
+    
+    # Create a copy to avoid modifying the original
+    result = plot_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}_line_{col}" for col in result.columns]
+    
+    return result

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_mean_ci.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_plot_mean_ci.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_mean_ci.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+def _format_plot_mean_ci(id, tracked_dict, kwargs):
+    """Format data from a plot_mean_ci call.
+    
+    Processes mean with confidence interval band plot data for CSV export.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Contains 'plot_df' (pandas DataFrame with mean and CI data)
+        kwargs (dict): Keyword arguments passed to plot_mean_ci
+        
+    Returns:
+        pd.DataFrame: Formatted mean and CI data
+    """
+    # Mean-CI plot data is typically passed in the plot_df in the args dictionary
+    if not args:
+        return pd.DataFrame()
+    
+    # Get the plot_df from args
+    plot_df = tracked_dict.get('plot_df')
+    
+    if plot_df is None or not isinstance(plot_df, pd.DataFrame):
+        return pd.DataFrame()
+    
+    # Create a copy to avoid modifying the original
+    result = plot_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}_mean_ci_{col}" for col in result.columns]
+    
+    return result

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_mean_std.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_plot_mean_std.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_mean_std.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+def _format_plot_mean_std(id, tracked_dict, kwargs):
+    """Format data from a plot_mean_std call.
+    
+    Processes mean with standard deviation band plot data for CSV export.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing 'plot_df' key with mean and std data
+        kwargs (dict): Keyword arguments passed to plot_mean_std
+        
+    Returns:
+        pd.DataFrame: Formatted mean and std 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 plot_df from tracked_dict
+    plot_df = tracked_dict.get('plot_df')
+    
+    if plot_df is None or not isinstance(plot_df, pd.DataFrame):
+        return pd.DataFrame()
+    
+    # Create a copy to avoid modifying the original
+    result = plot_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}_mean_std_{col}" for col in result.columns]
+    
+    return result

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_median_iqr.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_plot_median_iqr.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_median_iqr.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+def _format_plot_median_iqr(id, tracked_dict, kwargs):
+    """Format data from a plot_median_iqr call.
+    
+    Processes median with interquartile range band plot data for CSV export.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Contains 'plot_df' (pandas DataFrame with median and IQR data)
+        kwargs (dict): Keyword arguments passed to plot_median_iqr
+        
+    Returns:
+        pd.DataFrame: Formatted median and IQR data
+    """
+    # Median-IQR plot data is typically passed in the plot_df in the args dictionary
+    if not args:
+        return pd.DataFrame()
+    
+    # Get the plot_df from args
+    plot_df = tracked_dict.get('plot_df')
+    
+    if plot_df is None or not isinstance(plot_df, pd.DataFrame):
+        return pd.DataFrame()
+    
+    # Create a copy to avoid modifying the original
+    result = plot_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}_median_iqr_{col}" for col in result.columns]
+    
+    return result

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_raster.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_raster.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_raster.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+def _format_plot_raster(id, tracked_dict, kwargs):
+    """Format data from a plot_raster call.
+    
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing 'raster_digit_df' key with raster plot data
+        kwargs (dict): Keyword arguments passed to plot_raster
+        
+    Returns:
+        pd.DataFrame: Formatted raster plot data
+    """
+    # Check if args is empty or not a dictionary
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+    
+    # Get the raster_digit_df from args
+    raster_df = tracked_dict.get('raster_digit_df')
+    
+    if raster_df is None or not isinstance(raster_df, pd.DataFrame):
+        return pd.DataFrame()
+    
+    # Create a copy to avoid modifying the original
+    result = raster_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}_raster_{col}" for col in result.columns]
+    
+    return result

scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_rectangle.py

@@ -0,0 +1,103 @@
+#!/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_rectangle.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/_format_plot_rectangle.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+import pandas as pd
+
+def _format_plot_rectangle(id, tracked_dict, kwargs):
+    """Format data from a plot_rectangle call."""
+    # 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 rectangle parameters directly from tracked_dict
+    x = tracked_dict.get('x')
+    y = tracked_dict.get('y')
+    width = tracked_dict.get('width')
+    height = tracked_dict.get('height')
+    
+    # If direct parameters aren't available, try the args
+    if any(param is None for param in [x, y, width, height]):
+        args = tracked_dict.get('args', [])
+        
+        # Rectangles defined by [x, y, width, height]
+        if len(args) >= 4:
+            x, y, width, height = args[0], args[1], args[2], args[3]
+    
+    # If we have all required parameters, create the DataFrame
+    if all(param is not None for param in [x, y, width, height]):
+        try:
+            # Handle single rectangle
+            if all(isinstance(val, (int, float, np.number)) for val in [x, y, width, height]):
+                return pd.DataFrame(
+                    {
+                        f"{id}_rectangle_x": [x],
+                        f"{id}_rectangle_y": [y],
+                        f"{id}_rectangle_width": [width],
+                        f"{id}_rectangle_height": [height],
+                    }
+                )
+            
+            # Handle multiple rectangles (arrays)
+            elif all(
+                isinstance(val, (np.ndarray, list))
+                for val in [x, y, width, height]
+            ):
+                try:
+                    result_df = pd.DataFrame(
+                        {
+                            f"{id}_rectangle_x": x,
+                            f"{id}_rectangle_y": y,
+                            f"{id}_rectangle_width": width,
+                            f"{id}_rectangle_height": height,
+                        }
+                    )
+                    return result_df
+                except ValueError:
+                    # Handle case where arrays might be different lengths
+                    result = pd.DataFrame()
+                    result[f"{id}_rectangle_x"] = pd.Series(x)
+                    result[f"{id}_rectangle_y"] = pd.Series(y)
+                    result[f"{id}_rectangle_width"] = pd.Series(width)
+                    result[f"{id}_rectangle_height"] = pd.Series(height)
+                    return result
+        except Exception:
+            # Fallback for rectangle in case of any errors
+            try:
+                return pd.DataFrame({
+                    f"{id}_rectangle_x": [float(x) if x is not None else 0],
+                    f"{id}_rectangle_y": [float(y) if y is not None else 0],
+                    f"{id}_rectangle_width": [float(width) if width is not None else 0],
+                    f"{id}_rectangle_height": [float(height) if height is not None else 0],
+                })
+            except (TypeError, ValueError):
+                pass
+    
+    # Check directly in the kwtracked_dict for the parameters
+    rect_x = kwargs.get('x')
+    rect_y = kwargs.get('y')
+    rect_w = kwargs.get('width')
+    rect_h = kwargs.get('height')
+    
+    if all(param is not None for param in [rect_x, rect_y, rect_w, rect_h]):
+        try:
+            return pd.DataFrame({
+                f"{id}_rectangle_x": [float(rect_x)],
+                f"{id}_rectangle_y": [float(rect_y)],
+                f"{id}_rectangle_width": [float(rect_w)],
+                f"{id}_rectangle_height": [float(rect_h)],
+            })
+        except (TypeError, ValueError):
+            pass
+    
+    # Default empty DataFrame if nothing could be processed
+    return pd.DataFrame()