Styler

class pandas::Styler

Styling class for DataFrame rendering.

Example

#include <pandas/pandas.h>
using namespace pandas;

// Use Styler
Styler obj;
// ... operations ...

Constructors

Signature	Location	Example
explicit Styler(const DataFrame& data)	pd_styler.h:167
Styler(const Styler& other)	pd_styler.h:172

Indexing / Selection

Signature	Return Type	Location	Example
std::string get_cell_str(size_t row, size_t col) const	std::string	pd_styler.h:137
size_t get_col_index(const std::string& col_name) const	size_t	pd_styler.h:130
std::string get_column_name(size_t col) const	std::string	pd_styler.h:143
std::string get_index_str(size_t row) const	std::string	pd_styler.h:140

Missing Data

Signature	Return Type	Location	Example
static std::string interpolate_color(double normalized, const std::string& low_color, const std::string& high_color)	static std::string	pd_styler.h:152

Aggregation

Signature	Return Type	Location	Example
Styler& apply(ColumnStyleFunc func, std::optional<int> axis = 0, const StyleSubset& subset = {})	Styler&	pd_styler.h:191	View
Styler& map(CellStyleFunc func, const StyleSubset& subset = {})	Styler&	pd_styler.h:202	View
auto pipe(Func func) -> decltype(func(\*this))	auto	pd_styler.h:646	View

Combining

Signature	Return Type	Location	Example
Styler& concat(const Styler& other)	Styler&	pd_styler.h:637	View

I/O

Signature	Return Type	Location	Example
static std::optional<double> to_double(const std::string& s)	static std::optional<double>	pd_styler.h:146
std::string to_html(const std::string& table_uuid = "", const std::string& table_attributes = "", bool sparse_index = true, bool sparse_columns = true, bool bold_headers = false, const std::string& caption = "", const std::string& encoding = "utf-8", bool doctype_html = false, bool exclude_styles = false) const	std::string	pd_styler.h:530	View
void to_html(std::ostream& buf, const std::string& table_uuid = "", const std::string& table_attributes = "", bool sparse_index = true, bool sparse_columns = true, bool bold_headers = false, const std::string& caption = "", const std::string& encoding = "utf-8", bool doctype_html = false, bool exclude_styles = false) const	void	pd_styler.h:543	View
std::string to_latex(const std::string& column_format = "", const std::string& position = "", const std::string& position_float = "", bool hrules = false, const std::string& clines = "", const std::string& label = "", const std::string& caption = "", bool sparse_index = true, bool sparse_columns = true, const std::string& multirow_align = "c", const std::string& multicol_align = "r", bool siunitx = false, const std::string& environment = "", const std::string& encoding = "utf-8", bool convert_css = false) const	std::string	pd_styler.h:574	View
void to_latex(std::ostream& buf, const std::string& column_format = "", const std::string& position = "", const std::string& position_float = "", bool hrules = false, const std::string& clines = "", const std::string& label = "", const std::string& caption = "", bool sparse_index = true, bool sparse_columns = true, const std::string& multirow_align = "c", const std::string& multicol_align = "r", bool siunitx = false, const std::string& environment = "", const std::string& encoding = "utf-8", bool convert_css = false) const	void	pd_styler.h:593	View
std::string to_string(bool sparse_index = true, bool sparse_columns = true) const	std::string	pd_styler.h:617	View
void to_string(std::ostream& buf, bool sparse_index = true, bool sparse_columns = true) const	void	pd_styler.h:623	View

Other Methods

