scitex 2.8.1__py3-none-any.whl → 2.10.0__py3-none-any.whl

scitex/plt/_subplots/_export_as_csv.py

@@ -76,6 +76,8 @@ from ._export_as_csv_formatters import (
     _format_eventplot,
     _format_fill,
     _format_fill_between,
+    _format_stackplot,
+    _format_pcolormesh,
     _format_hexbin,
     _format_hist,
     _format_hist2d,
@@ -147,6 +149,9 @@ _FORMATTER_REGISTRY = {
     "eventplot": _format_eventplot,
     "fill": _format_fill,
     "fill_between": _format_fill_between,
+    "stackplot": _format_stackplot,
+    "pcolormesh": _format_pcolormesh,
+    "pcolor": _format_pcolormesh,
     "hexbin": _format_hexbin,
     "hist": _format_hist,
     "hist2d": _format_hist2d,
@@ -337,6 +342,12 @@ def format_record(record, record_index=0):
         return _format_fill(id, tracked_dict, kwargs)
     elif method == "fill_between":
         return _format_fill_between(id, tracked_dict, kwargs)
+    elif method == "stackplot":
+        return _format_stackplot(id, tracked_dict, kwargs)
+    elif method == "pcolormesh":
+        return _format_pcolormesh(id, tracked_dict, kwargs)
+    elif method == "pcolor":
+        return _format_pcolormesh(id, tracked_dict, kwargs)
     elif method == "hexbin":
         return _format_hexbin(id, tracked_dict, kwargs)
     elif method == "hist2d":

scitex/plt/_subplots/_export_as_csv_formatters/__init__.py

@@ -24,6 +24,8 @@ 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_stackplot import _format_stackplot
+from ._format_pcolormesh import _format_pcolormesh
 from ._format_hexbin import _format_hexbin
 from ._format_hist2d import _format_hist2d
 from ._format_imshow import _format_imshow

scitex/plt/_subplots/_export_as_csv_formatters/_format_pcolormesh.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-21 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/plt/_subplots/_export_as_csv_formatters/_format_pcolormesh.py
+
+import numpy as np
+import pandas as pd
+
+from scitex.plt.utils._csv_column_naming import get_csv_column_name
+from ._format_plot import _parse_tracking_id
+
+
+def _format_pcolormesh(id, tracked_dict, kwargs):
+    """Format data from a pcolormesh call.
+
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to pcolormesh
+
+    Returns:
+        pd.DataFrame: Formatted data from pcolormesh (x, y, value columns)
+    """
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+
+    # Parse tracking ID to get axes position and trace ID
+    ax_row, ax_col, trace_id = _parse_tracking_id(id)
+
+    args = tracked_dict.get("args", ())
+
+    if len(args) == 0:
+        return pd.DataFrame()
+
+    # pcolormesh can be called as:
+    # pcolormesh(C) - just color values
+    # pcolormesh(X, Y, C) - with coordinates
+    if len(args) == 1:
+        # Just C provided
+        C = np.asarray(args[0])
+        rows, cols = C.shape
+        Y, X = np.meshgrid(range(rows), range(cols), indexing="ij")
+    elif len(args) >= 3:
+        # X, Y, C provided
+        X = np.asarray(args[0])
+        Y = np.asarray(args[1])
+        C = np.asarray(args[2])
+    else:
+        return pd.DataFrame()
+
+    # Get column names
+    col_x = get_csv_column_name("x", ax_row, ax_col, trace_id=trace_id)
+    col_y = get_csv_column_name("y", ax_row, ax_col, trace_id=trace_id)
+    col_value = get_csv_column_name("value", ax_row, ax_col, trace_id=trace_id)
+
+    # Flatten for CSV format
+    df = pd.DataFrame({
+        col_x: X.flatten(),
+        col_y: Y.flatten(),
+        col_value: C.flatten(),
+    })
+
+    return df
+
+
+# EOF

scitex/plt/_subplots/_export_as_csv_formatters/_format_stackplot.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-21 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/plt/_subplots/_export_as_csv_formatters/_format_stackplot.py
+
+import numpy as np
+import pandas as pd
+
+from scitex.plt.utils._csv_column_naming import get_csv_column_name
+from ._format_plot import _parse_tracking_id
+
+
+def _format_stackplot(id, tracked_dict, kwargs):
+    """Format data from a stackplot call.
+
+    Args:
+        id (str): Identifier for the plot
+        tracked_dict (dict): Dictionary containing tracked data
+        kwargs (dict): Keyword arguments passed to stackplot
+
+    Returns:
+        pd.DataFrame: Formatted data from stackplot (x and multiple y columns)
+    """
+    if not tracked_dict or not isinstance(tracked_dict, dict):
+        return pd.DataFrame()
+
+    # Parse tracking ID to get axes position and trace ID
+    ax_row, ax_col, trace_id = _parse_tracking_id(id)
+
+    args = tracked_dict.get("args", ())
+
+    # stackplot(x, y1, y2, y3, ...) or stackplot(x, [y1, y2, y3], ...)
+    if len(args) < 2:
+        return pd.DataFrame()
+
+    x = np.asarray(args[0])
+    col_x = get_csv_column_name("x", ax_row, ax_col, trace_id=trace_id)
+    data = {col_x: x}
+
+    # Get labels from kwargs if available
+    labels = kwargs.get("labels", [])
+
+    # Handle remaining args as y arrays
+    y_arrays = args[1:]
+
+    # If first y arg is a 2D array, treat rows as separate series
+    if len(y_arrays) == 1 and hasattr(y_arrays[0], "ndim"):
+        y_data = np.asarray(y_arrays[0])
+        if y_data.ndim == 2:
+            y_arrays = [y_data[i] for i in range(y_data.shape[0])]
+
+    for i, y in enumerate(y_arrays):
+        y = np.asarray(y)
+        # Use label if available, otherwise use index
+        label = labels[i] if i < len(labels) else f"y{i:02d}"
+        col_y = get_csv_column_name(label, ax_row, ax_col, trace_id=trace_id)
+        data[col_y] = y
+
+    return pd.DataFrame(data)
+
+
+# EOF

scitex/plt/_subplots/_export_as_csv_formatters/test_formatters.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-18 22:05:10 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/plt/_subplots/_export_as_csv_formatters/test_formatters.py
+# ----------------------------------------
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import unittest
+import numpy as np
+import pandas as pd
+
+# Import formatters directly
+from ._format_plot import _format_plot
+from ._format_plot_kde import _format_plot_kde
+from ._format_plot_ecdf import _format_plot_ecdf
+from ._format_plot_heatmap import _format_plot_heatmap
+from ._format_plot_violin import _format_plot_violin
+from ._format_plot_shaded_line import _format_plot_shaded_line
+from ._format_plot_scatter_hist import _format_plot_scatter_hist
+
+
+class FormattersTest(unittest.TestCase):
+    """Test the formatter functions."""
+
+    def test_format_plot_kde(self):
+        """Test _format_plot_kde function."""
+        # Test case 1: Normal input
+        tracked_dict = {
+            'x': np.linspace(-3, 3, 100),
+            'kde': np.exp(-np.linspace(-3, 3, 100)**2/2),
+            'n': 500
+        }
+        id = 'test_kde'
+        df = _format_plot_kde(id, tracked_dict, {})
+        
+        # Verify columns
+        self.assertIn(f"{id}_kde_x", df.columns)
+        self.assertIn(f"{id}_kde_density", df.columns)
+        self.assertIn(f"{id}_kde_n", df.columns)
+        
+        # Test case 2: Empty tracked_dict
+        df = _format_plot_kde(id, {}, {})
+        self.assertTrue(df.empty)
+        
+        # Test case 3: Missing 'x' key
+        tracked_dict = {'kde': np.exp(-np.linspace(-3, 3, 100)**2/2)}
+        df = _format_plot_kde(id, tracked_dict, {})
+        self.assertTrue(df.empty)
+
+    def test_format_plot(self):
+        """Test _format_plot function."""
+        # Test case 1: Normal input
+        tracked_dict = {
+            'plot_df': pd.DataFrame({
+                'x': np.linspace(0, 10, 100),
+                'y': np.sin(np.linspace(0, 10, 100))
+            })
+        }
+        id = 'test_plot'
+        df = _format_plot(id, tracked_dict, {})
+        
+        # Verify it returned the DataFrame with added prefix
+        self.assertFalse(df.empty)
+        
+        # Test case 2: Empty tracked_dict
+        df = _format_plot(id, {}, {})
+        self.assertTrue(df.empty)
+
+    def test_format_plot_ecdf(self):
+        """Test _format_plot_ecdf function."""
+        # Test case 1: Normal input
+        tracked_dict = {
+            'ecdf_df': pd.DataFrame({
+                'x': np.linspace(-3, 3, 100),
+                'ecdf': np.linspace(0, 1, 100)
+            })
+        }
+        id = 'test_ecdf'
+        df = _format_plot_ecdf(id, tracked_dict, {})
+        
+        # Verify it returned the DataFrame
+        self.assertFalse(df.empty)
+        
+        # Test case 2: Empty tracked_dict
+        df = _format_plot_ecdf(id, {}, {})
+        self.assertTrue(df.empty)
+
+    def test_format_plot_heatmap(self):
+        """Test _format_plot_heatmap function."""
+        # Test case 1: Normal input with labels
+        data = np.random.rand(3, 4)
+        x_labels = ['A', 'B', 'C']
+        y_labels = ['W', 'X', 'Y', 'Z']
+        
+        tracked_dict = {
+            'data': data,
+            'x_labels': x_labels,
+            'y_labels': y_labels
+        }
+        id = 'test_heatmap'
+        df = _format_plot_heatmap(id, tracked_dict, {})
+        
+        # Verify it returned the DataFrame with the expected shape
+        self.assertFalse(df.empty)
+        self.assertEqual(df.shape[0], 12)  # 3 rows * 4 columns = 12 cells
+        # We should have 5 columns: row, col, value, row_label, col_label
+        self.assertEqual(df.shape[1], 5)
+        
+        # Test case 2: No labels
+        tracked_dict = {'data': data}
+        df = _format_plot_heatmap(id, tracked_dict, {})
+        self.assertFalse(df.empty)
+        
+        # Test case 3: Empty tracked_dict
+        df = _format_plot_heatmap(id, {}, {})
+        self.assertTrue(df.empty)
+
+    def test_format_plot_violin(self):
+        """Test _format_plot_violin function."""
+        # Test case 1: List data
+        data = [np.random.normal(0, 1, 100), np.random.normal(2, 1, 100)]
+        labels = ['Group A', 'Group B']
+        
+        tracked_dict = {
+            'data': data,
+            'labels': labels
+        }
+        id = 'test_violin'
+        df = _format_plot_violin(id, tracked_dict, {})
+        
+        # Verify it returned the DataFrame
+        self.assertFalse(df.empty)
+        
+        # Test case 2: DataFrame data
+        data_df = pd.DataFrame({
+            'values': np.concatenate([np.random.normal(0, 1, 100), np.random.normal(2, 1, 100)]),
+            'group': ['A'] * 100 + ['B'] * 100
+        })
+        tracked_dict = {
+            'data': data_df,
+            'x': 'group',
+            'y': 'values'
+        }
+        df = _format_plot_violin(id, tracked_dict, {})
+        self.assertFalse(df.empty)
+        
+        # Test case 3: Empty tracked_dict
+        df = _format_plot_violin(id, {}, {})
+        self.assertTrue(df.empty)
+
+    def test_format_plot_shaded_line(self):
+        """Test _format_plot_shaded_line function."""
+        # Test case 1: Normal input
+        tracked_dict = {
+            'plot_df': pd.DataFrame({
+                'x': np.linspace(0, 10, 100),
+                'y_lower': np.sin(np.linspace(0, 10, 100)) - 0.2,
+                'y_middle': np.sin(np.linspace(0, 10, 100)),
+                'y_upper': np.sin(np.linspace(0, 10, 100)) + 0.2
+            })
+        }
+        id = 'test_shaded'
+        df = _format_plot_shaded_line(id, tracked_dict, {})
+        
+        # Verify it returned the DataFrame
+        self.assertFalse(df.empty)
+        
+        # Test case 2: Empty tracked_dict
+        df = _format_plot_shaded_line(id, {}, {})
+        self.assertTrue(df.empty)
+
+    def test_format_plot_scatter_hist(self):
+        """Test _format_plot_scatter_hist function."""
+        # Test case 1: Normal input
+        tracked_dict = {
+            'x': np.random.normal(0, 1, 100),
+            'y': np.random.normal(0, 1, 100),
+            'hist_x': np.random.rand(10),
+            'hist_y': np.random.rand(10),
+            'bin_edges_x': np.linspace(-3, 3, 11),
+            'bin_edges_y': np.linspace(-3, 3, 11)
+        }
+        id = 'test_scatter_hist'
+        df = _format_plot_scatter_hist(id, tracked_dict, {})
+        
+        # Verify it returned the DataFrame with expected columns
+        self.assertFalse(df.empty)
+        self.assertTrue(any(col.startswith(f"{id}_scatter_hist_x") for col in df.columns))
+        self.assertTrue(any(col.startswith(f"{id}_scatter_hist_y") for col in df.columns))
+        
+        # Test case 2: Missing keys
+        tracked_dict = {
+            'x': np.random.normal(0, 1, 100),
+            'y': np.random.normal(0, 1, 100)
+        }
+        df = _format_plot_scatter_hist(id, tracked_dict, {})
+        self.assertFalse(df.empty)  # Should still work with just x,y
+        
+        # Test case 3: Empty tracked_dict
+        df = _format_plot_scatter_hist(id, {}, {})
+        self.assertTrue(df.empty)
+
+
+if __name__ == '__main__':
+    unittest.main()

scitex/plt/_subplots/_fonts.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Font configuration for matplotlib figures."""
+
+import os
+
+import matplotlib as mpl
+import matplotlib.font_manager as fm
+
+
+def configure_arial_font():
+    """Configure Arial font for matplotlib if available.
+
+    Returns
+    -------
+    bool
+        True if Arial was successfully configured, False otherwise.
+    """
+    arial_enabled = False
+
+    # Try to find Arial
+    try:
+        fm.findfont("Arial", fallback_to_default=False)
+        arial_enabled = True
+    except Exception:
+        # Search for Arial font files and register them
+        arial_paths = [
+            f
+            for f in fm.findSystemFonts()
+            if os.path.basename(f).lower().startswith("arial")
+        ]
+
+        if arial_paths:
+            for path in arial_paths:
+                try:
+                    fm.fontManager.addfont(path)
+                except Exception:
+                    pass
+
+            # Verify Arial is now available
+            try:
+                fm.findfont("Arial", fallback_to_default=False)
+                arial_enabled = True
+            except Exception:
+                pass
+
+    # Configure matplotlib to use Arial if available
+    if arial_enabled:
+        mpl.rcParams["font.family"] = "Arial"
+        mpl.rcParams["font.sans-serif"] = [
+            "Arial",
+            "Helvetica",
+            "DejaVu Sans",
+            "Liberation Sans",
+        ]
+    else:
+        # Warn about missing Arial
+        from scitex import logging as _logging
+
+        _logger = _logging.getLogger(__name__)
+        _logger.warning(
+            "Arial font not found. Using fallback fonts (Helvetica/DejaVu Sans). "
+            "For publication figures with Arial: sudo apt-get install ttf-mscorefonts-installer && fc-cache -fv"
+        )
+
+    return arial_enabled
+
+
+# Configure fonts at module import
+_arial_enabled = configure_arial_font()
+
+# EOF