scitex 2.3.0__py3-none-any.whl → 2.4.1__py3-none-any.whl

scitex/plt/_subplots/_export_as_csv.py

@@ -27,12 +27,12 @@ _METHOD_ALTERNATIVES = {
     'bar': 'plot_bar',  # already tracked
     'barh': 'plot_barh',  # already tracked
     'hist': 'hist',  # already tracked
-    'boxplot': 'plot_box or plot_boxplot',
-    'violinplot': 'plot_violin or plot_violinplot',
+    'boxplot': 'stx_box or plot_boxplot',
+    'violinplot': 'stx_violin or plot_violinplot',
     'fill_between': 'plot_fill_between',
     'errorbar': 'plot_errorbar',
     'contour': 'plot_contour',
-    'heatmap': 'plot_heatmap',
+    'heatmap': 'stx_heatmap',
 
     # Seaborn methods (accessed via ax.sns_*)
     'scatterplot': 'sns_scatterplot',
@@ -60,42 +60,93 @@ def _warn_once(message, category=UserWarning):
         _warning_registry.add(message)
         warnings.warn(message, category, stacklevel=3)
 
-from ._export_as_csv_formatters import (_format_annotate, _format_bar,
-                                        _format_barh, _format_boxplot,
-                                        _format_contour, _format_errorbar,
-                                        _format_eventplot, _format_fill,
-                                        _format_fill_between, _format_hist,
-                                        _format_imshow, _format_imshow2d,
-                                        _format_plot, _format_plot_box,
-                                        _format_plot_conf_mat,
-                                        _format_plot_ecdf, _format_plot_fillv,
-                                        _format_plot_heatmap,
-                                        _format_plot_image,
-                                        _format_plot_imshow,
-                                        _format_plot_joyplot, _format_plot_kde,
-                                        _format_plot_line,
-                                        _format_plot_mean_ci,
-                                        _format_plot_mean_std,
-                                        _format_plot_median_iqr,
-                                        _format_plot_raster,
-                                        _format_plot_rectangle,
-                                        _format_plot_scatter,
-                                        _format_plot_scatter_hist,
-                                        _format_plot_shaded_line,
-                                        _format_plot_violin, _format_scatter,
-                                        _format_sns_barplot,
-                                        _format_sns_boxplot,
-                                        _format_sns_heatmap,
-                                        _format_sns_histplot,
-                                        _format_sns_jointplot,
-                                        _format_sns_kdeplot,
-                                        _format_sns_lineplot,
-                                        _format_sns_pairplot,
-                                        _format_sns_scatterplot,
-                                        _format_sns_stripplot,
-                                        _format_sns_swarmplot,
-                                        _format_sns_violinplot, _format_text,
-                                        _format_violin, _format_violinplot)
+from ._export_as_csv_formatters import (
+    # Standard matplotlib formatters
+    _format_annotate, _format_bar, _format_barh, _format_boxplot,
+    _format_contour, _format_contourf, _format_errorbar, _format_eventplot,
+    _format_fill, _format_fill_between, _format_hexbin, _format_hist,
+    _format_hist2d, _format_imshow, _format_imshow2d, _format_matshow,
+    _format_pie, _format_plot, _format_quiver, _format_scatter, _format_stem,
+    _format_step, _format_streamplot, _format_text, _format_violin,
+    _format_violinplot,
+    # Custom scitex formatters
+    _format_plot_box, _format_plot_conf_mat, _format_plot_ecdf,
+    _format_plot_fillv, _format_plot_heatmap, _format_plot_image,
+    _format_plot_imshow, _format_plot_joyplot, _format_plot_kde,
+    _format_plot_line, _format_plot_mean_ci, _format_plot_mean_std,
+    _format_plot_median_iqr, _format_plot_raster, _format_plot_rectangle,
+    _format_plot_scatter, _format_plot_scatter_hist, _format_plot_shaded_line,
+    _format_plot_violin,
+    # Seaborn formatters
+    _format_sns_barplot, _format_sns_boxplot, _format_sns_heatmap,
+    _format_sns_histplot, _format_sns_jointplot, _format_sns_kdeplot,
+    _format_sns_lineplot, _format_sns_pairplot, _format_sns_scatterplot,
+    _format_sns_stripplot, _format_sns_swarmplot, _format_sns_violinplot,
+)
+
+# Registry mapping method names to their formatter functions
+_FORMATTER_REGISTRY = {
+    # Standard matplotlib methods
+    "annotate": _format_annotate,
+    "bar": _format_bar,
+    "barh": _format_barh,
+    "boxplot": _format_boxplot,
+    "contour": _format_contour,
+    "contourf": _format_contourf,
+    "errorbar": _format_errorbar,
+    "eventplot": _format_eventplot,
+    "fill": _format_fill,
+    "fill_between": _format_fill_between,
+    "hexbin": _format_hexbin,
+    "hist": _format_hist,
+    "hist2d": _format_hist2d,
+    "imshow": _format_imshow,
+    "imshow2d": _format_imshow2d,
+    "matshow": _format_matshow,
+    "pie": _format_pie,
+    "plot": _format_plot,
+    "quiver": _format_quiver,
+    "scatter": _format_scatter,
+    "stem": _format_stem,
+    "step": _format_step,
+    "streamplot": _format_streamplot,
+    "text": _format_text,
+    "violin": _format_violin,
+    "violinplot": _format_violinplot,
+    # Custom scitex methods
+    "stx_box": _format_plot_box,
+    "stx_conf_mat": _format_plot_conf_mat,
+    "stx_ecdf": _format_plot_ecdf,
+    "stx_fillv": _format_plot_fillv,
+    "stx_heatmap": _format_plot_heatmap,
+    "stx_image": _format_plot_image,
+    "plot_imshow": _format_plot_imshow,
+    "stx_joyplot": _format_plot_joyplot,
+    "stx_kde": _format_plot_kde,
+    "stx_line": _format_plot_line,
+    "stx_mean_ci": _format_plot_mean_ci,
+    "stx_mean_std": _format_plot_mean_std,
+    "stx_median_iqr": _format_plot_median_iqr,
+    "stx_raster": _format_plot_raster,
+    "stx_rectangle": _format_plot_rectangle,
+    "plot_scatter": _format_plot_scatter,
+    "stx_scatter_hist": _format_plot_scatter_hist,
+    "stx_shaded_line": _format_plot_shaded_line,
+    "stx_violin": _format_plot_violin,
+    # Seaborn methods (sns_ prefix)
+    "sns_barplot": _format_sns_barplot,
+    "sns_boxplot": _format_sns_boxplot,
+    "sns_heatmap": _format_sns_heatmap,
+    "sns_histplot": _format_sns_histplot,
+    "sns_jointplot": _format_sns_jointplot,
+    "sns_kdeplot": _format_sns_kdeplot,
+    "sns_lineplot": _format_sns_lineplot,
+    "sns_pairplot": _format_sns_pairplot,
+    "sns_scatterplot": _format_sns_scatterplot,
+    "sns_stripplot": _format_sns_stripplot,
+    "sns_swarmplot": _format_sns_swarmplot,
+    "sns_violinplot": _format_sns_violinplot,
+}
 
 
 def _to_numpy(data):
@@ -167,7 +218,7 @@ def export_as_csv(history_records):
             else:
                 message = (
                     f"Method '{method}()' does not support data tracking for CSV export. "
-                    f"Consider using scitex plot methods (e.g., plot_image, plot_imshow) for data export support."
+                    f"Consider using scitex plot methods (e.g., stx_image, plot_imshow) for data export support."
                 )
             _warn_once(message)
         return pd.DataFrame()
@@ -219,6 +270,8 @@ def format_record(record):
         return _format_boxplot(id, tracked_dict, kwargs)
     elif method == "contour":
         return _format_contour(id, tracked_dict, kwargs)
+    elif method == "contourf":
+        return _format_contourf(id, tracked_dict, kwargs)
     elif method == "errorbar":
         return _format_errorbar(id, tracked_dict, kwargs)
     elif method == "eventplot":
@@ -227,10 +280,26 @@ def format_record(record):
         return _format_fill(id, tracked_dict, kwargs)
     elif method == "fill_between":
         return _format_fill_between(id, tracked_dict, kwargs)
+    elif method == "hexbin":
+        return _format_hexbin(id, tracked_dict, kwargs)
+    elif method == "hist2d":
+        return _format_hist2d(id, tracked_dict, kwargs)
     elif method == "imshow":
         return _format_imshow(id, tracked_dict, kwargs)
     elif method == "imshow2d":
         return _format_imshow2d(id, tracked_dict, kwargs)
+    elif method == "matshow":
+        return _format_matshow(id, tracked_dict, kwargs)
+    elif method == "pie":
+        return _format_pie(id, tracked_dict, kwargs)
+    elif method == "quiver":
+        return _format_quiver(id, tracked_dict, kwargs)
+    elif method == "stem":
+        return _format_stem(id, tracked_dict, kwargs)
+    elif method == "step":
+        return _format_step(id, tracked_dict, kwargs)
+    elif method == "streamplot":
+        return _format_streamplot(id, tracked_dict, kwargs)
     elif method == "violin":
         return _format_violin(id, tracked_dict, kwargs)
     elif method == "violinplot":
@@ -241,46 +310,46 @@ def format_record(record):
         return _format_annotate(id, tracked_dict, kwargs)
 
     # Custom plotting functions
-    elif method == "plot_box":
+    elif method == "stx_box":
         return _format_plot_box(id, tracked_dict, kwargs)
-    elif method == "plot_conf_mat":
+    elif method == "stx_conf_mat":
         return _format_plot_conf_mat(id, tracked_dict, kwargs)
-    elif method == "plot_ecdf":
+    elif method == "stx_ecdf":
         return _format_plot_ecdf(id, tracked_dict, kwargs)
-    elif method == "plot_fillv":
+    elif method == "stx_fillv":
         return _format_plot_fillv(id, tracked_dict, kwargs)
-    elif method == "plot_heatmap":
+    elif method == "stx_heatmap":
         return _format_plot_heatmap(id, tracked_dict, kwargs)
-    elif method == "plot_image":
+    elif method == "stx_image":
         return _format_plot_image(id, tracked_dict, kwargs)
     elif method == "plot_imshow":
         return _format_plot_imshow(id, tracked_dict, kwargs)
-    elif method == "plot_joyplot":
+    elif method == "stx_joyplot":
         return _format_plot_joyplot(id, tracked_dict, kwargs)
-    elif method == "plot_kde":
+    elif method == "stx_kde":
         return _format_plot_kde(id, tracked_dict, kwargs)
-    elif method == "plot_line":
+    elif method == "stx_line":
         return _format_plot_line(id, tracked_dict, kwargs)
-    elif method == "plot_mean_ci":
+    elif method == "stx_mean_ci":
         return _format_plot_mean_ci(id, tracked_dict, kwargs)
-    elif method == "plot_mean_std":
+    elif method == "stx_mean_std":
         return _format_plot_mean_std(id, tracked_dict, kwargs)
-    elif method == "plot_median_iqr":
+    elif method == "stx_median_iqr":
         return _format_plot_median_iqr(id, tracked_dict, kwargs)
-    elif method == "plot_raster":
+    elif method == "stx_raster":
         return _format_plot_raster(id, tracked_dict, kwargs)
-    elif method == "plot_rectangle":
+    elif method == "stx_rectangle":
         return _format_plot_rectangle(id, tracked_dict, kwargs)
     elif method == "plot_scatter":
         return _format_plot_scatter(id, tracked_dict, kwargs)
-    elif method == "plot_scatter_hist":
+    elif method == "stx_scatter_hist":
         return _format_plot_scatter_hist(id, tracked_dict, kwargs)
-    elif method == "plot_shaded_line":
+    elif method == "stx_shaded_line":
         return _format_plot_shaded_line(id, tracked_dict, kwargs)
-    elif method == "plot_violin":
+    elif method == "stx_violin":
         return _format_plot_violin(id, tracked_dict, kwargs)
 
-    # Seaborn functions
+    # Seaborn functions (sns_ prefix)
     elif method == "sns_barplot":
         return _format_sns_barplot(id, tracked_dict, kwargs)
     elif method == "sns_boxplot":

scitex/plt/_subplots/_export_as_csv_formatters/__init__.py

@@ -18,37 +18,46 @@ from ._format_barh import _format_barh
 from ._format_hist import _format_hist
 from ._format_boxplot import _format_boxplot
 from ._format_contour import _format_contour
+from ._format_contourf import _format_contourf
 from ._format_errorbar import _format_errorbar
 from ._format_eventplot import _format_eventplot
 from ._format_fill import _format_fill
 from ._format_fill_between import _format_fill_between
+from ._format_hexbin import _format_hexbin
+from ._format_hist2d import _format_hist2d
 from ._format_imshow import _format_imshow
 from ._format_imshow2d import _format_imshow2d
+from ._format_matshow import _format_matshow
+from ._format_pie import _format_pie
+from ._format_quiver import _format_quiver
+from ._format_stem import _format_stem
+from ._format_step import _format_step
+from ._format_streamplot import _format_streamplot
 from ._format_violin import _format_violin
 from ._format_violinplot import _format_violinplot
 
 # Custom plotting formatters
 from ._format_plot_imshow import _format_plot_imshow
 from ._format_plot_box import _format_plot_box
-from ._format_plot_conf_mat import _format_plot_conf_mat
-from ._format_plot_ecdf import _format_plot_ecdf
-from ._format_plot_fillv import _format_plot_fillv
-from ._format_plot_heatmap import _format_plot_heatmap
-from ._format_plot_image import _format_plot_image
-from ._format_plot_joyplot import _format_plot_joyplot
+from ._format_stx_conf_mat import _format_plot_conf_mat
+from ._format_stx_ecdf import _format_plot_ecdf
+from ._format_stx_fillv import _format_plot_fillv
+from ._format_stx_heatmap import _format_plot_heatmap
+from ._format_stx_image import _format_plot_image
+from ._format_stx_joyplot import _format_plot_joyplot
 from ._format_plot_kde import _format_plot_kde
-from ._format_plot_line import _format_plot_line
-from ._format_plot_mean_ci import _format_plot_mean_ci
-from ._format_plot_mean_std import _format_plot_mean_std
-from ._format_plot_median_iqr import _format_plot_median_iqr
-from ._format_plot_raster import _format_plot_raster
-from ._format_plot_rectangle import _format_plot_rectangle
+from ._format_stx_line import _format_plot_line
+from ._format_stx_mean_ci import _format_plot_mean_ci
+from ._format_stx_mean_std import _format_plot_mean_std
+from ._format_stx_median_iqr import _format_plot_median_iqr
+from ._format_stx_raster import _format_plot_raster
+from ._format_stx_rectangle import _format_plot_rectangle
 from ._format_plot_scatter import _format_plot_scatter
-from ._format_plot_scatter_hist import _format_plot_scatter_hist
-from ._format_plot_shaded_line import _format_plot_shaded_line
-from ._format_plot_violin import _format_plot_violin
+from ._format_stx_scatter_hist import _format_plot_scatter_hist
+from ._format_stx_shaded_line import _format_plot_shaded_line
+from ._format_stx_violin import _format_plot_violin
 
-# Seaborn formatters
+# Seaborn formatters (sns_ prefix)
 from ._format_sns_barplot import _format_sns_barplot
 from ._format_sns_boxplot import _format_sns_boxplot
 from ._format_sns_heatmap import _format_sns_heatmap

scitex/plt/_subplots/_export_as_csv_formatters/_format_contourf.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-01 12:20:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/plt/_subplots/_export_as_csv_formatters/_format_contourf.py
+
+import numpy as np
+import pandas as pd
+
+
+def _format_contourf(id, tracked_dict, kwargs):
+    """Format data from a filled contour plot call.
+
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to contourf
+
+    Returns:
+        pd.DataFrame: Formatted data from contourf (flattened X, Y, Z grids)
+    """
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+
+    if 'args' in tracked_dict:
+        args = tracked_dict['args']
+        if isinstance(args, tuple):
+            # contourf can be called as:
+            # contourf(Z) - Z is 2D
+            # contourf(X, Y, Z) - X, Y are 1D or 2D, Z is 2D
+            if len(args) == 1:
+                Z = np.asarray(args[0])
+                X, Y = np.meshgrid(np.arange(Z.shape[1]), np.arange(Z.shape[0]))
+            elif len(args) >= 3:
+                X = np.asarray(args[0])
+                Y = np.asarray(args[1])
+                Z = np.asarray(args[2])
+                # If X, Y are 1D, create meshgrid
+                if X.ndim == 1 and Y.ndim == 1:
+                    X, Y = np.meshgrid(X, Y)
+            else:
+                return pd.DataFrame()
+
+            # Flatten all arrays
+            df = pd.DataFrame({
+                f"{id}_contourf_x": X.flatten(),
+                f"{id}_contourf_y": Y.flatten(),
+                f"{id}_contourf_z": Z.flatten()
+            })
+            return df
+
+    return pd.DataFrame()
+
+
+# EOF

scitex/plt/_subplots/_export_as_csv_formatters/_format_hexbin.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-01 12:20:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/plt/_subplots/_export_as_csv_formatters/_format_hexbin.py
+
+import numpy as np
+import pandas as pd
+
+
+def _format_hexbin(id, tracked_dict, kwargs):
+    """Format data from a hexbin call.
+
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to hexbin
+
+    Returns:
+        pd.DataFrame: Formatted data from hexbin (input x, y data)
+    """
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+
+    if 'args' in tracked_dict:
+        args = tracked_dict['args']
+        if isinstance(args, tuple) and len(args) >= 2:
+            x = np.asarray(args[0]).flatten()
+            y = np.asarray(args[1]).flatten()
+
+            # Ensure same length
+            min_len = min(len(x), len(y))
+            x = x[:min_len]
+            y = y[:min_len]
+
+            df = pd.DataFrame({f"{id}_hexbin_x": x, f"{id}_hexbin_y": y})
+            return df
+
+    return pd.DataFrame()
+
+
+# EOF

scitex/plt/_subplots/_export_as_csv_formatters/_format_hist2d.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-01 12:20:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/plt/_subplots/_export_as_csv_formatters/_format_hist2d.py
+
+import numpy as np
+import pandas as pd
+
+
+def _format_hist2d(id, tracked_dict, kwargs):
+    """Format data from a 2D histogram call.
+
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to hist2d
+
+    Returns:
+        pd.DataFrame: Formatted data from 2D histogram (input x, y data)
+    """
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+
+    if 'args' in tracked_dict:
+        args = tracked_dict['args']
+        if isinstance(args, tuple) and len(args) >= 2:
+            x = np.asarray(args[0]).flatten()
+            y = np.asarray(args[1]).flatten()
+
+            # Ensure same length
+            min_len = min(len(x), len(y))
+            x = x[:min_len]
+            y = y[:min_len]
+
+            df = pd.DataFrame({f"{id}_hist2d_x": x, f"{id}_hist2d_y": y})
+            return df
+
+    return pd.DataFrame()
+
+
+# EOF

scitex/plt/_subplots/_export_as_csv_formatters/_format_imshow.py

@@ -1,57 +1,69 @@
 #!/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__ = __file__
-__DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
+# Timestamp: "2025-12-01 12:40:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/plt/_subplots/_export_as_csv_formatters/_format_imshow.py
 
+import numpy as np
 import pandas as pd
 
+
 def _format_imshow(id, tracked_dict, kwargs):
-    """Format data from an imshow call."""
+    """Format data from an imshow call.
+
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to imshow
+
+    Returns:
+        pd.DataFrame: Formatted data from imshow (flattened image with row, col indices)
+    """
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
 
+    # Check for pre-formatted image_df (from plot_imshow wrapper)
     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()
+    # Handle raw args from __getattr__ proxied calls
+    if 'args' in tracked_dict:
+        args = tracked_dict['args']
+        if isinstance(args, tuple) and len(args) > 0:
+            img = np.asarray(args[0])
+
+            # Handle 2D grayscale image
+            if 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 (3D array)
+            elif 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 (R, G, B, A)
+                channel_names = ['R', 'G', 'B', 'A'][:channels]
+                for c, name in enumerate(channel_names):
+                    data[f"{id}_imshow_{name}"] = img[:, :, c].flatten()
+
+                return pd.DataFrame(data)
+
+    return pd.DataFrame()

scitex/plt/_subplots/_export_as_csv_formatters/_format_matshow.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-01 12:20:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/plt/_subplots/_export_as_csv_formatters/_format_matshow.py
+
+import numpy as np
+import pandas as pd
+
+
+def _format_matshow(id, tracked_dict, kwargs):
+    """Format data from a matshow call.
+
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to matshow
+
+    Returns:
+        pd.DataFrame: Formatted data from matshow (flattened matrix with row, col indices)
+    """
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+
+    if 'args' in tracked_dict:
+        args = tracked_dict['args']
+        if isinstance(args, tuple) and len(args) > 0:
+            Z = np.asarray(args[0])
+
+            # Create row/col indices
+            rows, cols = np.indices(Z.shape)
+
+            df = pd.DataFrame({
+                f"{id}_matshow_row": rows.flatten(),
+                f"{id}_matshow_col": cols.flatten(),
+                f"{id}_matshow_value": Z.flatten()
+            })
+            return df
+
+    return pd.DataFrame()
+
+
+# EOF

scitex/plt/_subplots/_export_as_csv_formatters/_format_pie.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-01 12:20:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/plt/_subplots/_export_as_csv_formatters/_format_pie.py
+
+import numpy as np
+import pandas as pd
+
+
+def _format_pie(id, tracked_dict, kwargs):
+    """Format data from a pie chart call.
+
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to pie
+
+    Returns:
+        pd.DataFrame: Formatted data from pie chart
+    """
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+
+    if 'args' in tracked_dict:
+        args = tracked_dict['args']
+        if isinstance(args, tuple) and len(args) > 0:
+            x = np.asarray(args[0])
+
+            data = {f"{id}_pie_values": x}
+
+            # Add labels if provided
+            labels = kwargs.get('labels', None)
+            if labels is not None:
+                data[f"{id}_pie_labels"] = labels
+
+            df = pd.DataFrame(data)
+            return df
+
+    return pd.DataFrame()
+
+
+# EOF