scitex 2.0.0__py2.py3-none-any.whl

scitex/pd/_to_xy.py

@@ -0,0 +1,59 @@
+#!/./env/bin/python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-09-03 07:01:31 (ywatanabe)"
+# ./src/scitex/pd/_to_xy.py
+
+import scitex
+import numpy as np
+import pandas as pd
+
+
+def to_xy(data_frame):
+    """
+    Convert a heatmap DataFrame into x, y, z format.
+
+    Ensure the index and columns are the same, and if either exists, replace with that.
+
+    Example
+    -------
+    data_frame = pd.DataFrame(...)  # Your DataFrame here
+    out = to_xy(data_frame)
+    print(out)
+
+    Parameters
+    ----------
+    data_frame : pandas.DataFrame
+        The input DataFrame to be converted.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A DataFrame formatted with columns ['x', 'y', 'z']
+    """
+    assert data_frame.shape[0] == data_frame.shape[1]
+
+    if not data_frame.index.equals(data_frame.columns):
+
+        if (data_frame.index == np.array(range(len(data_frame.index)))).all():
+            data_frame.columns = data_frame.index
+        elif (data_frame.columns == np.array(range(len(data_frame.columns)))).all():
+            data_frame.index = data_frame.columns
+        else:
+            ValueError
+        # else:
+        #     ValueError "Either of index or columns has to be passed"
+
+    formatted_data_frames = []
+
+    for column in data_frame.columns:
+        column_data_frame = data_frame[column]
+        y_label = column_data_frame.name
+        column_data_frame = pd.DataFrame(column_data_frame)
+        column_data_frame["x"] = column_data_frame.index
+        column_data_frame["y"] = y_label
+        column_data_frame = column_data_frame.reset_index().drop(columns=["index"])
+        column_data_frame = column_data_frame.rename(columns={y_label: "z"})
+        column_data_frame = scitex.pd.mv(column_data_frame, "z", -1)
+        formatted_data_frames.append(column_data_frame)
+
+    return pd.concat(formatted_data_frames, ignore_index=True)

scitex/pd/_to_xyz.py

@@ -0,0 +1,110 @@
+#!/./env/bin/python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-09-28 11:17:22 (ywatanabe)"
+# ./src/scitex/pd/_to_xyz.py
+
+import scitex
+import numpy as np
+import pandas as pd
+
+
+def to_xyz(data_frame):
+    """
+    Convert a DataFrame into x, y, z format (long format).
+
+    Transforms a DataFrame from wide format (matrix/heatmap) to long format
+    where each value becomes a row with x (row index), y (column name),
+    and z (value) columns.
+
+    Example
+    -------
+    data_frame = pd.DataFrame(...)  # Your DataFrame here
+    out = to_xyz(data_frame)
+    print(out)
+
+    Parameters
+    ----------
+    data_frame : pandas.DataFrame
+        The input DataFrame to be converted.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A DataFrame formatted with columns ['x', 'y', 'z']
+    """
+    x_name = data_frame.index.name or "x"
+    y_name = data_frame.columns.name or "y"
+
+    formatted_data_frames = []
+
+    for column in data_frame.columns:
+        column_data_frame = data_frame[column]
+        formatted_data = pd.DataFrame(
+            {
+                x_name: column_data_frame.index,
+                y_name: column,
+                "z": column_data_frame.values,
+            }
+        )
+        formatted_data_frames.append(formatted_data)
+
+    result = pd.concat(formatted_data_frames, ignore_index=True)
+
+    # Ensure column order is x, y, z
+    col_order = [x_name, y_name, "z"]
+    result = result[col_order]
+
+    return result
+
+
+# def to_xyz(data_frame):
+#     """
+#     Convert a heatmap DataFrame into x, y, z format.
+
+#     Ensure the index and columns are the same, and if either exists, replace with that.
+
+#     Example
+#     -------
+#     data_frame = pd.DataFrame(...)  # Your DataFrame here
+#     out = to_xy(data_frame)
+#     print(out)
+
+#     Parameters
+#     ----------
+#     data_frame : pandas.DataFrame
+#         The input DataFrame to be converted.
+
+#     Returns
+#     -------
+#     pandas.DataFrame
+#         A DataFrame formatted with columns ['x', 'y', 'z']
+#     """
+#     assert data_frame.shape[0] == data_frame.shape[1]
+
+#     if not data_frame.index.equals(data_frame.columns):
+
+#         if (data_frame.index == np.array(range(len(data_frame.index)))).all():
+#             data_frame.columns = data_frame.index
+#         elif (
+#             data_frame.columns == np.array(range(len(data_frame.columns)))
+#         ).all():
+#             data_frame.index = data_frame.columns
+#         else:
+#             raise ValueError("Either index or columns must be a range of integers")
+
+#     formatted_data_frames = []
+
+#     for column in data_frame.columns:
+#         column_data_frame = data_frame[column]
+#         y_label = column_data_frame.name
+#         column_data_frame = pd.DataFrame(column_data_frame)
+#         column_data_frame["x"] = column_data_frame.index
+#         column_data_frame["y"] = y_label
+#         column_data_frame = column_data_frame.reset_index().drop(
+#             columns=["index"]
+#         )
+#         column_data_frame = column_data_frame.rename(columns={y_label: "z"})
+#         column_data_frame = scitex.pd.mv(column_data_frame, "z", -1)
+#         formatted_data_frames.append(column_data_frame)
+
+#     return pd.concat(formatted_data_frames, ignore_index=True)

