scitex 2.0.0__py2.py3-none-any.whl → 2.1.0__py2.py3-none-any.whl

scitex/plt/_subplots/_AxisWrapperMixins/_UnitAwareMixin.py

@@ -0,0 +1,322 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-08-01 10:35:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/SciTeX-Code/src/scitex/plt/_subplots/_AxisWrapperMixins/_UnitAwareMixin.py
+# ----------------------------------------
+
+"""
+Unit-Aware Plotting Mixin
+=========================
+
+This mixin adds unit handling capabilities to the AxisWrapper class,
+ensuring scientific validity in plots.
+
+Features:
+- Automatic unit tracking for axes
+- Unit validation for data compatibility
+- Automatic unit conversion
+- Unit-aware axis labels
+"""
+
+from typing import Optional, Dict, Tuple, Union, Any
+import numpy as np
+from ....units import Unit, Q, Units
+from ....errors import SciTeXError
+
+
+class UnitMismatchError(SciTeXError):
+    """Raised when units are incompatible for an operation."""
+    pass
+
+
+class UnitAwareMixin:
+    """Mixin that adds unit awareness to plotting operations."""
+    
+    def __init__(self):
+        """Initialize unit tracking."""
+        self._x_unit: Optional[Unit] = None
+        self._y_unit: Optional[Unit] = None
+        self._z_unit: Optional[Unit] = None
+        self._unit_validation_enabled: bool = True
+        
+    def set_unit_validation(self, enabled: bool) -> None:
+        """Enable or disable unit validation."""
+        self._unit_validation_enabled = enabled
+        
+    def set_x_unit(self, unit: Union[str, Unit]) -> None:
+        """Set the unit for the x-axis."""
+        if isinstance(unit, str):
+            unit_obj = getattr(Units, unit, None)
+            if unit_obj is None:
+                raise ValueError(f"Unknown unit: {unit}")
+            unit = unit_obj
+        self._x_unit = unit
+        self._update_xlabel_with_unit()
+        
+    def set_y_unit(self, unit: Union[str, Unit]) -> None:
+        """Set the unit for the y-axis."""
+        if isinstance(unit, str):
+            unit_obj = getattr(Units, unit, None)
+            if unit_obj is None:
+                raise ValueError(f"Unknown unit: {unit}")
+            unit = unit_obj
+        self._y_unit = unit
+        self._update_ylabel_with_unit()
+        
+    def set_z_unit(self, unit: Union[str, Unit]) -> None:
+        """Set the unit for the z-axis (for 3D plots)."""
+        if isinstance(unit, str):
+            unit_obj = getattr(Units, unit, None)
+            if unit_obj is None:
+                raise ValueError(f"Unknown unit: {unit}")
+            unit = unit_obj
+        self._z_unit = unit
+        self._update_zlabel_with_unit()
+        
+    def get_x_unit(self) -> Optional[Unit]:
+        """Get the current x-axis unit."""
+        return self._x_unit
+        
+    def get_y_unit(self) -> Optional[Unit]:
+        """Get the current y-axis unit."""
+        return self._y_unit
+        
+    def get_z_unit(self) -> Optional[Unit]:
+        """Get the current z-axis unit."""
+        return self._z_unit
+        
+    def _update_xlabel_with_unit(self) -> None:
+        """Update x-axis label to include unit."""
+        if self._x_unit and hasattr(self, '_axes_mpl'):
+            current_label = self._axes_mpl.get_xlabel()
+            # Remove existing unit if present
+            if '[' in current_label and ']' in current_label:
+                current_label = current_label.split('[')[0].strip()
+            if current_label:
+                self._axes_mpl.set_xlabel(f"{current_label} [{self._x_unit.symbol}]")
+                
+    def _update_ylabel_with_unit(self) -> None:
+        """Update y-axis label to include unit."""
+        if self._y_unit and hasattr(self, '_axes_mpl'):
+            current_label = self._axes_mpl.get_ylabel()
+            # Remove existing unit if present
+            if '[' in current_label and ']' in current_label:
+                current_label = current_label.split('[')[0].strip()
+            if current_label:
+                self._axes_mpl.set_ylabel(f"{current_label} [{self._y_unit.symbol}]")
+                
+    def _update_zlabel_with_unit(self) -> None:
+        """Update z-axis label to include unit (for 3D plots)."""
+        if self._z_unit and hasattr(self, '_axes_mpl') and hasattr(self._axes_mpl, 'set_zlabel'):
+            current_label = self._axes_mpl.get_zlabel()
+            # Remove existing unit if present
+            if '[' in current_label and ']' in current_label:
+                current_label = current_label.split('[')[0].strip()
+            if current_label:
+                self._axes_mpl.set_zlabel(f"{current_label} [{self._z_unit.symbol}]")
+                
+    def plot_with_units(self, x, y, x_unit=None, y_unit=None, **kwargs):
+        """Plot with automatic unit handling.
+        
+        Parameters
+        ----------
+        x : array-like or Quantity
+            X-axis data
+        y : array-like or Quantity
+            Y-axis data
+        x_unit : str or Unit, optional
+            Unit for x-axis (overrides detected unit)
+        y_unit : str or Unit, optional
+            Unit for y-axis (overrides detected unit)
+        **kwargs : dict
+            Additional plotting parameters
+            
+        Returns
+        -------
+        lines : list of Line2D
+            The plotted lines
+        """
+        # Extract values and units from Quantity objects
+        x_val, x_detected_unit = self._extract_value_and_unit(x)
+        y_val, y_detected_unit = self._extract_value_and_unit(y)
+        
+        # Use provided units or detected units
+        if x_unit:
+            self.set_x_unit(x_unit)
+        elif x_detected_unit and not self._x_unit:
+            self.set_x_unit(x_detected_unit)
+            
+        if y_unit:
+            self.set_y_unit(y_unit)
+        elif y_detected_unit and not self._y_unit:
+            self.set_y_unit(y_detected_unit)
+            
+        # Validate units if enabled
+        if self._unit_validation_enabled:
+            self._validate_unit_compatibility(x_detected_unit, self._x_unit, "x")
+            self._validate_unit_compatibility(y_detected_unit, self._y_unit, "y")
+            
+        # Plot using the standard method
+        return self.plot(x_val, y_val, **kwargs)
+        
+    def _extract_value_and_unit(self, data) -> Tuple[np.ndarray, Optional[Unit]]:
+        """Extract numerical value and unit from data."""
+        if hasattr(data, 'value') and hasattr(data, 'unit'):
+            # It's a Quantity object
+            return data.value, data.unit
+        else:
+            # Regular array
+            return np.asarray(data), None
+            
+    def _validate_unit_compatibility(self, data_unit: Optional[Unit], 
+                                   axis_unit: Optional[Unit], 
+                                   axis_name: str) -> None:
+        """Validate that data unit is compatible with axis unit."""
+        if not self._unit_validation_enabled:
+            return
+            
+        if data_unit and axis_unit:
+            # Check if units have same dimensions
+            if data_unit.dimensions != axis_unit.dimensions:
+                raise UnitMismatchError(
+                    f"Unit mismatch on {axis_name}-axis: "
+                    f"data has unit {data_unit.symbol} {data_unit.dimensions}, "
+                    f"but axis expects {axis_unit.symbol} {axis_unit.dimensions}"
+                )
+                
+    def convert_x_units(self, new_unit: Union[str, Unit], 
+                       update_data: bool = True) -> float:
+        """Convert x-axis to new units.
+        
+        Parameters
+        ----------
+        new_unit : str or Unit
+            Target unit
+        update_data : bool
+            Whether to update plotted data
+            
+        Returns
+        -------
+        float
+            Conversion factor applied
+        """
+        if isinstance(new_unit, str):
+            new_unit = getattr(Units, new_unit)
+            
+        if not self._x_unit:
+            raise ValueError("No x-axis unit set")
+            
+        # Calculate conversion factor
+        factor = self._x_unit.scale / new_unit.scale
+        
+        if update_data and hasattr(self, '_axes_mpl'):
+            # Update all line data
+            for line in self._axes_mpl.lines:
+                xdata = line.get_xdata()
+                line.set_xdata(xdata * factor)
+                
+            # Update x-axis limits
+            xlim = self._axes_mpl.get_xlim()
+            self._axes_mpl.set_xlim([x * factor for x in xlim])
+            
+        # Update unit
+        self.set_x_unit(new_unit)
+        
+        return factor
+        
+    def convert_y_units(self, new_unit: Union[str, Unit], 
+                       update_data: bool = True) -> float:
+        """Convert y-axis to new units.
+        
+        Parameters
+        ----------
+        new_unit : str or Unit
+            Target unit
+        update_data : bool
+            Whether to update plotted data
+            
+        Returns
+        -------
+        float
+            Conversion factor applied
+        """
+        if isinstance(new_unit, str):
+            new_unit = getattr(Units, new_unit)
+            
+        if not self._y_unit:
+            raise ValueError("No y-axis unit set")
+            
+        # Calculate conversion factor
+        factor = self._y_unit.scale / new_unit.scale
+        
+        if update_data and hasattr(self, '_axes_mpl'):
+            # Update all line data
+            for line in self._axes_mpl.lines:
+                ydata = line.get_ydata()
+                line.set_ydata(ydata * factor)
+                
+            # Update y-axis limits
+            ylim = self._axes_mpl.get_ylim()
+            self._axes_mpl.set_ylim([y * factor for y in ylim])
+            
+        # Update unit
+        self.set_y_unit(new_unit)
+        
+        return factor
+        
+    def set_xlabel(self, label: str, unit: Optional[Union[str, Unit]] = None) -> None:
+        """Set x-axis label with optional unit.
+        
+        Parameters
+        ----------
+        label : str
+            Axis label text
+        unit : str or Unit, optional
+            Unit to display
+        """
+        if unit:
+            self.set_x_unit(unit)
+            
+        if self._x_unit:
+            label = f"{label} [{self._x_unit.symbol}]"
+            
+        self._axes_mpl.set_xlabel(label)
+        
+    def set_ylabel(self, label: str, unit: Optional[Union[str, Unit]] = None) -> None:
+        """Set y-axis label with optional unit.
+        
+        Parameters
+        ----------
+        label : str
+            Axis label text
+        unit : str or Unit, optional
+            Unit to display
+        """
+        if unit:
+            self.set_y_unit(unit)
+            
+        if self._y_unit:
+            label = f"{label} [{self._y_unit.symbol}]"
+            
+        self._axes_mpl.set_ylabel(label)
+        
+    def set_zlabel(self, label: str, unit: Optional[Union[str, Unit]] = None) -> None:
+        """Set z-axis label with optional unit (for 3D plots).
+        
+        Parameters
+        ----------
+        label : str
+            Axis label text
+        unit : str or Unit, optional
+            Unit to display
+        """
+        if not hasattr(self._axes_mpl, 'set_zlabel'):
+            raise ValueError("Z-axis labels only available for 3D plots")
+            
+        if unit:
+            self.set_z_unit(unit)
+            
+        if self._z_unit:
+            label = f"{label} [{self._z_unit.symbol}]"
+            
+        self._axes_mpl.set_zlabel(label)

