refactor: add debug utilities for HTML formatter integration testing and enhance debugging output in DataFrameHtmlFormatter

Author: kosiew

python/datafusion/debug_utils.py

@@ -0,0 +1,60 @@
+"""Debug utilities for DataFusion."""
+
+
+def check_html_formatter_integration():
+    """Debug function to check if DataFrame properly uses the HTML formatter."""
+    from datafusion import SessionContext
+    from datafusion.html_formatter import get_formatter, configure_formatter
+
+    # Print formatter details
+    formatter = get_formatter()
+    print(f"Default formatter ID: {id(formatter)}")
+    print(f"Has type formatters: {len(formatter._type_formatters)}")
+
+    # Create a test DataFrame
+    ctx = SessionContext()
+    df = ctx.sql("SELECT 1 as a, 2 as b, 3 as c")
+
+    # Check if DataFrame has _repr_html_ method
+    if not hasattr(df, "_repr_html_"):
+        print("ERROR: DataFrame does not have _repr_html_ method")
+        return
+
+    # Get the _repr_html_ method
+    repr_html_method = getattr(df, "_repr_html_")
+    print(f"DataFrame _repr_html_ method: {repr_html_method}")
+
+    # Register a custom formatter
+    formatter.register_formatter(int, lambda n: f"INT:{n}")
+    print("Registered formatter for integers")
+
+    # Generate HTML and check if our formatter was used
+    html_output = df._repr_html_()
+    print(f"HTML contains our formatter output (INT:1): {'INT:1' in html_output}")
+
+    # If not using our formatter, try to install a monkeypatch
+    if "INT:1" not in html_output:
+        print("Installing monkeypatch for DataFrame._repr_html_")
+        import importlib
+
+        df_module = importlib.import_module("datafusion.dataframe")
+        DataFrame = getattr(df_module, "DataFrame")
+
+        # Define the monkeypatch
+        def patched_repr_html(self):
+            """Patched version of _repr_html_ to use our formatter."""
+            from datafusion.html_formatter import get_formatter
+
+            formatter = get_formatter()
+            print(f"Patched _repr_html_ using formatter ID: {id(formatter)}")
+            return formatter.format_html(self.collect(), self.schema())
+
+        # Apply the monkeypatch
+        setattr(DataFrame, "_repr_html_", patched_repr_html)
+
+        # Test again
+        df = ctx.sql("SELECT 1 as a, 2 as b, 3 as c")
+        html_output = df._repr_html_()
+        print(
+            f"After monkeypatch, HTML contains our formatter output (INT:1): {'INT:1' in html_output}"
+        )

python/datafusion/html_formatter.py

@@ -1,5 +1,6 @@
 """HTML formatting utilities for DataFusion DataFrames."""
 
+import sys
 from typing import Dict, Optional, Any, Union, List, Callable, Type, Protocol
 
 
@@ -140,6 +141,14 @@ def format_html(
         Returns:
             HTML string representation of the data
         """
+        print("DEBUG format_html: Called with batches:", len(batches) if batches else 0)
+        print(
+            f"DEBUG format_html: Type formatters registered: {len(self._type_formatters)}"
+        )
+        print(
+            f"DEBUG format_html: Has custom cell builder: {self._custom_cell_builder is not None}"
+        )
+
         if not batches:
             return "No data to display"
 
@@ -215,16 +224,25 @@ def _build_table_body(self, batches: list, table_uuid: str) -> List[str]:
                 for col_idx, column in enumerate(batch.columns):
                     # Get the raw value from the column
                     raw_value = self._get_cell_value(column, row_idx)
+                    print(
+                        f"DEBUG row {row_count}, col {col_idx}: raw_value = {raw_value} ({type(raw_value).__name__})"
+                    )
 
                     # Always check for type formatters first to format the value
                     formatted_value = self._format_cell_value(raw_value)
+                    print(
+                        f"DEBUG row {row_count}, col {col_idx}: formatted_value = {formatted_value}"
+                    )
 
                     # Then apply either custom cell builder or standard cell formatting
                     if self._custom_cell_builder:
                         # Pass both the raw value and formatted value to let the builder decide
                         cell_html = self._custom_cell_builder(
                             raw_value, row_count, col_idx, table_uuid
                         )
+                        print(
+                            f"DEBUG custom cell builder returned: {cell_html[:50]}..."
+                        )
                         html.append(cell_html)
                     else:
                         # Standard cell formatting with formatted value
@@ -273,7 +291,10 @@ def _format_cell_value(self, value: Any) -> str:
         # Check for custom type formatters
         for type_cls, formatter in self._type_formatters.items():
             if isinstance(value, type_cls):
-                return formatter(value)
+                print(f"DEBUG formatter match for {type_cls.__name__}: {value}")
+                result = formatter(value)
+                print(f"DEBUG formatter returned: {result}")
+                return result
 
         # If no formatter matched, return string representation
         return str(value)
@@ -383,6 +404,10 @@ def get_formatter() -> DataFrameHtmlFormatter:
     Returns:
         The global HTML formatter instance
     """
+    print(f"DEBUG get_formatter: returning instance id={id(_default_formatter)}")
+    print(
+        f"DEBUG get_formatter: type formatters: {len(_default_formatter._type_formatters)}"
+    )
     return _default_formatter
 
 

python/tests/test_dataframe.py

@@ -740,6 +740,56 @@ def test_html_formatter_type_formatters(df, reset_formatter):
     assert '<span style="color: red">3</span>' in html_output
 
 
+def test_html_formatter_type_formatters_debug(df, reset_formatter):
+    """Debugging version of test_html_formatter_type_formatters."""
+    from datafusion.html_formatter import get_formatter
+
+    print("\n\n==== STARTING test_html_formatter_type_formatters_debug ====")
+
+    # Import the debug utility
+    try:
+        from datafusion.debug_utils import check_html_formatter_integration
+
+        check_html_formatter_integration()
+    except ImportError:
+        print("Could not import debug_utils, continuing...")
+
+    # Get current formatter and register custom formatters
+    formatter = get_formatter()
+
+    # Format integers with color based on value
+    formatter.register_formatter(
+        int, lambda n: f'<span style="color: {"red" if n > 2 else "blue"}">{n}</span>'
+    )
+    print(f"Registered formatter for int: {formatter._type_formatters}")
+
+    # Let's examine the DataFrame instance
+    print(f"DataFrame type: {type(df).__name__}")
+    print(
+        f"DataFrame dir: {[m for m in dir(df) if not m.startswith('_') or m == '_repr_html_']}"
+    )
+
+    # Let's check what _repr_html_ does
+    import inspect
+
+    if hasattr(df, "_repr_html_"):
+        print(f"_repr_html_ source: {inspect.getsource(df._repr_html_)}")
+    else:
+        print("No _repr_html_ method found")
+
+    # Get the HTML output
+    html_output = df._repr_html_()
+
+    # Check for our expected string
+    expected = '<span style="color: blue">1</span>'
+    print(f"Expected string '{expected}' in output: {expected in html_output}")
+
+    # Print a small portion of the output
+    print(f"HTML snippet: {html_output[:500]}...")
+
+    print("==== END test_html_formatter_type_formatters_debug ====\n\n")
+
+
 def test_html_formatter_custom_cell_builder(df, reset_formatter):
     """Test using a custom cell builder function."""
     from datafusion.html_formatter import get_formatter