fix(draw): Resolve Subframe.column references in draw()

BUG_AliasDataFrame_20260324_draw_subframe_resolution

draw() failed with ValueError when using Subframe.column syntax
(e.g., 'Side.dy:row') because dfdraw's df.eval() interprets dots
as attribute access. Also failed when subframe columns share names
with main frame columns (auto_alias_subframe skips them).

Fix: draw() detects Subframe.column patterns in expr, selection,
and group_by, materializes them as temporary columns with underscore
names (Side_dy) via join indices, rewrites expressions to match.

5 new tests, 1377 passed, 7 failed (pre-existing), no regressions.

Author: miranov25

UTILS/dfextensions/AliasDataFrame/AliasDataFrame.py

@@ -9978,6 +9978,50 @@ def draw(self,
             df_subset = self.df
             cleanup_needed = not effective_keep
 
+        # =================================================================
+        # Subframe column resolution for draw
+        # Detect 'Subframe.column' patterns in expression and selection,
+        # materialize them as temporary columns so dfdraw can access them.
+        # Column names use underscores (Sub_col) to avoid pandas eval issues.
+        # =================================================================
+        subframe_replacements = {}
+        if hasattr(self, '_subframes') and hasattr(self._subframes, 'subframes'):
+            sf_names = set(self._subframes.subframes.keys())
+            all_text = expr
+            if kwargs.get('selection'):
+                all_text += ' ' + kwargs['selection']
+            if kwargs.get('group_by'):
+                all_text += ' ' + str(kwargs['group_by'])
+            
+            import re as _re
+            for match in _re.finditer(r'\b(\w+)\.(\w+)\b', all_text):
+                sf_name, col_name = match.group(1), match.group(2)
+                if sf_name in sf_names:
+                    dot_ref = f"{sf_name}.{col_name}"
+                    flat_ref = f"{sf_name}_{col_name}"
+                    if flat_ref not in df_subset.columns and dot_ref not in subframe_replacements:
+                        try:
+                            sf = self.get_subframe(sf_name)
+                            index_cols = self._subframes.get_entry(sf_name)['index']
+                            if isinstance(index_cols, str):
+                                index_cols = [index_cols]
+                            join_idx, missing = self._compute_join_indices(sf_name, index_cols)
+                            if col_name in sf.df.columns:
+                                if df_subset is self.df:
+                                    df_subset = df_subset.copy()
+                                df_subset[flat_ref] = sf.df[col_name].values[join_idx]
+                                subframe_replacements[dot_ref] = flat_ref
+                        except Exception:
+                            pass
+            
+            if subframe_replacements:
+                for dot_ref, flat_ref in subframe_replacements.items():
+                    expr = expr.replace(dot_ref, flat_ref)
+                    if 'selection' in kwargs and kwargs['selection']:
+                        kwargs['selection'] = kwargs['selection'].replace(dot_ref, flat_ref)
+                    if 'group_by' in kwargs and isinstance(kwargs.get('group_by'), str):
+                        kwargs['group_by'] = kwargs['group_by'].replace(dot_ref, flat_ref)
+        
         # Create plotter and delegate
         plotter = DFDraw(df_subset)
 

UTILS/dfextensions/AliasDataFrame/tests/test_draw_subframe_resolution.py

@@ -0,0 +1,94 @@
+"""
+Tests for BUG_AliasDataFrame_20260324_draw_subframe_resolution
+
+Verifies that draw() correctly resolves Subframe.column references
+when the subframe has columns with names that conflict with main frame columns.
+"""
+
+import pytest
+import numpy as np
+import pandas as pd
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from AliasDataFrame import AliasDataFrame
+
+
+@pytest.fixture
+def adf_with_subframe():
+    """Create ADF with subframe that has conflicting column names."""
+    df_main = pd.DataFrame({
+        'group': [0, 0, 0, 1, 1, 1],
+        'x': np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]),
+        'dy': np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6]),
+    })
+    df_sub = pd.DataFrame({
+        'group': [0, 1],
+        'dy': [0.2, 0.5],     # conflicts with main frame
+        'dz': [0.01, 0.02],   # no conflict
+    })
+    adf = AliasDataFrame(df_main)
+    adf.register_subframe('Sub', AliasDataFrame(df_sub), index_columns=['group'])
+    return adf
+
+
+class TestDrawSubframeResolution:
+    """draw() should resolve Subframe.column references automatically."""
+
+    def test_draw_subframe_column_no_conflict(self, adf_with_subframe):
+        """draw('Sub.dz:x') works — dz has no name conflict."""
+        import matplotlib
+        matplotlib.use('Agg')
+        adf = adf_with_subframe
+        fig, ax, stats = adf.draw("Sub.dz:x", type='profile', bins=3)
+        assert fig is not None
+        assert ax is not None
+
+    def test_draw_subframe_column_with_conflict(self, adf_with_subframe):
+        """draw('Sub.dy:x') works — dy exists in both main and subframe."""
+        import matplotlib
+        matplotlib.use('Agg')
+        adf = adf_with_subframe
+        fig, ax, stats = adf.draw("Sub.dy:x", type='profile', bins=3)
+        assert fig is not None
+        assert ax is not None
+
+    def test_draw_subframe_column_values_correct(self, adf_with_subframe):
+        """Sub.dy values match subframe join (not main frame dy)."""
+        import matplotlib
+        matplotlib.use('Agg')
+        adf = adf_with_subframe
+
+        fig, ax, stats = adf.draw("Sub.dy:x", type='profile', bins=2,
+                                   return_data=True)
+        profile_data = stats.get('profile_data')
+        assert profile_data is not None
+
+        # Group 0 rows (x=1,2,3) should have Sub.dy = 0.2 (subframe value)
+        # Group 1 rows (x=4,5,6) should have Sub.dy = 0.5 (subframe value)
+        # Profile mean in first bin (x~2) should be ~0.2
+        # Profile mean in second bin (x~5) should be ~0.5
+        means = profile_data['y_mean'].values
+        assert abs(means[0] - 0.2) < 0.01, f"Expected ~0.2, got {means[0]}"
+        assert abs(means[1] - 0.5) < 0.01, f"Expected ~0.5, got {means[1]}"
+
+    def test_draw_subframe_in_selection(self, adf_with_subframe):
+        """Subframe.column works in selection parameter."""
+        import matplotlib
+        matplotlib.use('Agg')
+        adf = adf_with_subframe
+        # Use Sub.dz in selection (no conflict column)
+        fig, ax, stats = adf.draw("dy:x", type='profile', bins=3,
+                                   selection="Sub.dz<0.015")
+        assert fig is not None
+        # Should only have group 0 data (Sub.dz=0.01 < 0.015)
+
+    def test_auto_alias_subframe_conflict_skips(self, adf_with_subframe):
+        """auto_alias_subframe skips columns that exist in main frame."""
+        adf = adf_with_subframe
+        result = adf.auto_alias_subframe('Sub')
+        # 'dy' should be skipped (exists in main frame)
+        assert 'dy' in result['skipped_column']
+        # 'dz' should be created (no conflict)
+        assert any('dz' in alias for alias in result['created'])