scitex/plt/_subplots/_AxisWrapperMixins/__init__.py

@@ -12,5 +12,6 @@ from ._AdjustmentMixin import AdjustmentMixin
 from ._MatplotlibPlotMixin import MatplotlibPlotMixin
 from ._SeabornMixin import SeabornMixin
 from ._TrackingMixin import TrackingMixin
+from ._UnitAwareMixin import UnitAwareMixin
 
 # EOF

scitex/plt/_subplots/_FigWrapper.py

@@ -18,6 +18,7 @@ import pandas as pd
 class FigWrapper:
     def __init__(self, fig_mpl):
         self._fig_mpl = fig_mpl
+        self._axes = []  # Keep track of axes for synchronization
         self._last_saved_info = None
         self._not_saved_yet_flag = True
         self._called_from_mng_io_save = False
@@ -36,7 +37,17 @@ class FigWrapper:
 
             @wraps(attr_mpl)
             def wrapper(*args, track=None, id=None, **kwargs):
-                results = attr_mpl(*args, **kwargs)
+                # Suppress constrained_layout warnings for certain operations
+                import warnings
+                with warnings.catch_warnings():
+                    if attr in ['subplots_adjust', 'tight_layout']:
+                        warnings.filterwarnings('ignore', 
+                                              message='.*constrained_layout.*',
+                                              category=UserWarning)
+                        warnings.filterwarnings('ignore',
+                                              message='.*layout engine.*incompatible.*',
+                                              category=UserWarning)
+                    results = attr_mpl(*args, **kwargs)
                 # self._track(track, id, attr, args, kwargs)
                 return results
 
