DatetimeTZDtype

class pandas::DatetimeTZDtype

pandas C++ class.

Example

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

// Use DatetimeTZDtype
DatetimeTZDtype obj;
// ... operations ...

Constructors

Signature	Location	Example
DatetimeTZDtype(const std::string& unit = "ns", std::optional<std::string> tz = std::nullopt)	pd_datetime_tz_dtype.h:47

Iteration

Signature	Return Type	Location	Example
size_t itemsize() const override	size_t	pd_datetime_tz_dtype.h:73

Type Checking

Signature	Return Type	Location	Example
bool is_dtype(const std::string& dtype_name) const	bool	pd_datetime_tz_dtype.h:86	View
bool is_tz_aware() const { return tz_.has_value()	bool	pd_datetime_tz_dtype.h:54	View

Other Methods

Signature	Return Type	Location	Example
std::string kind() const override	std::string	pd_datetime_tz_dtype.h:77	View
std::string name() const override	std::string	pd_datetime_tz_dtype.h:57	View
numpy::DType numpy_dtype() const override	numpy::DType	pd_datetime_tz_dtype.h:69
static DatetimeUnit parse_unit(const std::string& s)	static DatetimeUnit	pd_datetime_tz_dtype.h:27
std::string repr() const override	std::string	pd_datetime_tz_dtype.h:64	View
const std::type_info& type() const override	const std::type_info&	pd_datetime_tz_dtype.h:81	View
std::optional<std::string> tz() const	std::optional<std::string>	pd_datetime_tz_dtype.h:53	View
std::string unit() const { return unit_str(unit_)	std::string	pd_datetime_tz_dtype.h:52	View
static std::string unit_str(DatetimeUnit u)	static std::string	pd_datetime_tz_dtype.h:35

Code Examples

The following examples are extracted from the test suite.

is_dtype (pd_test_3_all.cpp:18831)

    }
    if (!(dt1 != dt3)) {
        std::cout << "  [FAIL] : != operator failed" << std::endl;
        throw std::runtime_error("pd_test_equality: != operator failed");
    }

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

// ============================================================================
// Test is_dtype() method
// ============================================================================

void pd_test_is_dtype() {
    std::cout << "========= DatetimeTZDtype: is_dtype() ======================";

    pandas::DatetimeTZDtype dt("ns", "UTC");

    if (!dt.is_dtype("datetime64[ns, UTC]")) {
        std::cout << "  [FAIL] : is_dtype() exact match failed" << std::endl;
        throw std::runtime_error("pd_test_is_dtype: exact match failed");

is_tz_aware (pd_test_1_all.cpp:1425)

    void pd_test_datetime_array_timezone() {
        std::cout << "========= DatetimeArray: timezone ======================= ";

        pandas::DatetimeArray arr(std::vector<std::string>{
            "2023-01-01",
            "2023-06-15"
        });

        // Initially should be timezone-naive
        if (arr.is_tz_aware()) {
            std::cout << "  [FAIL] : array should be timezone-naive initially" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_timezone failed: naive");
        }

        // Localize to UTC
        auto localized = arr.tz_localize("UTC");
        if (!localized.is_tz_aware()) {
            std::cout << "  [FAIL] : localized array should be timezone-aware" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_timezone failed: localize");
        }

kind (pd_test_1_all.cpp:300)

    void pd_test_boolean_array_dtype() {
        std::cout << "========= BooleanArray: dtype ======================= ";

        pandas::BooleanArray arr;
        if (arr.dtype().name() != "boolean") {
            std::cout << "  [FAIL] : in pd_test_boolean_array_dtype() : dtype name should be 'boolean'" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_dtype failed: dtype name");
        }

        if (arr.dtype().kind() != "b") {
            std::cout << "  [FAIL] : in pd_test_boolean_array_dtype() : dtype kind should be 'b'" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_dtype failed: dtype kind");
        }

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

int pd_test_boolean_array_main() {
    std::cout << "====================================== running pd_test_boolean_array ==================================== " << std::endl;

name (pd_test_1_all.cpp:295)

            throw std::runtime_error("pd_test_boolean_array_reductions failed: mean");
        }

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

    void pd_test_boolean_array_dtype() {
        std::cout << "========= BooleanArray: dtype ======================= ";

        pandas::BooleanArray arr;
        if (arr.dtype().name() != "boolean") {
            std::cout << "  [FAIL] : in pd_test_boolean_array_dtype() : dtype name should be 'boolean'" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_dtype failed: dtype name");
        }

        if (arr.dtype().kind() != "b") {
            std::cout << "  [FAIL] : in pd_test_boolean_array_dtype() : dtype kind should be 'b'" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_dtype failed: dtype kind");
        }

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

repr (pd_test_1_all.cpp:10906)

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

void pd_test_extension_index_repr() {
    std::cout << "========= repr =========================";

    pandas::CategoricalArray arr({"a", "b", "c"});
    // Use ExtensionIndex<CategoricalArray> directly to test base class repr
    pandas::ExtensionIndex<pandas::CategoricalArray> idx(arr, "test");

    std::string repr_str = idx.repr();

    bool passed = (!repr_str.empty() && repr_str.find("ExtensionIndex") != std::string::npos);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_repr() : repr check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_repr failed");
    }

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

type (pd_test_3_all.cpp:15450)

/**
 * Test Series.convert_dtypes() parameter flags
 */
void pd_test_series_convert_dtypes_flags() {
    std::cout << "========= Series.convert_dtypes() flags =================";

    // Test convert_integer=false - with floats disabled too, so it becomes string/object
    pandas::Series<std::string> s({"1", "2", "3"}, "numbers");
    auto converted = s.convert_dtypes(true, true, false, true, false);  // convert_integer=false, convert_floating=false

    // Should remain object type (Series<std::string> has dtype_name()="object")
    // When integer and floating are both disabled for integer-like strings, it falls back to string type
    if (converted->dtype_name() != "object") {
        std::cout << "  [FAIL] : dtype should be object when convert_integer=false and convert_floating=false, got " << converted->dtype_name() << std::endl;
        throw std::runtime_error("pd_test_series_convert_dtypes_flags failed: convert_integer");
    }

    // Test convert_boolean=false - strings stay as object/string type
    pandas::Series<std::string> s_bool({"true", "false"}, "bools");
    auto converted_bool = s_bool.convert_dtypes(true, true, true, false, true);  // convert_boolean=false

tz (pd_test_2_all.cpp:17914)

            pandas::DataFrame df(data);
            df.set_index(std::make_unique<pandas::DatetimeIndex>(tz_aware_idx));

            // Verify the index is timezone-aware
            const pandas::DatetimeIndex* original_idx = dynamic_cast<const pandas::DatetimeIndex*>(&df.index());
            if (!original_idx) {
                std::cout << "  [FAIL] : in pd_test_tz_convert_basic() : index is not DatetimeIndex" << std::endl;
                throw std::runtime_error("pd_test_tz_convert_basic failed: index is not DatetimeIndex");
            }

            std::string original_tz = original_idx->tz();
            if (original_tz.empty()) {
                std::cout << "  [FAIL] : in pd_test_tz_convert_basic() : original index is not timezone-aware" << std::endl;
                throw std::runtime_error("pd_test_tz_convert_basic failed: original index is not timezone-aware");
            }

            // Convert to Asia/Shanghai timezone
            pandas::DataFrame df_shanghai = df.tz_convert("Asia/Shanghai");

            // Verify result has a DatetimeIndex
            const pandas::DatetimeIndex* converted_idx = dynamic_cast<const pandas::DatetimeIndex*>(&df_shanghai.index());

unit (pd_test_1_all.cpp:9284)

    data.setElementAt({0}, numpy::datetime64(1000LL, numpy::DateTimeUnit::Nanosecond));
    data.setElementAt({1}, numpy::datetime64(2000LL, numpy::DateTimeUnit::Nanosecond));

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

    pandas::DatetimeArray arr(data, mask);
    pandas::DatetimeTDMixin idx(arr);

    std::string unit = idx.unit();

    bool passed = (unit == "ns");  // nanosecond
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_datetime_unit_property() : unit property check failed, got '" << unit << "'" << std::endl;
        throw std::runtime_error("pd_test_datetime_unit_property failed");
    }

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