Signature	Return Type	Location	Example
Styler& background_gradient(const std::string& cmap = "PuBu", double low = 0.0, double high = 0.0, std::optional<int> axis = 0, const StyleSubset& subset = {}, double text_color_threshold = 0.408, std::optional<double> vmin = std::nullopt, std::optional<double> vmax = std::nullopt)	Styler&	pd_styler.h:305	View
Styler& bar(const StyleSubset& subset = {}, std::optional<int> axis = 0, const std::string& color = "#d65f5f", const std::string& cmap = "", double width = 100.0, double height = 100.0, const std::string& align = "left", std::optional<double> vmin = std::nullopt, std::optional<double> vmax = std::nullopt)	Styler&	pd_styler.h:345	View
Styler& clear()	Styler&	pd_styler.h:495	View
const DataFrame& data() const	const DataFrame&	pd_styler.h:653	View
void ensure_style_matrices()	void	pd_styler.h:127
static std::string escape_html(const std::string& str)	static std::string	pd_styler.h:149
std::vector<std::map<std::string, std::string>> export_styles() const	std::vector<std::map<std::string, std::string>>	pd_styler.h:502
Styler& format(const std::string& formatter = "", const StyleSubset& subset = {}, const std::string& na_rep = "", int precision = -1, const std::string& thousands = "", bool escape = true)	Styler&	pd_styler.h:370	View
Styler& format(const std::map<std::string, std::string>& formatters, const std::string& na_rep = "", int precision = -1, bool escape = true)	Styler&	pd_styler.h:380	View
Styler& hide(const StyleSubset& subset = {}, std::optional<int> axis = std::nullopt, const std::vector<int>& level = {}, bool names = false)	Styler&	pd_styler.h:481	View
Styler& highlight_between(const StyleSubset& subset = {}, const std::string& color = "yellow", std::optional<int> axis = std::nullopt, std::optional<double> left = std::nullopt, std::optional<double> right = std::nullopt, const std::string& inclusive = "both", const std::string& props = "")	Styler&	pd_styler.h:260	View
Styler& highlight_max(const StyleSubset& subset = {}, const std::string& color = "yellow", std::optional<int> axis = 0, const std::string& props = "")	Styler&	pd_styler.h:229	View
Styler& highlight_min(const StyleSubset& subset = {}, const std::string& color = "yellow", std::optional<int> axis = 0, const std::string& props = "")	Styler&	pd_styler.h:243	View
Styler& highlight_null(const std::string& color = "red", const StyleSubset& subset = {}, const std::string& props = "")	Styler&	pd_styler.h:216	View
Styler& highlight_quantile(const StyleSubset& subset = {}, const std::string& color = "yellow", std::optional<int> axis = 0, double q_left = 0.0, double q_right = 1.0, const std::string& inclusive = "both", const std::string& props = "")	Styler&	pd_styler.h:280	View
static std::tuple<int, int, int> parse_color(const std::string& color)	static std::tuple<int, int, int>	pd_styler.h:157
std::string render() const { return to_html()	std::string	pd_styler.h:658	View
std::pair<std::vector<size_t>, std::vector<size_t>> resolve_subset( const StyleSubset& subset) const	std::pair<std::vector<size_t>, std::vector<size_t>>	pd_styler.h:133
static std::string rgb_to_hex(int r, int g, int b)	static std::string	pd_styler.h:160
Styler& set_caption(const std::string& caption)	Styler&	pd_styler.h:434	View
Styler& set_properties(const std::map<std::string, std::string>& props, const StyleSubset& subset = {})	Styler&	pd_styler.h:396	View
Styler& set_sticky(std::optional<int> axis = 0, std::optional<int> pixel_size = std::nullopt, const std::vector<int>& levels = {})	Styler&	pd_styler.h:464
Styler& set_table_attributes(const std::string& attributes)	Styler&	pd_styler.h:418
Styler& set_table_styles( const std::vector<std::pair<std::string, std::string>>& table_styles, std::optional<int> axis = std::nullopt, bool overwrite = false)	Styler&	pd_styler.h:407	View
Styler& set_td_classes(const std::vector<std::vector<std::string>>& classes)	Styler&	pd_styler.h:426
Styler& set_tooltips(const std::vector<std::vector<std::string>>& ttips, const std::string& props = "", const std::string& css_class = "")	Styler&	pd_styler.h:444
Styler& set_uuid(const std::string& uuid)	Styler&	pd_styler.h:454	View
Styler& text_gradient(const std::string& cmap = "PuBu", double low = 0.0, double high = 0.0, std::optional<int> axis = 0, const StyleSubset& subset = {}, std::optional<double> vmin = std::nullopt, std::optional<double> vmax = std::nullopt)	Styler&	pd_styler.h:319	View
Styler& use(const std::vector<std::map<std::string, std::string>>& styles)	Styler&	pd_styler.h:510

Code Examples

The following examples are extracted from the test suite.

apply (pd_test_1_all.cpp:11244)

        void pd_test_func_apply_dataframe_apply_axis0() {
            std::cout << "========= DataFrame apply axis=0 ======================";

            std::map<std::string, std::vector<double>> data = {
                {"A", {1.0, 2.0, 3.0}},
                {"B", {4.0, 5.0, 6.0}}
            };
            pandas::DataFrame df(data);

            // apply axis=0 applies function to each column
            auto result = df.apply([](const std::vector<double>& col) {
                return std::accumulate(col.begin(), col.end(), 0.0);
            }, 0);

            bool passed = true;

            // Plan F·dtype: axis=0 reduce now returns a single "result" column
            // with the original column names ("A", "B") as the row index.
            // Sum of A: 1+2+3=6, Sum of B: 4+5+6=15
            const auto& result_col = result["result"];
            double sum_a = std::stod(result_col.get_value_str(0));

map (pd_test_1_all.cpp:5839)

// Map Tests
// ============================================================================

void pd_test_categorical_index_map() {
    std::cout << "========= map =========================================";

    pandas::CategoricalArray arr({"yes", "no", "yes"});
    pandas::CategoricalIndex idx(arr);

    std::unordered_map<std::string, std::string> mapping = {{"yes", "1"}, {"no", "0"}};
    pandas::CategoricalIndex mapped = idx.map(mapping);

    bool passed = (mapped.has_category("1") && mapped.has_category("0") &&
                   !mapped.has_category("yes") && !mapped.has_category("no"));
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_categorical_index_map()" << std::endl;
        throw std::runtime_error("pd_test_categorical_index_map failed");
    }

    std::cout << " -> tests passed" << std::endl;
}

pipe (pd_test_1_all.cpp:11164)

            // Pipe applies function to entire Series
            auto add_mean = [](const pandas::Series<double>& ser, double offset) {
                auto mean_val = ser.mean();
                std::vector<double> result;
                for (size_t i = 0; i < ser.size(); ++i) {
                    result.push_back(ser[i] + mean_val.value_or(0.0) + offset);
                }
                return pandas::Series<double>(result, ser.name());
            };

            auto result = s.pipe(add_mean, 10.0);

            bool passed = true;
            // mean is 2.5, offset is 10.0, so each value + 12.5
            std::vector<double> expected = {13.5, 14.5, 15.5, 16.5};
            for (size_t i = 0; i < result.size(); ++i) {
                if (!approx_equal(result[i], expected[i])) {
                    passed = false;
                    std::cout << "  [FAIL] : in pd_test_func_apply_series_pipe() : value mismatch at " << i << std::endl;
                    throw std::runtime_error("pd_test_func_apply_series_pipe failed: value mismatch");
                }

concat (pd_test_1_all.cpp:17717)

}

void pd_test_period_index_concat() {
    std::cout << "========= concat factory ==============================";

    std::vector<int64_t> ordinals1 = {0, 1};
    std::vector<int64_t> ordinals2 = {2, 3};
    pandas::PeriodIndex idx1(ordinals1, "D");
    pandas::PeriodIndex idx2(ordinals2, "D");

    pandas::PeriodIndex concatenated = pandas::PeriodIndex::concat({idx1, idx2});

    bool passed = (concatenated.size() == 4);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_period_index_concat()" << std::endl;
        throw std::runtime_error("pd_test_period_index_concat failed");
    }

    std::cout << " -> tests passed" << std::endl;
}