@@ -96,15 +107,59 @@ class FigWrapper:
             if df is not None and not df.empty:
                 # Add axis ID prefix to column names if not already present
                 prefix = f"ax_{ii:02d}_"
-                df.columns = [
-                    col if col.startswith(prefix) else f"{prefix}{col}" 
-                    for col in df.columns
-                ]
+                # Make column names unique by appending index if there are duplicates
+                new_cols = []
+                col_counts = {}
+                for col in df.columns:
+                    # Convert to string and check if already has prefix
+                    col_str = str(col) if not (isinstance(col, str) and col.startswith(prefix)) else col
+                    if not col_str.startswith(prefix):
+                        col_str = f"{prefix}{col_str}"
+
+                    # Handle duplicates by adding a counter
+                    if col_str in col_counts:
+                        col_counts[col_str] += 1
+                        col_str = f"{col_str}_{col_counts[col_str]}"
+                    else:
+                        col_counts[col_str] = 0
+
+                    new_cols.append(col_str)
+
+                df.columns = new_cols
                 dfs.append(df)
         
         # Return concatenated DataFrame or empty DataFrame if no data
         return pd.concat(dfs, axis=1) if dfs else pd.DataFrame()
-    
+
+    def colorbar(self, mappable, ax=None, **kwargs):
+        """Add a colorbar to the figure, automatically unwrapping SciTeX axes.
+
+        This method properly handles both regular matplotlib axes and SciTeX
+        AxisWrapper objects when creating colorbars.
+
+        Parameters:
+        -----------
+        mappable : ScalarMappable
+            The image, contour set, etc. to which the colorbar applies
+        ax : Axes or AxisWrapper, optional
+            The axes to attach the colorbar to. If not specified, uses current axes.
+        **kwargs : dict
+            Additional keyword arguments passed to matplotlib's colorbar
+
+        Returns:
+        --------
+        Colorbar
+            The created colorbar object
+        """
+        # Unwrap axes if it's a SciTeX AxisWrapper
+        if ax is not None:
+            ax_mpl = ax._axis_mpl if hasattr(ax, '_axis_mpl') else ax
+        else:
+            ax_mpl = None
+
+        # Call matplotlib's colorbar with the unwrapped axes
+        return self._fig_mpl.colorbar(mappable, ax=ax_mpl, **kwargs)
+
     def _traverse_axes(self):
         """Helper method to traverse all axis wrappers in the figure."""
         if hasattr(self, 'axes'):
