pl2html 0.4.1__tar.gz → 0.5.1__tar.gz

{pl2html-0.4.1 → pl2html-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pl2html
-Version: 0.4.1
+Version: 0.5.1
 Summary: Add your description here
 Requires-Dist: polars>=1.42.1
 Requires-Python: >=3.14
@@ -40,7 +40,7 @@ By default, `pl2html` infers datatypes to securely render human-readable tables.
 
 ```python
 import polars as pl
-from pl2html import to_html
+from pl2html.compiler import to_html
 
 df = pl.DataFrame(
     {
@@ -78,7 +78,7 @@ Output:
 
 ```python
 import polars as pl
-from pl2html import to_html
+from pl2html.compiler import to_html
 from pl2html import formats as fmt
 
 df = pl.DataFrame(
@@ -107,7 +107,7 @@ Instead of embedding hacky structural HTML tags in your data, use the `attrs` pa
 
 ```python
 import polars as pl
-from pl2html import to_html
+from pl2html.compiler import to_html
 from pl2html.styles import data_color, rank_color
 
 df = pl.DataFrame(
@@ -167,7 +167,7 @@ Output (github may override table colors, but they are there):
 
 The library is explicitly divided into three decoupled layers:
 
-### 1. Core Compiler (`__init__.py`)
+### 1. Core Compiler (`compiler.py`)
 Responsible for reading the dataframe schema, iterating horizontally over visible columns, and joining tokens into structural row arrays natively in Rust. 
 * Exposed via `to_html(df, *, attrs=None, exclude_columns=None)`.
 * Automatically assigns high-performance format fallbacks:

{pl2html-0.4.1 → pl2html-0.5.1}/README.md

@@ -31,7 +31,7 @@ By default, `pl2html` infers datatypes to securely render human-readable tables.
 
 ```python
 import polars as pl
-from pl2html import to_html
+from pl2html.compiler import to_html
 
 df = pl.DataFrame(
     {
@@ -69,7 +69,7 @@ Output:
 
 ```python
 import polars as pl
-from pl2html import to_html
+from pl2html.compiler import to_html
 from pl2html import formats as fmt
 
 df = pl.DataFrame(
@@ -98,7 +98,7 @@ Instead of embedding hacky structural HTML tags in your data, use the `attrs` pa
 
 ```python
 import polars as pl
-from pl2html import to_html
+from pl2html.compiler import to_html
 from pl2html.styles import data_color, rank_color
 
 df = pl.DataFrame(
@@ -158,7 +158,7 @@ Output (github may override table colors, but they are there):
 
 The library is explicitly divided into three decoupled layers:
 
-### 1. Core Compiler (`__init__.py`)
+### 1. Core Compiler (`compiler.py`)
 Responsible for reading the dataframe schema, iterating horizontally over visible columns, and joining tokens into structural row arrays natively in Rust. 
 * Exposed via `to_html(df, *, attrs=None, exclude_columns=None)`.
 * Automatically assigns high-performance format fallbacks:

pl2html-0.5.1/pl2html/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.5.1'

pl2html-0.5.1/pl2html/compiler.py

@@ -0,0 +1,267 @@
+from polars import (
+    DataFrame as _DataFrame,
+    DataType as _DataType,
+    Expr as _Expr,
+    LazyFrame as _LazyFrame,
+    String as _String,
+    col as _col,
+    concat_str as _concat_str,
+    lit as _lit,
+    when as _when,
+)
+
+
+def _escape_expr(expr: _Expr) -> _Expr:
+    """
+    Escapes an expression's string representations for secure HTML compatibility.
+    Using literal=True is critical; otherwise, the '&' character in the replacement
+    string acts as a regex match expansion macro and corrupts the entities.
+    """
+    return (
+        expr.cast(_String)
+        .str.replace_all('&', '&', literal=True)
+        .str.replace_all('<', '&lt;', literal=True)
+        .str.replace_all('>', '&gt;', literal=True)
+        .str.replace_all('"', '&quot;', literal=True)
+        .str.replace_all("'", '&#x27;', literal=True)
+    )
+
+
+def _format_integer(col_name: str) -> _Expr:
+    """Adds thousands separators to integers using look-around-free logic."""
+    return (
+        _col(col_name)
+        .fill_null(0)
+        .cast(_String)
+        # Polars regex engine doesn't support look-behinds (e.g., (?<=\d)(?=(\d{3})+$)).
+        # We reverse the string, match chunks of 3 digits from the right, add commas,
+        # and then reverse it back to normal.
+        .str.reverse()
+        .str.replace_all(r'\d{3}', '$0,')
+        .str.reverse()
+        .str.replace(r'^,', '')
+        .str.replace(r'^-,', '-')
+    )
+
+
+def _format_float(col_name: str) -> _Expr:
+    """Formats floats with 3 decimals and thousands separators."""
+    rounded_str = _col(col_name).round(3).cast(_String)
+
+    parts = rounded_str.str.split_exact('.', 1)
+    int_part = parts.struct.field('field_0')
+    dec_part = parts.struct.field('field_1')
+
+    formatted_int = (
+        int_part.str.reverse()
+        .str.replace_all(r'\d{3}', '$0,')
+        .str.reverse()
+        .str.replace(r'^,', '')
+        .str.replace(r'^-,', '-')
+    )
+
+    return (
+        _when(dec_part.is_not_null() & (dec_part != ''))
+        .then(formatted_int + _lit('.') + dec_part)
+        .otherwise(formatted_int)
+    )
+
+
+def _build_cell_expr(
+    col_name: str,
+    dtype: _DataType,
+    attrs: dict[str, dict[str, _Expr]],
+) -> _Expr:
+    """Resolves attribute expressions before user formatters are applied."""
+    if dtype.is_integer():
+        fmt_expr = _format_integer(col_name)
+    elif dtype.is_float():
+        fmt_expr = _format_float(col_name)
+    else:
+        fmt_expr = _escape_expr(_col(col_name))
+
+    fmt_expr = fmt_expr.fill_null('')
+
+    attr_expr_list = []
+    if col_name in attrs:
+        for attr_name, val_expr in attrs[col_name].items():
+            val_str_expr = val_expr.cast(_String)
+
+            compiled_attr = (
+                _when(val_str_expr.is_not_null() & (val_str_expr != ''))
+                .then(_lit(f' {attr_name}="') + val_str_expr + _lit('"'))
+                .otherwise(_lit(''))
+            )
+            attr_expr_list.append(compiled_attr)
+
+    if attr_expr_list:
+        opening_td = _lit('<td') + _concat_str(attr_expr_list) + _lit('>')
+    else:
+        opening_td = _lit('<td>')
+
+    return opening_td + fmt_expr + _lit('</td>')
+
+
+def _build_html_skeleton(visible_columns: list[str]) -> tuple[_Expr, _Expr]:
+    header_parts = ['<table>', '  <thead>\n    <tr>']
+    for c in visible_columns:
+        header_parts.append(f'      <th>{c}</th>')
+    header_parts.append('    </tr>\n  </thead>\n  <tbody>')
+
+    html_header = _lit('\n'.join(header_parts) + '\n')
+    html_footer = _lit('\n  </tbody>\n</table>')
+    return html_header, html_footer
+
+
+def _resolve_attributes(
+    lf: _LazyFrame,
+    df: _DataFrame,
+    attrs: dict[str, dict[str, _Expr]],
+    visible_columns: list[str],
+) -> tuple[_LazyFrame, dict[str, dict[str, _Expr]]]:
+    """Compiles dynamic attribute expressions using the raw, unformatted numeric data."""
+    attr_exprs = []
+    attr_aliases = {}
+
+    for col_name, attr_map in attrs.items():
+        if col_name in visible_columns:
+            for attr_name, expr in attr_map.items():
+                alias_key = f'__attr_{col_name}_{attr_name}'
+                attr_exprs.append(_escape_expr(expr).alias(alias_key))
+                attr_aliases[(col_name, attr_name)] = alias_key
+
+    if not attr_exprs:
+        return lf, attrs
+
+    # Evaluate dynamic style contexts on the unformatted DataFrame
+    resolved_attrs_df = df.select(attr_exprs)
+
+    # Re-inject styles as true native structural data streams
+    lf = lf.with_columns(resolved_attrs_df)
+
+    # Remap the attributes dictionary to look at the new column references
+    new_attrs = {col: attr_map.copy() for col, attr_map in attrs.items()}
+
+    for (col_name, attr_name), alias in attr_aliases.items():
+        new_attrs[col_name][attr_name] = _col(alias)
+
+    return lf, new_attrs
+
+
+def _apply_user_formatters(
+    lf: _LazyFrame, formatters: _Expr | list[_Expr] | None
+) -> _LazyFrame:
+    """Applies layout transformation modifications/conversions to columns."""
+    if formatters is None:
+        return lf
+    if isinstance(formatters, _Expr):
+        formatters = [formatters]
+    return lf.with_columns(formatters)
+
+
+def _compile_html(
+    lf: _LazyFrame,
+    visible_columns: list[str],
+    attrs: dict[str, dict[str, _Expr]],
+) -> str:
+    """Constructs the raw structural HTML string from the resolved LazyFrame pipeline."""
+    # NOTE: Recompute the schema after applying user formatters. Formatters may
+    # cast numeric columns to String, and _build_cell_expr uses the current dtype
+    # to decide whether default numeric formatting (e.g. .round()) should be
+    # applied. Using the original schema would incorrectly attempt numeric
+    # formatting on already-formatted string columns.
+    current_schema = lf.collect_schema()
+
+    cell_expressions = [
+        _build_cell_expr(c, current_schema[c], attrs) for c in visible_columns
+    ]
+
+    row_expr = _lit('    <tr>') + _concat_str(cell_expressions) + _lit('</tr>')
+    html_header, html_footer = _build_html_skeleton(visible_columns)
+
+    return (
+        lf.select(row_expr.alias('html_row'))
+        .select(
+            (
+                html_header + _col('html_row').str.join('\n') + html_footer
+            ).alias('html_table')
+        )
+        .collect()
+        .item()
+    )
+
+
+def to_html(
+    df: _DataFrame | _LazyFrame,
+    *,
+    attrs: dict[str, dict[str, _Expr]] | None = None,
+    exclude_columns: list[str] | None = None,
+    formatters: _Expr | list[_Expr] | None = None,
+) -> str:
+    """Compiles a Polars DataFrame safely into an HTML string layout.
+
+    Accepts structural custom attribute mappings to handle layout modifications
+    and cell styling natively.
+
+    Args:
+        df: The source Polars DataFrame or LazyFrame containing the data.
+        attrs: A dictionary mapping column names to cell attributes (e.g., style,
+            class). The inner dictionary values can be raw Polars expressions that
+            evaluate dynamically based on the column values.
+        exclude_columns: A list of column names to omit from the final rendered
+            HTML table. See note below on structural execution context.
+        formatters: A single Polars expression or a list of expressions used to
+            format column values into display strings (e.g., using `fmt_number`).
+
+    Note on Execution Order (formatters and exclude_columns):
+        Both `formatters` and `exclude_columns` serve critical roles in preserving
+        the numeric evaluation state of the DataFrame before HTML compilation:
+
+        1. formatters: Usually, formatting expressions can be applied directly to
+           the DataFrame via `.with_columns()` before calling `to_html`. However,
+           doing so converts numeric columns into `String` types too early, causing
+           downstream style calculations (e.g., string division errors) to fail.
+           Passing them here guarantees formatting runs *after* style resolution.
+
+        2. exclude_columns: Dropping intermediate or helper columns before passing
+           the DataFrame to `to_html` removes the data context required by your
+           `attrs` expressions. By using `exclude_columns`, helper columns remain
+           fully accessible during the mathematical style resolution phase (Step 1),
+           but are cleanly filtered out before generating the HTML structural matrix.
+
+    Example:
+        >>> import polars as pl
+        >>> from pl2html import to_html
+        >>>
+        >>> # 'max_threshold' is a helper column required for styling but not rendering
+        >>> df = pl.DataFrame({
+        ...     "sprd": [10.0, 50.0, 100.0],
+        ...     "max_threshold": [120.0, 120.0, 120.0]
+        ... })
+        >>>
+        >>> # Style depends on the unrendered 'max_threshold' column
+        >>> attrs = {"sprd": {"style": pl.col("sprd") / pl.col("max_threshold")}}
+        >>>
+        >>> # Safe execution: 'max_threshold' is preserved for math, then omitted from output
+        >>> html = to_html(
+        ...     df,
+        ...     attrs=attrs,
+        ...     exclude_columns=["max_threshold"]
+        ... )
+    """
+    lf = df.lazy() if isinstance(df, _DataFrame) else df
+    exclude_columns = exclude_columns or []
+    attrs = attrs or {}
+
+    # Setup the evaluation context data
+    df_eager = lf.collect()
+    lf = df_eager.lazy()
+
+    visible_columns = [
+        c for c in df_eager.schema.names() if c not in exclude_columns
+    ]
+
+    lf, attrs = _resolve_attributes(lf, df_eager, attrs, visible_columns)
+    lf = _apply_user_formatters(lf, formatters)
+
+    return _compile_html(lf, visible_columns, attrs)

{pl2html-0.4.1 → pl2html-0.5.1}/pl2html/formats.py

@@ -30,81 +30,60 @@ def _multicolumn(func):
 _Columns = str | list[str]
 
 
-@_multicolumn
-def fmt_number(
-    *,
-    columns: _Columns,
-    decimals: int = 2,
-    scale_by: float = 1.0,
-    compact: bool = False,
-    compact_system: _Literal['financial', 'engineering'] = 'financial',
-    use_seps: bool = True,
-    accounting: bool = False,
-    pattern: str = '{x}',
-    n_sigfig: int | None = None,
-    force_sign: bool = False,
-) -> _Expr:
-    """
-    Highly optimized, native Polars numeric formatter matching great_tables features.
-    Runs entirely in the parallel Rust engine without dropping into Python row loops.
-    """
-    col_name = columns if isinstance(columns, str) else str(columns)
-    val = _col(columns)
-    if scale_by != 1.0:
-        val = val * scale_by
+def _apply_compact_scaling(
+    val: _Expr, compact: bool, compact_system: str
+) -> tuple[_Expr, _Expr]:
+    """Handles logic block 1: Extracts compact suffix rules and scales values down."""
+    if not compact:
+        return val, _lit('')
 
     abs_val = val.abs()
+    log10_expr = _when(abs_val > 0).then(abs_val.log10()).otherwise(_lit(0.0))
+    thousands_exponent = (log10_expr / 3.0).floor().cast(_Int32) * 3
 
-    # 1. Extract compact scaling suffix chain if enabled
-    if compact:
-        log10_expr = (
-            _when(abs_val > 0).then(abs_val.log10()).otherwise(_lit(0.0))
-        )
-        thousands_exponent = (log10_expr / 3.0).floor().cast(_Int32) * 3
+    # Force exponent to 0 for fractional numbers (< 1.0)
+    thousands_exponent = (
+        _when(thousands_exponent < 0)
+        .then(_lit(0))
+        .otherwise(thousands_exponent)
+    )
 
-        # Force exponent to 0 for fractional numbers (< 1.0) so we don't scale up without micro-suffixes
-        thousands_exponent = (
-            _when(thousands_exponent < 0)
-            .then(_lit(0))
-            .otherwise(thousands_exponent)
-        )
+    system_chars = (
+        ('k', 'M', 'G', 'T')
+        if compact_system == 'engineering'
+        else ('K', 'M', 'B', 'T')
+    )
 
-        if compact_system == 'engineering':
-            suffix_chain = (
-                _when(thousands_exponent == 3)
-                .then(_lit('k'))
-                .when(thousands_exponent == 6)
-                .then(_lit('M'))
-                .when(thousands_exponent == 9)
-                .then(_lit('G'))
-                .when(thousands_exponent == 12)
-                .then(_lit('T'))
-                .otherwise(_lit(''))
-            )
-        else:
-            suffix_chain = (
-                _when(thousands_exponent == 3)
-                .then(_lit('K'))
-                .when(thousands_exponent == 6)
-                .then(_lit('M'))
-                .when(thousands_exponent == 9)
-                .then(_lit('B'))
-                .when(thousands_exponent == 12)
-                .then(_lit('T'))
-                .otherwise(_lit(''))
-            )
-        divisor = _lit(10.0).pow(thousands_exponent.cast(_Float64))
-        val_scaled = val / divisor
-    else:
-        val_scaled = val
-        suffix_chain = _lit('')
+    suffix_chain = (
+        _when(thousands_exponent == 3)
+        .then(_lit(system_chars[0]))
+        .when(thousands_exponent == 6)
+        .then(_lit(system_chars[1]))
+        .when(thousands_exponent == 9)
+        .then(_lit(system_chars[2]))
+        .when(thousands_exponent == 12)
+        .then(_lit(system_chars[3]))
+        .otherwise(_lit(''))
+    )
+
+    divisor = _lit(10.0).pow(thousands_exponent.cast(_Float64))
+    return val / divisor, suffix_chain
+
+
+def _compute_dynamic_precision(
+    val_scaled: _Expr, decimals: int, n_sigfig: int | None
+) -> tuple[_Expr, _Expr | int]:
+    """Handles logic block 2: Computes precision bounds safely avoiding non-finite floats, preserving nulls."""
+
+    # FIX: Explicitly target only NaN and Infinity, leaving nulls untouched
+    is_anomaly = val_scaled.is_nan() | val_scaled.is_infinite()
+    safe_val = _when(is_anomaly).then(_lit(0.0)).otherwise(val_scaled)
 
-    # 2. Dynamic Precision Handling (Significant Figures vs Fixed Decimals)
     if n_sigfig is not None:
         if n_sigfig < 1:
             raise ValueError('n_sigfig must be a positive integer >= 1')
 
-        rounded = val_scaled.round_sig_figs(n_sigfig)
+        rounded = safe_val.round_sig_figs(n_sigfig)
         abs_rounded = rounded.abs()
 
         log10_expr = (
@@ -121,21 +100,27 @@ def fmt_number(
             .otherwise(dynamic_decimals)
         )
     else:
-        epsilon = (
-            _when(val_scaled >= 0).then(_lit(1e-9)).otherwise(_lit(-1e-9))
-        )
-        rounded = (val_scaled + epsilon).round(decimals)
+        epsilon = _when(safe_val >= 0).then(_lit(1e-9)).otherwise(_lit(-1e-9))
+        rounded = (safe_val + epsilon).round(decimals)
         dynamic_decimals = _lit(decimals)
 
-    # 3. Component Extraction & Alignment
+    return rounded, dynamic_decimals
+
+
+def _extract_and_align_components(
+    rounded: _Expr,
+    decimals: int,
+    n_sigfig: int | None,
+    dynamic_decimals: _Expr | int,
+    use_seps: bool,
+) -> _Expr:
+    """Handles logic blocks 3 & 4: Cuts string tokens cleanly."""
+    # Since rounded is calculated from safe_val above, it contains no NaN/inf here.
+    # The .cast(_Int64) is now completely safe from panicking!
     int_part = rounded.cast(_Int64).abs().cast(_String)
     full_str = rounded.abs().cast(_String)
 
-    raw_frac = (
-        _when(full_str.str.contains(r'\.'))
-        .then(full_str.str.split('.').list.get(1))
-        .otherwise(_lit(''))
-    )
+    raw_frac = full_str.str.extract(r'\.(.*)', 1).fill_null(_lit(''))
 
     pad_len = n_sigfig if n_sigfig is not None else decimals
     frac_part = (
@@ -144,7 +129,6 @@ def fmt_number(
         .otherwise(_lit(''))
     )
 
-    # 4. Constructing Base Number String
     if use_seps:
         int_part = (
             int_part.str.reverse()
@@ -153,19 +137,56 @@ def fmt_number(
             .str.reverse()
         )
 
-    base_num_str = (
+    return (
         _when(dynamic_decimals > 0)
         .then(int_part + _lit('.') + frac_part)
         .otherwise(int_part)
     )
+
+
+@_multicolumn
+def fmt_number(
+    *,
+    columns: _Columns,
+    decimals: int = 2,
+    scale_by: float = 1.0,
+    compact: bool = False,
+    compact_system: _Literal['financial', 'engineering'] = 'financial',
+    use_seps: bool = True,
+    accounting: bool = False,
+    pattern: str = '{x}',
+    n_sigfig: int | None = None,
+    force_sign: bool = False,
+) -> _Expr:
+    """
+    Highly optimized, native Polars numeric formatter matching great_tables features.
+    Runs entirely in the parallel Rust engine without dropping into Python row loops.
+    """
+    col_name = columns if isinstance(columns, str) else str(columns)
+    val = _col(columns)
+    if scale_by != 1.0:
+        val = val * scale_by
+
+    # --- HELPER ORCHESTRATION ---
+    val_scaled, suffix_chain = _apply_compact_scaling(
+        val, compact, compact_system
+    )
+    rounded, dynamic_decimals = _compute_dynamic_precision(
+        val_scaled, decimals, n_sigfig
+    )
+    base_num_str = _extract_and_align_components(
+        rounded, decimals, n_sigfig, dynamic_decimals, use_seps
+    )
     base_num_str = base_num_str + suffix_chain
 
+    # --- PATTERN PARSING ---
     prefix, suffix = '', ''
     if pattern != '{x}':
         parts = pattern.split('{x}')
         if len(parts) == 2:
             prefix, suffix = parts[0], parts[1]
 
+    # --- STANDARD EXPRESSION GENERATION ---
     if accounting:
         formatted_expr = (
             _when(val < 0)
@@ -192,7 +213,17 @@ def fmt_number(
             .otherwise(_lit('+') + _lit(prefix) + base_num_str + _lit(suffix))
         )
 
-    return formatted_expr.alias(col_name)
+    # --- CRUCIAL FIX: NON-FINITE GLOBAL GUARD MASK ---
+    # Intercepts expression evaluation to bypass Int64 panics on NaN and Infinity tokens
+    final_guarded_expr = (
+        _when(val.is_nan())
+        .then(_lit('NaN'))
+        .when(val.is_infinite())
+        .then(_when(val < 0).then(_lit('-inf')).otherwise(_lit('inf')))
+        .otherwise(formatted_expr)
+    )
+
+    return final_guarded_expr.alias(col_name)
 
 
 @_multicolumn

{pl2html-0.4.1 → pl2html-0.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = 'uv_build'
 
 [project]
 name = "pl2html"
-version = "0.4.1"
+version = "0.5.1"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.14"

pl2html-0.4.1/pl2html/__init__.py

@@ -1,164 +0,0 @@
-from polars import (
-    DataFrame as _DataFrame,
-    DataType as _DataType,
-    Expr as _Expr,
-    LazyFrame as _LazyFrame,
-    String as _String,
-    col as _col,
-    concat_str as _concat_str,
-    lit as _lit,
-    when as _when,
-)
-
-__version__ = '0.4.1'
-
-
-def _escape_polars_string(col_name: str) -> _Expr:
-    """
-    Escapes a column's string representations for secure HTML compatibility.
-    Because standard HTML entities use look-arounds or loops, we can fall back to
-    a native character loop or custom mapper if extensive characters are used,
-    but basic safety replaces characters sequentially.
-    """
-    return (
-        _col(col_name)
-        .cast(_String)
-        .str.replace_all('&', '&')
-        .str.replace_all('<', '&lt;')
-        .str.replace_all('>', '&gt;')
-        .str.replace_all('"', '&quot;')
-        .str.replace_all("'", '&#x27;')
-    )
-
-
-def _format_integer(col_name: str) -> _Expr:
-    """Adds thousands separators to integers using look-around-free logic."""
-    return (
-        _col(col_name)
-        .fill_null(0)
-        .cast(_String)
-        .str.reverse()
-        .str.replace_all(r'\d{3}', '$0,')
-        .str.reverse()
-        .str.replace(r'^,', '')
-        .str.replace(r'^-,', '-')
-    )
-
-
-def _format_float(col_name: str) -> _Expr:
-    """Formats floats with 3 decimals and thousands separators."""
-    rounded_str = _col(col_name).round(3).cast(_String)
-    int_part = rounded_str.str.split_exact('.', 1).struct.field('field_0')
-    dec_part = rounded_str.str.split_exact('.', 1).struct.field('field_1')
-
-    formatted_int = (
-        int_part.str.reverse()
-        .str.replace_all(r'\d{3}', '$0,')
-        .str.reverse()
-        .str.replace(r'^,', '')
-        .str.replace(r'^-,', '-')
-    )
-
-    return (
-        _when(dec_part.is_not_null() & (dec_part != ''))
-        .then(formatted_int + _lit('.') + dec_part)
-        .otherwise(formatted_int)
-    )
-
-
-def _build_cell_expr(
-    col_name: str,
-    dtype: _DataType,
-    attrs: dict[str, dict[str, _Expr]],
-) -> _Expr:
-    """
-    Applies secure auto-escaping or data formatting overrides, then dynamically
-    compiles HTML attributes into a valid single opening <td> tag block.
-    """
-    # 1. Base Data Evaluation (Formatted and HTML Escaped safely)
-    if dtype.is_integer():
-        fmt_expr = _format_integer(col_name)
-    elif dtype.is_float():
-        fmt_expr = _format_float(col_name)
-    else:
-        fmt_expr = _escape_polars_string(col_name)
-
-    fmt_expr = fmt_expr.fill_null('')
-
-    # 2. Build Attributes Expression Natively (e.g., style="...", class="...")
-    attr_expr_list = []
-    if col_name in attrs:
-        for attr_name, val_expr in attrs[col_name].items():
-            # If the expression returns null or empty for a specific row, skip writing the attribute
-            compiled_attr = (
-                _when(val_expr.is_not_null() & (val_expr != ''))
-                .then(
-                    _lit(f' {attr_name}="')
-                    + val_expr.cast(_String)
-                    + _lit('"')
-                )
-                .otherwise(_lit(''))
-            )
-            attr_expr_list.append(compiled_attr)
-
-    # Combine attribute strings together
-    if attr_expr_list:
-        opening_td = _lit('<td') + _concat_str(attr_expr_list) + _lit('>')
-    else:
-        opening_td = _lit('<td>')
-
-    return opening_td + fmt_expr + _lit('</td>')
-
-
-def _build_html_skeleton(visible_columns: list[str]) -> tuple[_Expr, _Expr]:
-    header_parts = ['<table>', '  <thead>\n    <tr>']
-    for c in visible_columns:
-        header_parts.append(f'      <th>{c}</th>')
-    header_parts.append('    </tr>\n  </thead>\n  <tbody>')
-
-    html_header = _lit('\n'.join(header_parts) + '\n')
-    html_footer = _lit('\n  </tbody>\n</table>')
-    return html_header, html_footer
-
-
-def to_html(
-    df: _DataFrame | _LazyFrame,
-    *,
-    attrs: dict[str, dict[str, _Expr]] | None = None,
-    exclude_columns: list[str] | None = None,
-) -> str:
-    """
-    Compiles a Polars DataFrame safely into an HTML string layout.
-    Accepts structural custom attributes mappings to handle layout modifications natively.
-    """
-    lf = df.lazy() if isinstance(df, _DataFrame) else df
-
-    exclude_columns = exclude_columns or []
-    attrs = attrs or {}
-
-    schema = lf.collect_schema()
-    visible_columns = [c for c in schema.names() if c not in exclude_columns]
-
-    cell_expressions = []
-
-    # 2. Map structural cell loops
-    for c in visible_columns:
-        cell_expressions.append(_build_cell_expr(c, schema[c], attrs))
-
-    # 3. Concatenate columns horizontally into rows
-    row_expr = _lit('    <tr>') + _concat_str(cell_expressions) + _lit('</tr>')
-
-    # 4. Generate wrappers and frame the query graph
-    html_header, html_footer = _build_html_skeleton(visible_columns)
-
-    # 5. Execute the query graph and pull out the raw python string directly
-    return (
-        lf.select(row_expr.alias('html_row'))
-        .select(
-            (
-                html_header + _col('html_row').str.join('\n') + html_footer
-            ).alias('html_table')
-        )
-        .collect()
-        .item()
-    )