feat(export): Add columns= parameter for snapshot mode

New parameter export_tree(columns=[...]) for cache/snapshot workflows:
- Exports only specified columns (no schema/aliases/subframes)
- Raises ValueError for missing columns
- Warns (UserWarning) if subframes exist but won't be exported
- Handles float16→float32 conversion for uproot compatibility

3 new tests added to TestExportTreeColumns.

Design decisions (3-reviewer consensus):
- Parameter name: columns= (matches pandas/RDF conventions)
- No auto-include of index columns (explicit is better)
- Warning for subframes (2-1 vote: GPT+Gemini yes, Claude no)

Co-authored-by: Claude (Architect)
Reviewed-by: GPT, Gemini, Claude

Author: miranov25

UTILS/dfextensions/AliasDataFrame/AliasDataFrame.py

@@ -3966,15 +3966,44 @@ def load(path_prefix, load_subframes=True):
 
         return adf
 
-    def export_tree(self, filename_or_file, treename="tree", dropAliasColumns=True,compression=uproot.ZLIB(level=1)):
+    def export_tree(self, filename_or_file, treename="tree", dropAliasColumns=True, compression=uproot.ZLIB(level=1), columns=None):
         """
-        uproot.LZMA(level=5)
-        :param filename_or_file:
-        :param treename:
-        :param dropAliasColumns:
-        :param compression:
-        :return:
+        Export DataFrame to ROOT TTree.
+        
+        Parameters
+        ----------
+        filename_or_file : str or uproot file
+            Output file path or open uproot file
+        treename : str
+            Name of output tree
+        dropAliasColumns : bool
+            If True, don't export columns that are aliases
+        compression : uproot compression
+            Compression algorithm (default: ZLIB level 1)
+        columns : list of str, optional
+            If provided, export only these columns (snapshot/cache mode).
+            WARNING: Schema, aliases, and subframes are NOT exported.
         """
+        import warnings
+        
+        # Snapshot mode: export only specified columns, no schema/subframes
+        if columns is not None:
+            missing = set(columns) - set(self.df.columns)
+            if missing:
+                raise ValueError(f"Requested columns not found: {sorted(missing)}")
+            if self._subframes.subframes:
+                warnings.warn(
+                    "export_tree(columns=...) does not export subframes. "
+                    "Only specified columns will be saved.",
+                    UserWarning
+                )
+            dtype_casts = {col: np.float32 for col in columns if self.df[col].dtype == np.float16}
+            export_df = self.df[columns].astype(dtype_casts)
+            with uproot.recreate(filename_or_file, compression=compression) as f:
+                f[treename] = {col: export_df[col].values for col in export_df.columns}
+            return
+        
+        # Full export mode: existing behavior
         is_path = isinstance(filename_or_file, str)
 
         if is_path:

UTILS/dfextensions/AliasDataFrame/tests/test_alias_dataframe.py

@@ -2482,5 +2482,75 @@ def test_schema_v2_order_agnostic_load(self):
                 os.unlink(temp_path)
 
 
+class TestExportTreeColumns(unittest.TestCase):
+    """Tests for export_tree(columns=...) snapshot mode."""
+    
+    def test_export_tree_columns_subset(self):
+        """Test export_tree with columns parameter exports only specified columns."""
+        import tempfile
+        
+        df = pd.DataFrame({
+            'x': np.array([1, 2, 3], dtype=np.float32),
+            'y': np.array([3, 4, 5], dtype=np.float32),
+            'z': np.array([5, 6, 7], dtype=np.float32),
+        })
+        adf = AliasDataFrame(df)
+        
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            filepath = os.path.join(tmp_dir, "subset.root")
+            adf.export_tree(filepath, "tree", columns=['x', 'y'])
+            
+            # Verify only x, y exported
+            adf2 = AliasDataFrame.read_tree(filepath, "tree")
+            self.assertIn('x', adf2.df.columns)
+            self.assertIn('y', adf2.df.columns)
+            self.assertNotIn('z', adf2.df.columns)
+            
+            # Verify data is correct
+            np.testing.assert_array_equal(adf2.df['x'].values, [1, 2, 3])
+            np.testing.assert_array_equal(adf2.df['y'].values, [3, 4, 5])
+    
+    def test_export_tree_columns_missing_raises(self):
+        """Test export_tree raises ValueError for missing columns."""
+        import tempfile
+        
+        df = pd.DataFrame({'x': np.array([1, 2], dtype=np.float32)})
+        adf = AliasDataFrame(df)
+        
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            filepath = os.path.join(tmp_dir, "out.root")
+            with self.assertRaises(ValueError) as ctx:
+                adf.export_tree(filepath, "tree", columns=['x', 'missing'])
+            self.assertIn("not found", str(ctx.exception))
+    
+    def test_export_tree_columns_warns_subframes(self):
+        """Test export_tree warns when subframes exist but columns specified."""
+        import tempfile
+        import warnings
+        
+        df = pd.DataFrame({
+            'x': np.array([1, 2], dtype=np.float32),
+            'row': np.array([0, 1], dtype=np.int32),
+        })
+        sub_df = pd.DataFrame({
+            'row': np.array([0, 1], dtype=np.int32),
+            'val': np.array([10, 20], dtype=np.float32),
+        })
+        
+        adf = AliasDataFrame(df)
+        adf.register_subframe('S', AliasDataFrame(sub_df), index_columns='row')
+        
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            filepath = os.path.join(tmp_dir, "out.root")
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter("always")
+                adf.export_tree(filepath, "tree", columns=['x'])
+                
+                # Check warning was raised
+                self.assertEqual(len(w), 1)
+                self.assertIn("subframes", str(w[0].message))
+                self.assertEqual(w[0].category, UserWarning)
+
+
 if __name__ == "__main__":
     unittest.main()