Attrs

class pandas::Attrs

Utility class for pandas operations.

Example

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

// Use Attrs
Attrs obj;
// ... operations ...

Constructors

Signature	Location	Example
Attrs() = default	pd_attrs.h:52
Attrs(const Attrs&) = default	pd_attrs.h:57
Attrs(Attrs&&) = default	pd_attrs.h:62

Indexing / Selection

Signature	Return Type	Location	Example
T get(const std::string& key) const	T	pd_attrs.h:103	View
T get(const std::string& key, T default_value) const	T	pd_attrs.h:119	View

Combining

Signature	Return Type	Location	Example
void merge(const Attrs& other, bool overwrite = true)	void	pd_attrs.h:217	View

Conversion

Signature	Return Type	Location	Example
Attrs copy() const	Attrs	pd_attrs.h:229	View

Iteration

Signature	Return Type	Location	Example
std::vector<std::string> keys() const	std::vector<std::string>	pd_attrs.h:188	View

Other Methods

Signature	Return Type	Location	Example
void clear()	void	pd_attrs.h:164	View
bool contains(const std::string& key) const	bool	pd_attrs.h:79	View
bool empty() const	bool	pd_attrs.h:180	View
bool has_type(const std::string& key) const	bool	pd_attrs.h:204	View
bool remove(const std::string& key)	bool	pd_attrs.h:157	View
void set(const std::string& key, T&& value)	void	pd_attrs.h:90	View
size_t size() const	size_t	pd_attrs.h:172	View
bool try_get(const std::string& key, T& out_value) const	bool	pd_attrs.h:139

Code Examples

The following examples are extracted from the test suite.

get (pd_test_1_all.cpp:10290)

void pd_test_extension_index_get_loc_unique() {
    std::cout << "========= get_loc (unique) =========================";

    pandas::CategoricalArray arr({"apple", "banana", "cherry"});
    pandas::CategoricalIndex idx(arr);

    auto loc_apple = idx.get_loc("apple");
    auto loc_banana = idx.get_loc("banana");
    auto loc_cherry = idx.get_loc("cherry");

    bool passed = (std::holds_alternative<size_t>(loc_apple) && std::get<size_t>(loc_apple) == 0 &&
                   std::get<size_t>(loc_banana) == 1 &&
                   std::get<size_t>(loc_cherry) == 2);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_get_loc_unique() : get_loc check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_get_loc_unique failed");
    }

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

get (pd_test_1_all.cpp:10290)

void pd_test_extension_index_get_loc_unique() {
    std::cout << "========= get_loc (unique) =========================";

    pandas::CategoricalArray arr({"apple", "banana", "cherry"});
    pandas::CategoricalIndex idx(arr);

    auto loc_apple = idx.get_loc("apple");
    auto loc_banana = idx.get_loc("banana");
    auto loc_cherry = idx.get_loc("cherry");

    bool passed = (std::holds_alternative<size_t>(loc_apple) && std::get<size_t>(loc_apple) == 0 &&
                   std::get<size_t>(loc_banana) == 1 &&
                   std::get<size_t>(loc_cherry) == 2);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_get_loc_unique() : get_loc check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_get_loc_unique failed");
    }

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

merge (pd_test_1_all.cpp:13639)

namespace dataframe_tests {
    namespace dataframe_tests_joining {

        // Helper to check approximate equality
        bool approx_equal(double a, double b, double tol = 1e-9) {
            if (std::isnan(a) && std::isnan(b)) return true;
            return std::abs(a - b) < tol;
        }

        // =====================================================================
        // merge() Tests
        // =====================================================================

        void pd_test_joining_merge_inner() {
            std::cout << "========= merge inner join ============================";

            // Left DataFrame: id, value_left
            std::map<std::string, std::vector<double>> left_data = {
                {"id", {1.0, 2.0, 3.0, 4.0}},
                {"value_left", {10.0, 20.0, 30.0, 40.0}}
            };

copy (pd_test_1_all.cpp:5798)

// ============================================================================
// Copy/Rename Tests
// ============================================================================

void pd_test_categorical_index_copy() {
    std::cout << "========= copy ========================================";

    pandas::CategoricalArray arr({"a", "b", "c"});
    pandas::CategoricalIndex idx(arr, "original");

    pandas::CategoricalIndex copied = idx.copy();

    bool passed = (copied.size() == idx.size() && copied.name() == idx.name() &&
                   copied.categories() == idx.categories() && copied.ordered() == idx.ordered());
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_categorical_index_copy()" << std::endl;
        throw std::runtime_error("pd_test_categorical_index_copy failed");
    }

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

keys (pd_test_1_all.cpp:16319)

            }