to_html (pd_test_1_all.cpp:13438)

        void pd_test_io_to_html() {
            std::cout << "========= to_html ================================";

            std::map<std::string, std::vector<double>> data;
            data["A"] = {1.0, 2.0};
            data["B"] = {3.0, 4.0};

            pandas::DataFrame df(data);

            std::string html = df.to_html();

            // Check for key HTML elements
            bool has_table = (html.find("<table") != std::string::npos);
            bool has_thead = (html.find("<thead>") != std::string::npos);
            bool has_tbody = (html.find("<tbody>") != std::string::npos);
            bool has_th = (html.find("<th>") != std::string::npos);
            bool has_td = (html.find("<td>") != std::string::npos);

            bool passed = has_table && has_thead && has_tbody && has_th && has_td;

to_html (pd_test_1_all.cpp:13438)

        void pd_test_io_to_html() {
            std::cout << "========= to_html ================================";

            std::map<std::string, std::vector<double>> data;
            data["A"] = {1.0, 2.0};
            data["B"] = {3.0, 4.0};

            pandas::DataFrame df(data);

            std::string html = df.to_html();

            // Check for key HTML elements
            bool has_table = (html.find("<table") != std::string::npos);
            bool has_thead = (html.find("<thead>") != std::string::npos);
            bool has_tbody = (html.find("<tbody>") != std::string::npos);
            bool has_th = (html.find("<th>") != std::string::npos);
            bool has_td = (html.find("<td>") != std::string::npos);

            bool passed = has_table && has_thead && has_tbody && has_th && has_td;

to_latex (pd_test_2_all.cpp:9446)

        void pd_test_styler_to_latex() {
            std::cout << "========= to_latex =================================";

            std::map<std::string, std::vector<double>> data = {
                {"A", {1.0, 2.0, 3.0}},
                {"B", {4.0, 5.0, 6.0}}
            };
            pandas::DataFrame df(data);

            auto styler = df.style();
            std::string latex = styler.to_latex();

            if (!contains(latex, "\\begin{tabular}")) {
                std::cout << "  [FAIL] : in pd_test_styler_to_latex() : did not produce tabular environment" << std::endl;
                throw std::runtime_error("pd_test_styler_to_latex failed: did not produce tabular environment");
            }
            if (!contains(latex, "\\end{tabular}")) {
                std::cout << "  [FAIL] : in pd_test_styler_to_latex() : did not close tabular environment" << std::endl;
                throw std::runtime_error("pd_test_styler_to_latex failed: did not close tabular environment");
            }

to_latex (pd_test_2_all.cpp:9446)

        void pd_test_styler_to_latex() {
            std::cout << "========= to_latex =================================";

            std::map<std::string, std::vector<double>> data = {
                {"A", {1.0, 2.0, 3.0}},
                {"B", {4.0, 5.0, 6.0}}
            };
            pandas::DataFrame df(data);

            auto styler = df.style();
            std::string latex = styler.to_latex();

            if (!contains(latex, "\\begin{tabular}")) {
                std::cout << "  [FAIL] : in pd_test_styler_to_latex() : did not produce tabular environment" << std::endl;
                throw std::runtime_error("pd_test_styler_to_latex failed: did not produce tabular environment");
            }
            if (!contains(latex, "\\end{tabular}")) {
                std::cout << "  [FAIL] : in pd_test_styler_to_latex() : did not close tabular environment" << std::endl;
                throw std::runtime_error("pd_test_styler_to_latex failed: did not close tabular environment");
            }

to_string (pd_test_1_all.cpp:2693)

        pandas::PeriodArray arr_m(std::vector<std::string>{
            "2020-01",
            "NaT",
            "2025-06"
        }, "M");

        // Year
        auto years = arr_m.year();
        auto y0 = years[0];
        if (!y0.has_value() || y0.value() != 2020) {
            std::cout << "  [FAIL] : year[0] should be 2020, got " << (y0.has_value() ? std::to_string(y0.value()) : "NA") << std::endl;
            throw std::runtime_error("pd_test_period_array_year_month_quarter failed: year[0]");
        }

        auto y1 = years[1];
        if (y1.has_value()) {
            std::cout << "  [FAIL] : year[1] should be NA (NaT)" << std::endl;
            throw std::runtime_error("pd_test_period_array_year_month_quarter failed: year[1] should be NA");
        }

        auto y2 = years[2];

to_string (pd_test_1_all.cpp:2693)

        pandas::PeriodArray arr_m(std::vector<std::string>{
            "2020-01",
            "NaT",
            "2025-06"
        }, "M");

        // Year
        auto years = arr_m.year();
        auto y0 = years[0];
        if (!y0.has_value() || y0.value() != 2020) {
            std::cout << "  [FAIL] : year[0] should be 2020, got " << (y0.has_value() ? std::to_string(y0.value()) : "NA") << std::endl;
            throw std::runtime_error("pd_test_period_array_year_month_quarter failed: year[0]");
        }

        auto y1 = years[1];
        if (y1.has_value()) {
            std::cout << "  [FAIL] : year[1] should be NA (NaT)" << std::endl;
            throw std::runtime_error("pd_test_period_array_year_month_quarter failed: year[1] should be NA");
        }

        auto y2 = years[2];

background_gradient (pd_test_2_all.cpp:9286)

        void pd_test_styler_background_gradient() {
            std::cout << "========= background_gradient ======================";

            std::map<std::string, std::vector<double>> data = {
                {"A", {1.0, 2.0, 3.0, 4.0, 5.0}},
                {"B", {10.0, 20.0, 30.0, 40.0, 50.0}}
            };
            pandas::DataFrame df(data);

            auto styler = df.style().background_gradient();
            std::string html = styler.to_html();

            if (!contains(html, "background-color: #")) {
                std::cout << "  [FAIL] : in pd_test_styler_background_gradient() : did not apply color styles" << std::endl;
                throw std::runtime_error("pd_test_styler_background_gradient failed: did not apply color styles");
            }

            auto styler2 = df.style().background_gradient("Reds");
            std::string html2 = styler2.to_html();

bar (pd_test_2_all.cpp:9332)

        }

        void pd_test_styler_bar() {
            std::cout << "========= bar ======================================";

            std::map<std::string, std::vector<double>> data = {
                {"A", {10.0, 30.0, 50.0, 70.0, 100.0}}
            };
            pandas::DataFrame df(data);

            auto styler = df.style().bar();
            std::string html = styler.to_html();

            if (!contains(html, "linear-gradient")) {
                std::cout << "  [FAIL] : in pd_test_styler_bar() : did not apply gradient background" << std::endl;
                throw std::runtime_error("pd_test_styler_bar failed: did not apply gradient background");
            }

            std::cout << " -> tests passed" << std::endl;
        }

clear (pd_test_1_all.cpp:16341)

            }

            // Test has_type
            passed = attrs.has_type<std::string>("author") && !attrs.has_type<int>("author");
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_ndframe_attrs() : has_type" << std::endl;
                throw std::runtime_error("pd_test_ndframe_attrs failed: has_type");
            }

            // Test clear
            attrs.clear();
            passed = attrs.empty();
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_ndframe_attrs() : clear" << std::endl;
                throw std::runtime_error("pd_test_ndframe_attrs failed: clear");
            }

            std::cout << " -> tests passed" << std::endl;
        }

        // =====================================================================