scitex/plt/__init__.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-06-13 22:42:39 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/SciTeX-Code/src/scitex/plt/__init__.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/__init__.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+"""Scitex plt module."""
+
+from ._tpl import termplot
+from . import color
+from . import utils
+
+# Lazy import for subplots to avoid circular dependencies
+_subplots = None
+
+def subplots(*args, **kwargs):
+    """Lazy-loaded subplots function."""
+    global _subplots
+    if _subplots is None:
+        from ._subplots._SubplotsWrapper import subplots as _subplots_impl
+        _subplots = _subplots_impl
+    return _subplots(*args, **kwargs)
+
+__all__ = [
+    "termplot",
+    "subplots",
+    "utils",
+    "color",
+]
+
+# EOF

scitex/plt/_subplots/_AxesWrapper.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-19 15:36:54 (ywatanabe)"
+# File: /ssh:ywatanabe@sp:/home/ywatanabe/proj/scitex_repo/src/scitex/plt/_subplots/_AxesWrapper.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_AxesWrapper.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+from functools import wraps
+
+import numpy as np
+import pandas as pd
+
+
+class AxesWrapper:
+    def __init__(self, fig_scitex, axes_scitex):
+        self._fig_scitex = fig_scitex
+        self._axes_scitex = axes_scitex
+
+    def get_figure(self, root=True):
+        """Get the figure, compatible with matplotlib 3.8+"""
+        return self._fig_scitex
+
+    def __dir__(self):
+        # Combine attributes from both self and the wrapped matplotlib axes
+        attrs = set(dir(self.__class__))
+        attrs.update(object.__dir__(self))
+
+        # Add attributes from the axes objects if available
+        if hasattr(self, "_axes_scitex") and self._axes_scitex is not None:
+            # Get attributes from the first axis if there are any
+            if self._axes_scitex.size > 0:
+                first_ax = self._axes_scitex.flat[0]
+                attrs.update(dir(first_ax))
+
+        return sorted(attrs)
+
+    def __getattr__(self, name):
+        # Note that self._axes_scitex is "numpy.ndarray"
+        # print(f"Attribute of AxesWrapper: {name}")
+        methods = []
+        try:
+            for axis in self._axes_scitex.flat:
+                methods.append(getattr(axis, name))
+        except Exception:
+            methods = []
+
+        if methods and all(callable(m) for m in methods):
+
+            @wraps(methods[0])
+            def wrapper(*args, **kwargs):
+                return [
+                    getattr(ax, name)(*args, **kwargs)
+                    for ax in self._axes_scitex.flat
+                ]
+
+            return wrapper
+
+        if methods and not callable(methods[0]):
+            return methods
+
+        def dummy(*args, **kwargs):
+            return None
+
+        return dummy
+
+    # def __getitem__(self, index):
+    #     subset = self._axes_scitex[index]
+    #     if isinstance(index, slice):
+    #         return AxesWrapper(self._fig_scitex, subset)
+    #     return subset
+
+    def __getitem__(self, index):
+        subset = self._axes_scitex[index]
+        if isinstance(subset, np.ndarray):
+            return AxesWrapper(self._fig_scitex, subset)
+        return subset
+
+    def __setitem__(self, index, value):
+        """Support item assignment for axes[row, col] = new_axis operations."""
+        self._axes_scitex[index] = value
+
+    def __iter__(self):
+        return iter(self._axes_scitex)
+
+    def __len__(self):
+        return self._axes_scitex.size
+
+    def __array__(self):
+        """Support conversion to numpy array.
+
+        This allows using np.array(axes) on an AxesWrapper instance, returning
+        a NumPy array with the same shape as the original axes array.
+
+        Notes:
+            - While this enables compatibility with NumPy functions, not all
+              operations will work correctly due to the nature of the wrapped
+              objects.
+            - For flattening operations, use the dedicated `flatten()` method
+              instead of `np.array(axes).flatten()`:
+
+                  # RECOMMENDED:
+                  flat_axes = list(axes.flatten())
+
+                  # AVOID (may cause "invalid __array_struct__" error):
+                  flat_axes = np.array(axes).flatten()
+
+        Returns:
+            np.ndarray: Array of wrapped axes with the same shape
+        """
+        import warnings
+
+        # Show a warning to help users avoid common mistakes
+        warnings.warn(
+            "Converting AxesWrapper to numpy array. If you're trying to flatten "
+            "the axes, use 'list(axes.flatten())' instead of 'np.array(axes).flatten()'.",
+            UserWarning,
+            stacklevel=2,
+        )
+
+        # Convert the underlying axes to a compatible numpy array representation
+        flat_axes = [ax for ax in self._axes_scitex.flat]
+        array_compatible = np.empty(len(flat_axes), dtype=object)
+        for idx, ax in enumerate(flat_axes):
+            array_compatible[idx] = ax
+        return array_compatible.reshape(self._axes_scitex.shape)
+
+    def legend(self, loc="upper left"):
+        return [ax.legend(loc=loc) for ax in self._axes_scitex.flat]
+
+    @property
+    def history(self):
+        return [ax.history for ax in self._axes_scitex.flat]
+
+    @property
+    def shape(self):
+        return self._axes_scitex.shape
+
+    @property
+    def flat(self):
+        """Return a flat iterator over all axes.
+        
+        This property provides direct access to the flattened axes array,
+        matching numpy array behavior.
+        
+        Returns:
+            Iterator over all axes in row-major (C-style) order
+        """
+        return self._axes_scitex.flat
+
+    def flatten(self):
+        """Return a flattened array of all axes in the AxesWrapper.
+
+        This method collects all axes from the flat iterator and returns them
+        as a NumPy array. This ensures compatibility with code that expects
+        a flat collection of axes.
+
+        Returns:
+            np.ndarray: A flattened array containing all axes
+
+        Example:
+            # Preferred way to get a list of all axes:
+            axes_list = list(axes.flatten())
+
+            # Alternatively, if you need a NumPy array:
+            axes_array = axes.flatten()
+        """
+        return np.array([ax for ax in self._axes_scitex.flat])
+
+    def export_as_csv(self):
+        dfs = []
+        for ii, ax in enumerate(self._axes_scitex.flat):
+            df = ax.export_as_csv()
+            df.columns = [f"ax_{ii:02d}_{col}" for col in df.columns]
+            dfs.append(df)
+        return pd.concat(dfs, axis=1) if dfs else pd.DataFrame()
+
+# EOF