            // Test default value
            passed = attrs.get<int>("missing", 99) == 99;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_ndframe_attrs() : default value" << std::endl;
                throw std::runtime_error("pd_test_ndframe_attrs failed: default value");
            }

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

            // Test remove
            passed = attrs.remove("count") && !attrs.contains("count");
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_ndframe_attrs() : remove" << 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;
        }

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

contains (pd_test_1_all.cpp:2200)

// Test: contains method
// ============================================================================
void test_contains() {
    std::cout << "========= IntervalArray: contains ======================= ";

    std::vector<numpy::float64> breaks = {0.0, 1.0, 2.0, 3.0};

    // Right-closed intervals: (0, 1], (1, 2], (2, 3]
    auto arr_right = pandas::IntervalArrayFloat64::from_breaks(breaks, pandas::IntervalClosed::Right);

    // Test contains(1.0) - should be in interval 0 but not 1 (since 1 is exclusive on left of interval 1)
    auto contains_1 = arr_right.contains(1.0);
    // (0, 1] contains 1: yes, (1, 2] contains 1: no (open on left), (2, 3] contains 1: no
    if (contains_1[0].value_or(false) != true ||
        contains_1[1].value_or(true) != false ||
        contains_1[2].value_or(true) != false) {
        std::cout << "[FAIL] : in test_contains() : right-closed contains 1.0" << std::endl;
        return;
    }

    // Left-closed intervals: [0, 1), [1, 2), [2, 3)

empty (pd_test_1_all.cpp:941)

#include "../pandas/pd_config.h"

namespace dataframe_tests {

namespace dataframe_tests_config {

    void pd_test_config_version() {
        std::cout << "========= df_config: version info ======================= ";
        const char* version = pandas::DataFrameInfo::version();
        if (version == nullptr || std::string(version).empty()) {
            std::cout << "[FAIL] : in pd_test_config_version() : version is null or empty" << std::endl;
            throw std::runtime_error("pd_test_config_version failed: version is null or empty");
        }
        std::cout << "-> tests passed" << std::endl;
    }

    void pd_test_config_na_repr() {
        std::cout << "========= df_config: NA representation ======================= ";
        const char* na_repr = pandas::DataFrameConfig::get_na_repr();
        if (na_repr == nullptr) {

has_type (pd_test_1_all.cpp:16334)

            }

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

            // 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;

remove (pd_test_1_all.cpp:16327)

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

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

            // 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");

set (pd_test_1_all.cpp:16281)

            pandas::Attrs attrs;

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

            // Test set/get string
            attrs.set("author", std::string("John Doe"));
            passed = attrs.contains("author") && attrs.get<std::string>("author") == "John Doe";
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_ndframe_attrs() : set/get string" << std::endl;
                throw std::runtime_error("pd_test_ndframe_attrs failed: set/get string");
            }

            // Test set/get double
            attrs.set("version", 1.5);
            passed = std::abs(attrs.get<double>("version") - 1.5) < 1e-10;
            if (!passed) {

size (pd_test_1_all.cpp:22)

#include "../pandas/pd_boolean_array.h"

namespace dataframe_tests {

namespace dataframe_tests_boolean_array {
    void pd_test_boolean_array_constructors() {
        std::cout << "========= BooleanArray: constructors ======================= ";

        // Default constructor
        pandas::BooleanArray arr1;
        if (arr1.size() != 0) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_constructors() : default constructor size != 0" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_constructors failed: default constructor size != 0");
        }

        // Initializer list constructor
        pandas::BooleanArray arr2({
            std::optional<bool>(true),
            std::optional<bool>(false),
            std::nullopt,
            std::optional<bool>(true)