@@ -179,6 +234,7 @@ class FigWrapper:
                 # If both fail, do nothing - figure will use default layout
                 pass
 
+    
     def adjust_layout(self, **kwargs):
         """Adjust the constrained layout parameters.
         

scitex/plt/_subplots/_export_as_csv.py

@@ -1,25 +1,27 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Timestamp: "2025-05-18 18:14:08 (ywatanabe)"
+# Timestamp: "2025-09-21 01:52:22 (ywatanabe)"
 # File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/plt/_subplots/_export_as_csv.py
 # ----------------------------------------
+from __future__ import annotations
 import os
-
-__FILE__ = "./src/scitex/plt/_subplots/_export_as_csv.py"
+__FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
 import warnings
 
+import numpy as np
 import pandas as pd
+from scitex.pd import to_xyz
 
-from ._export_as_csv_formatters import (_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,
+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,
@@ -31,6 +33,7 @@ from ._export_as_csv_formatters import (_format_bar, _format_barh,
                                         _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,
@@ -45,30 +48,30 @@ from ._export_as_csv_formatters import (_format_bar, _format_barh,
                                         _format_sns_scatterplot,
                                         _format_sns_stripplot,
                                         _format_sns_swarmplot,
-                                        _format_sns_violinplot, _format_violin,
-                                        _format_violinplot)
-
-from scitex.pd import to_xyz
+                                        _format_sns_violinplot, _format_text,
+                                        _format_violin, _format_violinplot)
 
 
 def _to_numpy(data):
     """Convert various data types to numpy array.