scitex/plt/_subplots/_AxisWrapper.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-01 17:11:28 (ywatanabe)"
+# File: /home/ywatanabe/proj/_scitex_repo/src/scitex/plt/_subplots/_AxisWrapper.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/_subplots/_AxisWrapper.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import warnings
+from functools import wraps
+
+import matplotlib
+
+from ._AxisWrapperMixins import (
+    AdjustmentMixin,
+    MatplotlibPlotMixin,
+    SeabornMixin,
+    TrackingMixin,
+)
+
+
+class AxisWrapper(MatplotlibPlotMixin, SeabornMixin, AdjustmentMixin, TrackingMixin):
+    def __init__(self, fig_scitex, axis_mpl, track):
+        """Initialize the AxisWrapper.
+        
+        Args:
+            fig_scitex: Parent figure wrapper
+            axis_mpl: Matplotlib axis to wrap
+            track: Whether to track plotting operations
+        """
+        self._fig_mpl = fig_scitex._fig_mpl
+        # Axis Properties
+        # self.axis = axis_mpl
+        # self._axis = axis_mpl
+        # self._axis_scitex = self
+        self._axis_mpl = axis_mpl
+
+        # Axes Properties
+        # self.axes = axis_mpl
+        # self._axes = axis_mpl
+        self._axes_mpl = axis_mpl
+        # self._axes_scitex = self
+
+        # Tracking properties
+        self._ax_history = {}
+        self._method_counters = {}  # Track method counts for auto-generated IDs
+        self.track = track
+        self.id = 0
+        self._counter_part = matplotlib.axes.Axes
+
+    def get_figure(self, root=True):
+        """Get the figure, compatible with matplotlib 3.8+"""
+        return self._fig_mpl
+    
+    def twinx(self):
+        """Create a twin y-axis and wrap it with AxisWrapper."""
+        twin_ax = self._axes_mpl.twinx()
+        # Create a mock figure wrapper for the twin axis
+        class MockFigWrapper:
+            def __init__(self, fig_mpl):
+                self._fig_mpl = fig_mpl
+        mock_fig = MockFigWrapper(self._fig_mpl)
+        return AxisWrapper(fig_scitex=mock_fig, axis_mpl=twin_ax, track=self.track)
+    
+    def twiny(self):
+        """Create a twin x-axis and wrap it with AxisWrapper."""
+        twin_ax = self._axes_mpl.twiny()
+        # Create a mock figure wrapper for the twin axis
+        class MockFigWrapper:
+            def __init__(self, fig_mpl):
+                self._fig_mpl = fig_mpl
+        mock_fig = MockFigWrapper(self._fig_mpl)
+        return AxisWrapper(fig_scitex=mock_fig, axis_mpl=twin_ax, track=self.track)
+
+    def __getattr__(self, name):
+        # 0. Check if the attribute is explicitly defined in AxisWrapper or its Mixins
+        #    This check happens implicitly before __getattr__ is called.
+        #    If a method like `plot` is defined in BasicPlotMixin, it will be found first.
+
+        # print(f"Attribute of AxisWrapper: {name}")
+
+        # 1. Try to get the attribute from the wrapped axes instance
+        if hasattr(self._axes_mpl, name):
+            orig_attr = getattr(self._axes_mpl, name)
+
+            if callable(orig_attr):
+
+                @wraps(orig_attr)
+                def wrapper(*args, **kwargs):
+                    id_value = kwargs.pop("id", None)
+                    track_override = kwargs.pop("track", None)
+
+                    # Call the original matplotlib method
+                    result = orig_attr(*args, **kwargs)
+
+                    # Determine if tracking should occur
+                    should_track = (
+                        track_override if track_override is not None else self.track
+                    )
+
+                    # Track the method call if tracking enabled
+                    # Expanded list of matplotlib plotting methods to track
+                    tracking_methods = {
+                        # Basic plots
+                        'plot', 'scatter', 'bar', 'barh', 'hist', 'boxplot', 'violinplot',
+                        # Line plots
+                        'fill_between', 'fill_betweenx', 'errorbar', 'step', 'stem',
+                        # Statistical plots  
+                        'hist2d', 'hexbin', 'pie',
+                        # Contour plots
+                        'contour', 'contourf', 'tricontour', 'tricontourf',
+                        # Image plots
+                        'imshow', 'matshow', 'spy',
+                        # Quiver plots
+                        'quiver', 'streamplot',
+                        # 3D-related (if axes3d)
+                        'plot3D', 'scatter3D', 'bar3d', 'plot_surface', 'plot_wireframe',
+                        # Text and annotations (data-containing)
+                        'annotate', 'text'
+                    }
+                    if should_track and name in tracking_methods:
+                        # Use the _track method from TrackingMixin
+                        # If no id provided, it will auto-generate one
+                        try:
+                            # Convert args to tracked_dict for consistency with other tracking
+                            tracked_dict = {"args": args}
+                            self._track(
+                                should_track, id_value, name, tracked_dict, kwargs
+                            )
+                        except AttributeError:
+                            warnings.warn(
+                                f"Tracking setup incomplete for AxisWrapper ({name}).",
+                                UserWarning,
+                                stacklevel=2,
+                            )
+                        except Exception as e:
+                            # Silently continue if tracking fails to not break plotting
+                            pass
+                    return result  # Return the result of the original call
+
+                return wrapper
+            else:
+                # If it's a non-callable attribute (property, etc.), return it directly
+                return orig_attr
+
+        # 2. If not found on instance, try the counterpart type (fallback)
+        if hasattr(self._counter_part, name):
+            counterpart_attr = getattr(self._counter_part, name)
+            warnings.warn(
+                f"SciTeX Axis_MplWrapper: '{name}' not directly handled. "
+                f"Falling back to underlying '{self._counter_part.__name__}' attribute.",
+                UserWarning,
+                stacklevel=2,
+            )
+            # If the counterpart attribute is callable (likely a method descriptor)
+            if callable(counterpart_attr):
+                # Return a new function that calls the counterpart method on self._axes_mpl
+                @wraps(counterpart_attr)
+                def fallback_method(*args, **kwargs):
+                    # Note: No id/track handling for fallback methods
+                    return counterpart_attr(self._axes_mpl, *args, **kwargs)
+
+                return fallback_method
+            else:
+                # Non-callable class attribute. Attempt to get from instance again,
+                # otherwise return the class attribute/descriptor.
+                try:
+                    return getattr(self._axes_mpl, name)
+                except AttributeError:
+                    return counterpart_attr
+
+        # 3. If not found anywhere, raise AttributeError
+        raise AttributeError(
+            f"'{type(self).__name__}' object and its underlying '{self._counter_part.__name__}' "
+            f"have no attribute '{name}'"
+        )
+
+    def __dir__(self):
+        # Start with attributes from the class and all parent classes (mixins)
+        attrs = set()
+        
+        # Get attributes from all parent classes including mixins
+        for cls in self.__class__.__mro__:
+            attrs.update(cls.__dict__.keys())
+        
+        # Add instance attributes
+        attrs.update(self.__dict__.keys())
+        
+        # Safely get matplotlib axes attributes
+        try:
+            # Get attributes from the wrapped matplotlib axes
+            if hasattr(self._axes_mpl, '__class__'):
+                # Get class methods from matplotlib.axes.Axes
+                for cls in self._axes_mpl.__class__.__mro__:
+                    attrs.update(name for name in cls.__dict__.keys() if not name.startswith('_'))
+            
+            # Add instance attributes of the matplotlib axes
+            if hasattr(self._axes_mpl, '__dict__'):
+                attrs.update(name for name in self._axes_mpl.__dict__.keys() if not name.startswith('_'))
+                
+        except Exception:
+            # If any error occurs, add common matplotlib methods manually
+            attrs.update(['plot', 'scatter', 'bar', 'barh', 'hist', 'boxplot', 
+                         'set_xlabel', 'set_ylabel', 'set_title', 'legend',
+                         'set_xlim', 'set_ylim', 'grid', 'annotate', 'text'])
+        
+        # Remove private attributes
+        attrs = {attr for attr in attrs if not attr.startswith('_')}
+        
+        return sorted(attrs)
+        
+    def flatten(self):
+        """Return a list containing just this axis.
+        
+        This method makes AxisWrapper compatible with code that calls flatten()
+        on an axes collection. It returns a list containing just this single axis
+        to maintain consistency with AxesWrapper.flatten().
+        
+        Returns:
+            list: A list containing this axis wrapper
+            
+        Example:
+            # When working with either AxesWrapper or AxisWrapper, this works:
+            axes_list = list(axes.flatten())
+        """
+        return [self]
+
+
+"""
+import matplotlib.pyplot as plt
+import scitex.plt as mplt
+
+fig_scitex, axes = plt.subplots(ncols=2)
+mfig_scitex, maxes = mplt.subplots(ncols=2)
+
+print(set(dir(mfig_scitex)) - set(dir(fig_scitex)))
+print(set(dir(maxes)) - set(dir(axes)))
+
+is_compatible = np.all([kk in set(dir(msubplots)) for kk in set(dir(counter_part))])
+if is_compatible:
+    print(f"{msubplots.__name__} is compatible with {counter_part.__name__}")
+else:
+    print(f"{msubplots.__name__} is incompatible with {counter_part.__name__}")
+"""
+
+# EOF