pocketpy/include/pybind11/internal/builtins.h

#pragma once

#include "types.h"

namespace pybind11 {
    inline void exec(const char* code, handle global = {}, handle local = {}) {
        vm->py_exec(code, global.ptr(), local.ptr());
    }

    // wrapper for builtin functions in Python
    inline bool hasattr(const handle& obj, const handle& name) {
        auto& key = _builtin_cast<pkpy::Str>(name);
        return vm->getattr(obj.ptr(), key, false) != nullptr;
    }

    inline bool hasattr(const handle& obj, const char* name) {
        return vm->getattr(obj.ptr(), name, false) != nullptr;
    }

    inline void delattr(const handle& obj, const handle& name) {
        auto& key = _builtin_cast<pkpy::Str>(name);
        vm->delattr(obj.ptr(), key);
    }

    inline void delattr(const handle& obj, const char* name) { vm->delattr(obj.ptr(), name); }

    inline object getattr(const handle& obj, const handle& name) {
        auto& key = _builtin_cast<pkpy::Str>(name);
        return reinterpret_borrow<object>(vm->getattr(obj.ptr(), key));
    }

    inline object getattr(const handle& obj, const char* name) {
        return reinterpret_borrow<object>(vm->getattr(obj.ptr(), name));
    }

    inline object getattr(const handle& obj, const handle& name, const handle& default_) {
        if(!hasattr(obj, name)) {
            return reinterpret_borrow<object>(default_);
        }
        return getattr(obj, name);
    }

    inline object getattr(const handle& obj, const char* name, const handle& default_) {
        if(!hasattr(obj, name)) {
            return reinterpret_borrow<object>(default_);
        }
        return getattr(obj, name);
    }

    inline void setattr(const handle& obj, const handle& name, const handle& value) {
        auto& key = _builtin_cast<pkpy::Str>(name);
        vm->setattr(obj.ptr(), key, value.ptr());
    }

    inline void setattr(const handle& obj, const char* name, const handle& value) {
        vm->setattr(obj.ptr(), name, value.ptr());
    }

    template <typename T>
    inline bool isinstance(const handle& obj) {
        pkpy::Type cls = _builtin_cast<pkpy::Type>(type::handle_of<T>().ptr());
        return vm->isinstance(obj.ptr(), cls);
    }

    template <>
    inline bool isinstance<handle>(const handle&) = delete;

    template <>
    inline bool isinstance<iterable>(const handle& obj) {
        return hasattr(obj, "__iter__");
    }

    template <>
    inline bool isinstance<iterator>(const handle& obj) {
        return hasattr(obj, "__iter__") && hasattr(obj, "__next__");
    }

    inline bool isinstance(const handle& obj, const handle& type) {
        return vm->isinstance(obj.ptr(), _builtin_cast<pkpy::Type>(type));
    }

    inline int64_t hash(const handle& obj) { return vm->py_hash(obj.ptr()); }

    template <typename T, typename SFINAE = void>
    struct type_caster;

    template <typename T>
    handle _cast(T&& value,
                 return_value_policy policy = return_value_policy::automatic_reference,
                 handle parent = handle()) {
        using U = std::remove_pointer_t<std::remove_cv_t<std::remove_reference_t<T>>>;
        return type_caster<U>::cast(std::forward<T>(value), policy, parent);
    }

    template <typename T>
    object cast(T&& value,
                return_value_policy policy = return_value_policy::automatic_reference,
                handle parent = handle()) {
        return reinterpret_borrow<object>(_cast(std::forward<T>(value), policy, parent));
    }

    template <typename T>
    T cast(handle obj, bool convert = false) {
        using Caster =
            type_caster<std::remove_pointer_t<std::remove_cv_t<std::remove_reference_t<T>>>>;
        Caster caster;

        if(caster.load(obj, convert)) {
            if constexpr(std::is_rvalue_reference_v<T>) {
                return std::move(caster.value);
            } else {
                return caster.value;
            }
        }
        throw std::runtime_error("Unable to cast Python instance to C++ type");
    }
}  // namespace pybind11