data (pd_test_1_all.cpp:9114)

        throw std::runtime_error("pd_test_datetime_mixin_default_constructor failed");
    }

    std::cout << " -> tests passed" << std::endl;
}

void pd_test_datetime_mixin_array_constructor() {
    std::cout << "========= DatetimeTDMixin array constructor =========================";

    // Create DatetimeArray with some values
    numpy::NDArray<numpy::datetime64> data(std::vector<size_t>{3});
    data.setElementAt({0}, numpy::datetime64(1000000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2001
    data.setElementAt({1}, numpy::datetime64(1500000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2017
    data.setElementAt({2}, numpy::datetime64(1600000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2020

    numpy::NDArray<numpy::bool_> mask(std::vector<size_t>{3});
    mask.setElementAt({0}, numpy::bool_(false));
    mask.setElementAt({1}, numpy::bool_(false));
    mask.setElementAt({2}, numpy::bool_(false));

    pandas::DatetimeArray arr(data, mask);

format (main.cpp:20)

int main() {
  // Automatically log all output to temp/pd_test_output.log
  numpy::TestLogger logger("temp/pd_test_output.log");

  int res = 0;
  int res1 = 0;
  std::string resS = "";

  // call all the tests
  res1 = dataframe_tests::pd_test_main();
  resS += std::format("             pd_test_main: {}  errors\n", res1);
  res += res1;

  std::cout << "\n------------------------- main --------------------------------------------\n";
  std::cout << std::endl << "All tests completed. Nb errors = " << res << std::endl;
  std::cout << "Details: \n" << resS;
  std::cout << "\n---------------------------------------------------------------------------\n";
  return res;
}

format (main.cpp:20)

int main() {
  // Automatically log all output to temp/pd_test_output.log
  numpy::TestLogger logger("temp/pd_test_output.log");

  int res = 0;
  int res1 = 0;
  std::string resS = "";

  // call all the tests
  res1 = dataframe_tests::pd_test_main();
  resS += std::format("             pd_test_main: {}  errors\n", res1);
  res += res1;

  std::cout << "\n------------------------- main --------------------------------------------\n";
  std::cout << std::endl << "All tests completed. Nb errors = " << res << std::endl;
  std::cout << "Details: \n" << resS;
  std::cout << "\n---------------------------------------------------------------------------\n";
  return res;
}

hide (pd_test_2_all.cpp:9420)

            std::cout << "========= hide =====================================";

            std::map<std::string, std::vector<double>> data = {
                {"A", {1.0, 2.0, 3.0}},
                {"B", {4.0, 5.0, 6.0}},
                {"C", {7.0, 8.0, 9.0}}
            };
            pandas::DataFrame df(data);

            pandas::StyleSubset subset({"B"});
            auto styler = df.style().hide(subset, 0);
            std::string html = styler.to_html();

            if (contains(html, "<th>B</th>")) {
                std::cout << "  [FAIL] : in pd_test_styler_hide() : did not hide column B" << std::endl;
                throw std::runtime_error("pd_test_styler_hide failed: did not hide column B");
            }

            if (!contains(html, "<th>A</th>") || !contains(html, "<th>C</th>")) {
                std::cout << "  [FAIL] : in pd_test_styler_hide() : removed wrong columns" << std::endl;
                throw std::runtime_error("pd_test_styler_hide failed: removed wrong columns");

highlight_between (pd_test_2_all.cpp:9266)

        void pd_test_styler_highlight_between() {
            std::cout << "========= highlight_between ========================";

            std::map<std::string, std::vector<double>> data = {
                {"A", {1.0, 5.0, 10.0}},
                {"B", {2.0, 6.0, 8.0}}
            };
            pandas::DataFrame df(data);

            auto styler = df.style().highlight_between({}, "lightblue", std::nullopt, 3.0, 7.0);
            std::string html = styler.to_html();

            if (!contains(html, "background-color: lightblue")) {
                std::cout << "  [FAIL] : in pd_test_styler_highlight_between() : did not apply lightblue background" << std::endl;
                throw std::runtime_error("pd_test_styler_highlight_between failed: did not apply lightblue background");
            }

            std::cout << " -> tests passed" << std::endl;
        }

highlight_max (pd_test_2_all.cpp:9188)

        void pd_test_styler_highlight_max() {
            std::cout << "========= highlight_max ============================";

            std::map<std::string, std::vector<double>> data = {
                {"A", {1.0, 3.0, 2.0}},
                {"B", {4.0, 5.0, 6.0}}
            };
            pandas::DataFrame df(data);

            // Highlight max with default color (yellow)
            auto styler = df.style().highlight_max();
            std::string html = styler.to_html();

            if (!contains(html, "background-color: yellow")) {
                std::cout << "  [FAIL] : in pd_test_styler_highlight_max() : did not apply yellow background" << std::endl;
                throw std::runtime_error("pd_test_styler_highlight_max failed: did not apply yellow background");
            }

            // Test with custom color
            auto styler2 = df.style().highlight_max({}, "lightgreen");
            std::string html2 = styler2.to_html();

highlight_min (pd_test_2_all.cpp:9217)

        void pd_test_styler_highlight_min() {
            std::cout << "========= highlight_min ============================";

            std::map<std::string, std::vector<double>> data = {
                {"A", {1.0, 3.0, 2.0}},
                {"B", {4.0, 5.0, 6.0}}
            };
            pandas::DataFrame df(data);

            auto styler = df.style().highlight_min();
            std::string html = styler.to_html();

            if (!contains(html, "background-color: yellow")) {
                std::cout << "  [FAIL] : in pd_test_styler_highlight_min() : did not apply yellow background" << std::endl;
                throw std::runtime_error("pd_test_styler_highlight_min failed: did not apply yellow background");
            }

            std::cout << " -> tests passed" << std::endl;
        }

highlight_null (pd_test_2_all.cpp:9237)

        void pd_test_styler_highlight_null() {
            std::cout << "========= highlight_null ===========================";

            std::map<std::string, std::vector<std::string>> data = {
                {"A", {"1.0", "NaN", "3.0"}},
                {"B", {"4.0", "5.0", "NA"}}
            };
            pandas::DataFrame df(data);

            auto styler = df.style().highlight_null();
            std::string html = styler.to_html();

            if (!contains(html, "background-color: red")) {
                std::cout << "  [FAIL] : in pd_test_styler_highlight_null() : did not apply red background" << std::endl;
                throw std::runtime_error("pd_test_styler_highlight_null failed: did not apply red background");
            }

            // Test with custom color
            auto styler2 = df.style().highlight_null("orange");
            std::string html2 = styler2.to_html();

highlight_quantile (pd_test_2_all.cpp:9672)

        }

        void pd_test_styler_highlight_quantile() {
            std::cout << "========= highlight_quantile =======================";

            std::map<std::string, std::vector<double>> data = {
                {"A", {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0}}
            };
            pandas::DataFrame df(data);

            auto styler = df.style().highlight_quantile({}, "lightgreen", 0, 0.8, 1.0);
            std::string html = styler.to_html();

            if (!contains(html, "background-color: lightgreen")) {
                std::cout << "  [FAIL] : in pd_test_styler_highlight_quantile() : did not apply highlight" << std::endl;
                throw std::runtime_error("pd_test_styler_highlight_quantile failed: did not apply highlight");
            }

            std::cout << " -> tests passed" << std::endl;
        }

render (pd_test_2_all.cpp:9161)

            std::map<std::string, std::vector<double>> data = {
                {"A", {1.0, 2.0, 3.0}},
                {"B", {4.0, 5.0, 6.0}}
            };
            pandas::DataFrame df(data);

            // Get Styler
            auto styler = df.style();

            // Check that render produces HTML
            std::string html = styler.render();
            if (!contains(html, "<table>")) {
                std::cout << "  [FAIL] : in pd_test_styler_basic() : render() did not produce table tag" << std::endl;
                throw std::runtime_error("pd_test_styler_basic failed: render() did not produce table tag");
            }
            if (!contains(html, "<th>A</th>")) {
                std::cout << "  [FAIL] : in pd_test_styler_basic() : render() did not include column header A" << std::endl;
                throw std::runtime_error("pd_test_styler_basic failed: render() did not include column header A");
            }
            if (!contains(html, "<th>B</th>")) {
                std::cout << "  [FAIL] : in pd_test_styler_basic() : render() did not include column header B" << std::endl;

set_caption (pd_test_2_all.cpp:9370)

        }

        void pd_test_styler_set_caption() {
            std::cout << "========= set_caption ==============================";

            std::map<std::string, std::vector<double>> data = {
                {"A", {1.0, 2.0, 3.0}}
            };
            pandas::DataFrame df(data);

            auto styler = df.style().set_caption("My Data Table");
            std::string html = styler.to_html();

            if (!contains(html, "<caption>My Data Table</caption>")) {
                std::cout << "  [FAIL] : in pd_test_styler_set_caption() : did not add caption element" << std::endl;
                throw std::runtime_error("pd_test_styler_set_caption failed: did not add caption element");
            }

            std::cout << " -> tests passed" << std::endl;
        }

set_properties (pd_test_2_all.cpp:9394)

            std::map<std::string, std::vector<double>> data = {
                {"A", {1.0, 2.0}},
                {"B", {3.0, 4.0}}
            };
            pandas::DataFrame df(data);

            std::map<std::string, std::string> props = {
                {"font-weight", "bold"},
                {"text-align", "center"}
            };
            auto styler = df.style().set_properties(props);
            std::string html = styler.to_html();

            if (!contains(html, "font-weight: bold")) {
                std::cout << "  [FAIL] : in pd_test_styler_set_properties() : did not apply font-weight" << std::endl;
                throw std::runtime_error("pd_test_styler_set_properties failed: did not apply font-weight");
            }
            if (!contains(html, "text-align: center")) {
                std::cout << "  [FAIL] : in pd_test_styler_set_properties() : did not apply text-align" << std::endl;
                throw std::runtime_error("pd_test_styler_set_properties failed: did not apply text-align");
            }

set_table_styles (pd_test_2_all.cpp:9696)

            std::map<std::string, std::vector<double>> data = {
                {"A", {1.0, 2.0, 3.0}}
            };
            pandas::DataFrame df(data);

            std::vector<std::pair<std::string, std::string>> styles = {
                {"th", "background-color: lightgray;"},
                {"td", "padding: 10px;"}
            };

            auto styler = df.style().set_table_styles(styles);
            std::string html = styler.to_html();

            if (!contains(html, "<style type=\"text/css\">")) {
                std::cout << "  [FAIL] : in pd_test_styler_set_table_styles() : did not add style block" << std::endl;
                throw std::runtime_error("pd_test_styler_set_table_styles failed: did not add style block");
            }
            if (!contains(html, "th { background-color: lightgray; }")) {
                std::cout << "  [FAIL] : in pd_test_styler_set_table_styles() : did not include th style" << std::endl;
                throw std::runtime_error("pd_test_styler_set_table_styles failed: did not include th style");
            }

set_uuid (pd_test_2_all.cpp:9653)

        }

        void pd_test_styler_set_uuid() {
            std::cout << "========= set_uuid =================================";

            std::map<std::string, std::vector<double>> data = {
                {"A", {1.0, 2.0, 3.0}}
            };
            pandas::DataFrame df(data);

            auto styler = df.style().set_uuid("my-custom-table-id");
            std::string html = styler.to_html();

            if (!contains(html, "id=\"my-custom-table-id\"")) {
                std::cout << "  [FAIL] : in pd_test_styler_set_uuid() : did not set table id" << std::endl;
                throw std::runtime_error("pd_test_styler_set_uuid failed: did not set table id");
            }

            std::cout << " -> tests passed" << std::endl;
        }

text_gradient (pd_test_2_all.cpp:9313)

        }

        void pd_test_styler_text_gradient() {
            std::cout << "========= text_gradient ============================";

            std::map<std::string, std::vector<double>> data = {
                {"A", {1.0, 2.0, 3.0}}
            };
            pandas::DataFrame df(data);

            auto styler = df.style().text_gradient("Blues");
            std::string html = styler.to_html();

            if (!contains(html, "color: #")) {
                std::cout << "  [FAIL] : in pd_test_styler_text_gradient() : did not apply text color styles" << std::endl;
                throw std::runtime_error("pd_test_styler_text_gradient failed: did not apply text color styles");
            }

            std::cout << " -> tests passed" << std::endl;
        }