-    
+
     Handles torch tensors, pandas Series/DataFrame, and other array-like objects.
-    
+
     Parameters
     ----------
     data : array-like
         Data to convert to numpy array
-        
+
     Returns
     -------
     numpy.ndarray
         Data as numpy array
     """
-    if hasattr(data, 'numpy'):  # torch tensor
-        return data.detach().numpy() if hasattr(data, 'detach') else data.numpy()
-    elif hasattr(data, 'values'):  # pandas series/dataframe
+    if hasattr(data, "numpy"):  # torch tensor
+        return (
+            data.detach().numpy() if hasattr(data, "detach") else data.numpy()
+        )
+    elif hasattr(data, "values"):  # pandas series/dataframe
         return data.values
     else:
         return np.asarray(data)
@@ -98,23 +101,30 @@ def export_as_csv(history_records):
                 dfs.append(formatted_df)
         except Exception as e:
             warnings.warn(f"Failed to format record {record[0]}: {e}")
-    
+
     # If no valid dataframes were created, return an empty one
     if not dfs:
         warnings.warn("No valid data found to export.")
         return pd.DataFrame()
 
     try:
-        df = pd.concat(dfs, axis=1)
+        # Reset index for each dataframe to avoid alignment issues
+        dfs_reset = [df.reset_index(drop=True) for df in dfs]
+        df = pd.concat(dfs_reset, axis=1)
         return df
     except Exception as e:
         warnings.warn(f"Failed to combine plotting records: {e}")
         # Return a DataFrame with metadata about what records were attempted
-        meta_df = pd.DataFrame({
-            "record_id": [r[0] for r in history_records.values()],
-            "method": [r[1] for r in history_records.values()],
-            "has_data": ["Yes" if r[2] and r[2] != {} else "No" for r in history_records.values()]
-        })
+        meta_df = pd.DataFrame(
+            {
+                "record_id": [r[0] for r in history_records.values()],
+                "method": [r[1] for r in history_records.values()],
+                "has_data": [
+                    "Yes" if r[2] and r[2] != {} else "No"
+                    for r in history_records.values()
+                ],
+            }
+        )
         return meta_df
 
 
@@ -160,6 +170,10 @@ def format_record(record):
         return _format_violin(id, tracked_dict, kwargs)
     elif method == "violinplot":
         return _format_violinplot(id, tracked_dict, kwargs)
+    elif method == "text":
+        return _format_text(id, tracked_dict, kwargs)
+    elif method == "annotate":
+        return _format_annotate(id, tracked_dict, kwargs)
 
     # Custom plotting functions
     elif method == "plot_box":
@@ -190,6 +204,8 @@ def format_record(record):
         return _format_plot_raster(id, tracked_dict, kwargs)
     elif method == "plot_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":
         return _format_plot_scatter_hist(id, tracked_dict, kwargs)
     elif method == "plot_shaded_line":

scitex/plt/_subplots/_export_as_csv_formatters/__init__.py

@@ -4,15 +4,15 @@
 # File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/plt/_subplots/_export_as_csv_formatters/__init__.py
 # ----------------------------------------
 import os
-__FILE__ = (
-    "./src/scitex/plt/_subplots/_export_as_csv_formatters/__init__.py"
-)
+__FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
 # Standard matplotlib formatters
 from ._format_plot import _format_plot
 from ._format_scatter import _format_scatter
+from ._format_text import _format_text
+from ._format_annotate import _format_annotate
 from ._format_bar import _format_bar
 from ._format_barh import _format_barh
 from ._format_hist import _format_hist
@@ -42,6 +42,7 @@ 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_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
@@ -58,4 +59,4 @@ from ._format_sns_pairplot import _format_sns_pairplot
 from ._format_sns_scatterplot import _format_sns_scatterplot
 from ._format_sns_stripplot import _format_sns_stripplot
 from ._format_sns_swarmplot import _format_sns_swarmplot
-from ._format_sns_violinplot import _format_sns_violinplot
+from ._format_sns_violinplot import _format_sns_violinplot

scitex/plt/_subplots/_export_as_csv_formatters/_format_annotate.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-04 02:30:00 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/SciTeX-Code/src/scitex/plt/_subplots/_export_as_csv_formatters/_format_annotate.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import pandas as pd
+
+
+def _make_column_name(id, suffix, method="annotate"):
+    """Create column name with method descriptor, avoiding duplication.
+
+    For example:
+    - id="annotate_0", suffix="x" -> "annotate_0_x"
+    - id="plot_5", suffix="x" -> "plot_5_annotate_x"
+    """
+    # Check if method name is already in the ID
+    id_parts = id.rsplit('_', 1)
+    if len(id_parts) == 2 and id_parts[0].endswith(method):
+        # Method already in ID, don't duplicate
+        return f"{id}_{suffix}"
+    else:
+        # Method not in ID, add it for clarity
+        return f"{id}_{method}_{suffix}"
+
+
+def _format_annotate(id, tracked_dict, kwargs):
+    """Format data from an annotate call.
+
+    matplotlib annotate signature: annotate(text, xy, xytext=None, **kwargs)
+    - text: The text of the annotation
+    - xy: The point (x, y) to annotate
+    - xytext: The position (x, y) to place the text at (optional)
+    """
+    # 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", [])
+
+    # Extract text and xy coordinates if available
+    if len(args) >= 2:
+        text_content = args[0]
+        xy = args[1]
+
+        # xy should be a tuple (x, y)
+        if hasattr(xy, '__len__') and len(xy) >= 2:
+            x, y = xy[0], xy[1]
+        else:
+            return pd.DataFrame()
+
+        data = {
+            _make_column_name(id, "x"): [x],
+            _make_column_name(id, "y"): [y],
+            _make_column_name(id, "content"): [text_content]
+        }
+
+        # Check if xytext was provided (either as third arg or in kwargs)
+        xytext = None
+        if len(args) >= 3:
+            xytext = args[2]
+        elif "xytext" in kwargs:
+            xytext = kwargs["xytext"]
+
+        if xytext is not None and hasattr(xytext, '__len__') and len(xytext) >= 2:
+            data[_make_column_name(id, "text_x")] = [xytext[0]]
+            data[_make_column_name(id, "text_y")] = [xytext[1]]
+
+        # Create DataFrame with proper column names (use dict with list values)
+        df = pd.DataFrame(data)
+        return df
+
+    return pd.DataFrame()
+
+# EOF