18 #include <frameobject.h> 22 #include <type_traits> 26 #if defined(PYBIND11_HAS_OPTIONAL) 30 #ifdef PYBIND11_HAS_STRING_VIEW 31 # include <string_view> 50 template <
typename Policy>
70 using is_pyobject = std::is_base_of<pyobject_tag, remove_reference_t<T>>;
76 template <
typename Derived>
78 const Derived &
derived()
const {
return static_cast<const Derived &
>(*this); }
122 template <
typename T>
123 bool contains(
T &&item)
const;
141 object call(Args &&...
args)
const;
146 bool is_none()
const {
return derived().ptr() == Py_None; }
156 object operator~()
const;
166 object operator|=(
object_api const &other)
const;
168 object operator&=(
object_api const &other)
const;
170 object operator^=(
object_api const &other)
const;
172 object operator<<=(
object_api const &other)
const;
174 object operator>>=(
object_api const &other)
const;
183 int ref_count()
const {
return static_cast<int>(Py_REFCNT(derived().ptr())); }
193 template <
typename T>
195 std::is_same<T, PyObject *const>,
196 std::is_same<T, std::nullptr_t>>;
200 #if !defined(PYBIND11_HANDLE_REF_DEBUG) && !defined(NDEBUG) 201 # define PYBIND11_HANDLE_REF_DEBUG 215 class handle :
public detail::object_api<handle> {
222 template <
typename T,
230 detail::enable_if_t<detail::all_of<detail::none_of<std::is_base_of<handle, T>,
231 detail::is_pyobj_ptr_or_nullptr_t<T>>,
232 std::is_convertible<T, PyObject *>>
::value,
238 PyObject *
ptr()
const {
return m_ptr; }
239 PyObject *&
ptr() {
return m_ptr; }
247 #ifdef PYBIND11_HANDLE_REF_DEBUG 268 template <
typename T>
271 explicit operator bool()
const {
return m_ptr !=
nullptr; }
277 bool operator==(const
handle &
h)
const {
return m_ptr == h.m_ptr; }
279 bool operator!=(const
handle &
h)
const {
return m_ptr != h.m_ptr; }
281 bool
check()
const {
return m_ptr !=
nullptr; }
284 PyObject *m_ptr =
nullptr;
286 #ifdef PYBIND11_HANDLE_REF_DEBUG 331 PyObject *tmp = m_ptr;
347 if (
this != &
other) {
350 other.m_ptr =
nullptr;
357 template <
typename T>
360 template <
typename T>
369 template <
typename T>
371 template <
typename T>
394 template <
typename T>
407 template <
typename T>
416 if (Py_TYPE(obj) == &PyType_Type) {
417 return reinterpret_cast<PyTypeObject *
>(obj)->tp_name;
419 return Py_TYPE(obj)->tp_name;
432 PyErr_Fetch(&m_type.ptr(), &m_value.ptr(), &m_trace.ptr());
436 "Python error indicator not set.");
439 if (exc_type_name_orig ==
nullptr) {
441 +
" failed to obtain the name " 442 "of the original active exception type.");
444 m_lazy_error_string = exc_type_name_orig;
447 PyErr_NormalizeException(&m_type.ptr(), &m_value.ptr(), &m_trace.ptr());
448 if (m_type.ptr() ==
nullptr) {
450 +
" failed to normalize the " 451 "active exception.");
454 if (exc_type_name_orig ==
nullptr) {
456 +
" failed to obtain the name " 457 "of the normalized active exception type.");
459 if (exc_type_name_norm != m_lazy_error_string) {
460 std::string
msg = std::string(called)
461 +
": MISMATCH of original and normalized " 462 "active exception types: ";
464 msg += m_lazy_error_string;
465 msg +=
" REPLACED BY ";
466 msg += exc_type_name_norm;
467 msg +=
": " + format_value_and_trace();
477 std::string message_error_string;
479 auto value_str = reinterpret_steal<object>(PyObject_Str(m_value.ptr()));
482 result =
"<MESSAGE UNAVAILABLE DUE TO ANOTHER EXCEPTION>";
484 result = value_str.cast<std::string>();
487 result =
"<MESSAGE UNAVAILABLE>";
489 if (result.empty()) {
490 result =
"<EMPTY MESSAGE>";
493 bool have_trace =
false;
495 #if !defined(PYPY_VERSION) 496 auto *tb =
reinterpret_cast<PyTracebackObject *
>(m_trace.ptr());
499 while (tb->tb_next) {
503 PyFrameObject *frame = tb->tb_frame;
505 result +=
"\n\nAt:\n";
507 # if PY_VERSION_HEX >= 0x030900B1 508 PyCodeObject *f_code = PyFrame_GetCode(frame);
510 PyCodeObject *f_code = frame->f_code;
513 int lineno = PyFrame_GetLineNumber(frame);
515 result +=
handle(f_code->co_filename).
cast<std::string>();
517 result += std::to_string(lineno);
519 result +=
handle(f_code->co_name).
cast<std::string>();
522 # if PY_VERSION_HEX >= 0x030900B1 523 auto *b_frame = PyFrame_GetBack(frame);
525 auto *b_frame = frame->f_back;
536 if (!message_error_string.empty()) {
540 result +=
"\nMESSAGE UNAVAILABLE DUE TO EXCEPTION: " + message_error_string;
547 if (!m_lazy_error_string_completed) {
548 m_lazy_error_string +=
": " + format_value_and_trace();
549 m_lazy_error_string_completed =
true;
551 return m_lazy_error_string;
555 if (m_restore_called) {
556 pybind11_fail(
"Internal error: pybind11::detail::error_fetch_and_normalize::restore() " 557 "called a second time. ORIGINAL ERROR: " 560 PyErr_Restore(m_type.inc_ref().ptr(), m_value.inc_ref().ptr(), m_trace.inc_ref().ptr());
561 m_restore_called =
true;
565 return (PyErr_GivenExceptionMatches(m_type.ptr(), exc.
ptr()) != 0);
574 mutable bool m_lazy_error_string_completed =
false;
575 mutable bool m_restore_called =
false;
584 #if defined(_MSC_VER) 585 # pragma warning(push) 586 # pragma warning(disable : 4275 4251) 599 : m_fetched_error{
new detail::error_fetch_and_normalize(
"pybind11::error_already_set"),
600 m_fetched_error_deleter} {}
605 const char *what()
const noexcept
override;
612 void restore() { m_fetched_error->restore(); }
620 PyErr_WriteUnraisable(err_context.
ptr());
638 const object &
type()
const {
return m_fetched_error->m_type; }
639 const object &
value()
const {
return m_fetched_error->m_value; }
640 const object &
trace()
const {
return m_fetched_error->m_trace; }
647 static void m_fetched_error_deleter(detail::error_fetch_and_normalize *raw_ptr);
649 #if defined(_MSC_VER) 650 # pragma warning(pop) 659 PyObject *exc =
nullptr, *val =
nullptr, *val2 =
nullptr, *tb =
nullptr;
661 assert(PyErr_Occurred());
662 PyErr_Fetch(&exc, &val, &tb);
663 PyErr_NormalizeException(&exc, &val, &tb);
665 PyException_SetTraceback(val, tb);
669 assert(!PyErr_Occurred());
671 PyErr_SetString(type, message);
673 PyErr_Fetch(&exc, &val2, &tb);
674 PyErr_NormalizeException(&exc, &val2, &tb);
676 PyException_SetCause(val2, val);
677 PyException_SetContext(val2, val);
678 PyErr_Restore(exc, val2, tb);
701 return T::check_(obj);
713 return obj.
ptr() !=
nullptr;
719 const auto result = PyObject_IsInstance(obj.
ptr(), type.
ptr());
729 return PyObject_HasAttr(obj.
ptr(), name.
ptr()) == 1;
733 return PyObject_HasAttrString(obj.
ptr(),
name) == 1;
737 if (PyObject_DelAttr(obj.
ptr(), name.
ptr()) != 0) {
743 if (PyObject_DelAttrString(obj.
ptr(),
name) != 0) {
749 PyObject *
result = PyObject_GetAttr(obj.
ptr(), name.
ptr());
753 return reinterpret_steal<object>(
result);
761 return reinterpret_steal<object>(
result);
765 if (PyObject *
result = PyObject_GetAttr(obj.
ptr(), name.
ptr())) {
766 return reinterpret_steal<object>(
result);
769 return reinterpret_borrow<object>(default_);
773 if (PyObject *
result = PyObject_GetAttrString(obj.
ptr(),
name)) {
774 return reinterpret_steal<object>(
result);
777 return reinterpret_borrow<object>(default_);
781 if (PyObject_SetAttr(obj.
ptr(), name.
ptr(), value.
ptr()) != 0) {
787 if (PyObject_SetAttrString(obj.
ptr(),
name, value.
ptr()) != 0) {
793 auto h = PyObject_Hash(obj.
ptr());
805 if (PyInstanceMethod_Check(
value.ptr())) {
806 value = PyInstanceMethod_GET_FUNCTION(
value.ptr());
807 }
else if (PyMethod_Check(
value.ptr())) {
819 PyObject *kv =
nullptr, *rv =
nullptr;
820 kv = PyUnicode_FromString(key);
825 rv = PyDict_GetItemWithError(v, kv);
827 if (rv ==
nullptr && PyErr_Occurred()) {
834 PyObject *rv = PyDict_GetItemWithError(v, key);
835 if (rv ==
nullptr && PyErr_Occurred()) {
846 return std::forward<T>(o);
854 #if defined(_MSC_VER) && _MSC_VER < 1920 855 # pragma warning(push) 856 # pragma warning(disable : 4522) // warning C4522: multiple assignment operators specified 858 template <
typename Policy>
872 template <
typename T>
876 template <
typename T>
881 template <
typename T = Policy>
883 "Use of obj.attr(...) as bool is deprecated in favor of pybind11::hasattr(obj, ...)")
890 template <
typename T = Policy>
894 return obj.contains(
key);
898 operator object()
const {
return get_cache(); }
899 PyObject *ptr()
const {
return get_cache().ptr(); }
900 template <
typename T>
902 return get_cache().template cast<T>();
906 static object ensure_object(
object &&o) {
return std::move(o); }
921 #if defined(_MSC_VER) && _MSC_VER < 1920 922 # pragma warning(pop) 942 PyObject *
result = PyObject_GetItem(obj.ptr(),
key.ptr());
946 return reinterpret_steal<object>(
result);
950 if (PyObject_SetItem(obj.ptr(), key.ptr(), val.ptr()) != 0) {
960 static object get(
handle obj,
const IdxType &index) {
965 return reinterpret_steal<object>(
result);
971 if (PySequence_SetItem(obj.ptr(),
ssize_t_cast(index), val.ptr()) != 0) {
981 static object get(
handle obj,
const IdxType &index) {
986 return reinterpret_borrow<object>(
result);
992 if (PyList_SetItem(obj.ptr(),
ssize_t_cast(index), val.inc_ref().ptr()) != 0) {
1002 static object get(
handle obj,
const IdxType &index) {
1007 return reinterpret_borrow<object>(
result);
1013 if (PyTuple_SetItem(obj.ptr(),
ssize_t_cast(index), val.inc_ref().ptr()) != 0) {
1020 template <
typename Policy>
1042 Policy::increment();
1047 Policy::increment();
1051 Policy::decrement();
1056 Policy::decrement();
1064 Policy::advance(-n);
1089 template <
typename T>
1164 PyObject *
key =
nullptr, *value =
nullptr;
1169 #if !defined(PYPY_VERSION) 1181 PyObject *
iter = PyObject_GetIter(obj);
1193 #ifdef PYBIND11_STR_LEGACY_PERMISSIVE 1194 inline bool PyUnicode_Check_Permissive(PyObject *o) {
1197 # define PYBIND11_STR_CHECK_FUN detail::PyUnicode_Check_Permissive 1199 # define PYBIND11_STR_CHECK_FUN PyUnicode_Check 1216 template <
typename T>
1218 template <
typename T>
1220 template <
typename T>
1222 template <
typename T>
1224 template <
typename T>
1228 template <return_value_policy policy = return_value_policy::automatic_reference>
1230 template <return_value_policy policy = return_value_policy::automatic_reference>
1239 #define PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun) \ 1241 PYBIND11_DEPRECATED("Use reinterpret_borrow<" #Name ">() or reinterpret_steal<" #Name ">()") \ 1242 Name(handle h, bool is_borrowed) \ 1243 : Parent(is_borrowed ? Parent(h, borrowed_t{}) : Parent(h, stolen_t{})) {} \ 1244 Name(handle h, borrowed_t) : Parent(h, borrowed_t{}) {} \ 1245 Name(handle h, stolen_t) : Parent(h, stolen_t{}) {} \ 1246 PYBIND11_DEPRECATED("Use py::isinstance<py::python_type>(obj) instead") \ 1247 bool check() const { return m_ptr != nullptr && (CheckFun(m_ptr) != 0); } \ 1248 static bool check_(handle h) { return h.ptr() != nullptr && CheckFun(h.ptr()); } \ 1249 template <typename Policy_> \ 1250 Name(const ::pybind11::detail::accessor<Policy_> &a) : Name(object(a)) {} 1252 #define PYBIND11_OBJECT_CVT(Name, Parent, CheckFun, ConvertFun) \ 1253 PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun) \ 1256 Name(const object &o) \ 1257 : Parent(check_(o) ? o.inc_ref().ptr() : ConvertFun(o.ptr()), stolen_t{}) { \ 1259 throw ::pybind11::error_already_set(); \ 1262 Name(object &&o) : Parent(check_(o) ? o.release().ptr() : ConvertFun(o.ptr()), stolen_t{}) { \ 1264 throw ::pybind11::error_already_set(); \ 1267 #define PYBIND11_OBJECT_CVT_DEFAULT(Name, Parent, CheckFun, ConvertFun) \ 1268 PYBIND11_OBJECT_CVT(Name, Parent, CheckFun, ConvertFun) \ 1269 Name() : Parent() {} 1271 #define PYBIND11_OBJECT_CHECK_FAILED(Name, o_ptr) \ 1272 ::pybind11::type_error("Object of type '" \ 1273 + ::pybind11::detail::get_fully_qualified_tp_name(Py_TYPE(o_ptr)) \ 1274 + "' is not an instance of '" #Name "'") 1276 #define PYBIND11_OBJECT(Name, Parent, CheckFun) \ 1277 PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun) \ 1280 Name(const object &o) : Parent(o) { \ 1281 if (m_ptr && !check_(m_ptr)) \ 1282 throw PYBIND11_OBJECT_CHECK_FAILED(Name, m_ptr); \ 1285 Name(object &&o) : Parent(std::move(o)) { \ 1286 if (m_ptr && !check_(m_ptr)) \ 1287 throw PYBIND11_OBJECT_CHECK_FAILED(Name, m_ptr); \ 1290 #define PYBIND11_OBJECT_DEFAULT(Name, Parent, CheckFun) \ 1291 PYBIND11_OBJECT(Name, Parent, CheckFun) \ 1292 Name() : Parent() {} 1328 if (m_ptr && !value.ptr()) {
1329 auto &
self =
const_cast<iterator &
>(*this);
1360 value = reinterpret_steal<object>(PyIter_Next(m_ptr));
1361 if (PyErr_Occurred()) {
1384 template <
typename T>
1385 static handle handle_of();
1390 template <
typename T>
1427 #ifdef PYBIND11_HAS_STRING_VIEW 1431 str(
T s) :
str(s.data(), s.size()) {}
1433 # ifdef PYBIND11_HAS_U8STRING 1436 str(std::u8string_view s) :
str(reinterpret_cast<const char *>(s.data()), s.size()) {}
1454 operator std::string()
const {
1455 object temp = *
this;
1456 if (PyUnicode_Check(m_ptr)) {
1457 temp = reinterpret_steal<object>(PyUnicode_AsUTF8String(m_ptr));
1464 if (PyBytes_AsStringAndSize(temp.
ptr(), &buffer, &length) != 0) {
1467 return std::string(buffer, (
size_t) length);
1470 template <
typename... Args>
1472 return attr(
"format")(std::forward<Args>(
args)...);
1478 PyObject *str_value = PyObject_Str(op);
1488 inline str operator"" _s(
const char *
s,
size_t size) {
return {
s, size}; }
1520 operator std::string()
const {
return string_op<std::string>(); }
1522 #ifdef PYBIND11_HAS_STRING_VIEW 1532 operator std::string_view()
const {
return string_op<std::string_view>(); }
1535 template <
typename T>
1539 if (PyBytes_AsStringAndSize(m_ptr, &buffer, &length) != 0) {
1542 return {buffer,
static_cast<size_t>(length)};
1551 if (PyUnicode_Check(s.ptr())) {
1552 temp = reinterpret_steal<object>(PyUnicode_AsUTF8String(s.ptr()));
1559 if (PyBytes_AsStringAndSize(temp.
ptr(), &buffer, &length) != 0) {
1566 m_ptr = obj.release().
ptr();
1572 if (PyBytes_AsStringAndSize(b.
ptr(), &buffer, &length) != 0) {
1575 auto obj = reinterpret_steal<object>(PyUnicode_FromStringAndSize(buffer, length));
1579 m_ptr = obj.release().
ptr();
1600 size_t size()
const {
return static_cast<size_t>(PyByteArray_Size(m_ptr)); }
1602 explicit operator std::string()
const {
1603 char *
buffer = PyByteArray_AS_STRING(m_ptr);
1605 return std::string(buffer, static_cast<size_t>(size));
1634 operator bool()
const {
return (m_ptr !=
nullptr) && PyLong_AsLong(m_ptr) != 0; }
1639 const auto value = PyObject_IsTrue(op);
1652 template <
typename Un
signed>
1655 unsigned long v = PyLong_AsUnsignedLong(o);
1656 return v == (
unsigned long) -1 && PyErr_Occurred() ? (Unsigned) -1 : (Unsigned)
v;
1658 unsigned long long v = PyLong_AsUnsignedLongLong(o);
1659 return v == (
unsigned long long) -1 && PyErr_Occurred() ? (Unsigned) -1 : (Unsigned)
v;
1673 m_ptr = PyLong_FromLong((
long) value);
1675 m_ptr = PyLong_FromUnsignedLong((
unsigned long) value);
1679 m_ptr = PyLong_FromLongLong((
long long) value);
1681 m_ptr = PyLong_FromUnsignedLongLong((
unsigned long long) value);
1691 operator T()
const {
1693 :
sizeof(
T) <=
sizeof(long) ? (
T) PyLong_AsLong(m_ptr)
1715 operator float()
const {
return (
float) PyFloat_AsDouble(m_ptr); }
1717 operator double()
const {
return (
double) PyFloat_AsDouble(m_ptr); }
1724 :
object(PyWeakref_NewRef(obj.
ptr(), callback.ptr()),
stolen_t{}) {
1726 if (PyErr_Occurred()) {
1734 static PyObject *
raw_weakref(PyObject *o) {
return PyWeakref_NewRef(o,
nullptr); }
1741 :
object(PySlice_New(start.ptr(), stop.ptr(),
step.ptr()),
stolen_t{}) {
1747 #ifdef PYBIND11_HAS_OPTIONAL 1748 slice(std::optional<ssize_t> start, std::optional<ssize_t> stop, std::optional<ssize_t>
step)
1749 :
slice(index_to_object(start), index_to_object(stop), index_to_object(
step)) {}
1756 compute(
size_t length,
size_t *start,
size_t *stop,
size_t *
step,
size_t *slicelength)
const {
1767 return PySlice_GetIndicesEx(
1773 template <
typename T>
1783 capsule(PyObject *ptr,
bool is_borrowed)
1787 const char *
name =
nullptr,
1788 void (*destructor)(PyObject *) =
nullptr)
1796 capsule(
const void *
value,
void (*destruct)(PyObject *))
1803 capsule(
const void *
value,
void (*destructor)(
void *)) {
1804 m_ptr = PyCapsule_New(const_cast<void *>(
value),
nullptr, [](PyObject *o) {
1807 auto destructor =
reinterpret_cast<void (*)(
void *)
>(PyCapsule_GetContext(o));
1808 if (destructor ==
nullptr) {
1809 if (PyErr_Occurred()) {
1814 const char *
name = get_name_in_error_scope(o);
1815 void *ptr = PyCapsule_GetPointer(o, name);
1816 if (ptr ==
nullptr) {
1822 if (!m_ptr || PyCapsule_SetContext(m_ptr, (
void *) destructor) != 0) {
1827 explicit capsule(
void (*destructor)()) {
1828 m_ptr = PyCapsule_New(reinterpret_cast<void *>(destructor),
nullptr, [](PyObject *o) {
1829 const char *
name = get_name_in_error_scope(o);
1830 auto destructor =
reinterpret_cast<void (*)()
>(PyCapsule_GetPointer(o, name));
1831 if (destructor ==
nullptr) {
1842 template <
typename T>
1843 operator T *()
const {
1844 return get_pointer<T>();
1848 template <
typename T =
void>
1849 T *get_pointer()
const {
1851 T *
result =
static_cast<T *
>(PyCapsule_GetPointer(m_ptr,
name));
1859 void set_pointer(
const void *
value) {
1860 if (PyCapsule_SetPointer(m_ptr, const_cast<void *>(value)) != 0) {
1865 const char *
name()
const {
1866 const char *
name = PyCapsule_GetName(m_ptr);
1867 if ((name ==
nullptr) && PyErr_Occurred()) {
1874 void set_name(
const char *new_name) {
1875 if (PyCapsule_SetName(m_ptr, new_name) != 0) {
1881 static const char *get_name_in_error_scope(PyObject *o) {
1884 const char *
name = PyCapsule_GetName(o);
1885 if ((name ==
nullptr) && PyErr_Occurred()) {
1887 PyErr_WriteUnraisable(o);
1897 template <
typename SzType =
ssize_t,
1905 size_t size()
const {
return (
size_t) PyTuple_Size(m_ptr); }
1910 return object::operator[](std::forward<T>(o));
1919 template <
typename... Args>
1921 return detail::all_of<detail::is_keyword_or_ds<Args>...>
::value;
1932 template <
typename... Args,
1939 size_t size()
const {
return (
size_t) PyDict_Size(m_ptr); }
1944 template <
typename T>
1952 if (PyDict_Check(op)) {
1955 return PyObject_CallFunctionObjArgs((PyObject *) &PyDict_Type, op,
nullptr);
1973 return object::operator[](std::forward<T>(o));
1982 template <
typename SzType =
ssize_t,
1990 size_t size()
const {
return (
size_t) PyList_Size(m_ptr); }
1995 return object::operator[](std::forward<T>(o));
1999 template <
typename T>
2003 template <
typename IdxType,
2006 void insert(
const IdxType &index, ValType &&val) {
2022 size_t size()
const {
return static_cast<size_t>(PySet_Size(m_ptr)); }
2024 template <
typename T>
2038 template <
typename T>
2055 if (fun && PyCFunction_Check(fun.
ptr())) {
2073 int flags = PyBUF_STRIDES | PyBUF_FORMAT;
2075 flags |= PyBUF_WRITABLE;
2077 auto *
view =
new Py_buffer();
2078 if (PyObject_GetBuffer(m_ptr,
view, flags) != 0) {
2101 pybind11_fail(
"Prohibited to create memoryview without Py_buffer");
2104 m_ptr = (info.view()->obj) ? PyMemoryView_FromObject(info.view()->obj)
2105 : PyMemoryView_FromBuffer(info.view());
2107 pybind11_fail(
"Unable to create memoryview from buffer descriptor");
2138 detail::any_container<ssize_t> shape,
2139 detail::any_container<ssize_t>
strides,
2140 bool readonly =
false);
2145 detail::any_container<ssize_t> shape,
2146 detail::any_container<ssize_t>
strides) {
2148 const_cast<void *>(ptr), itemsize, format, std::move(shape), std::move(strides),
true);
2151 template <
typename T>
2153 detail::any_container<ssize_t> shape,
2154 detail::any_container<ssize_t>
strides,
2155 bool readonly =
false) {
2164 template <
typename T>
2166 detail::any_container<ssize_t> shape,
2167 detail::any_container<ssize_t>
strides) {
2169 const_cast<T *>(ptr), std::move(shape), std::move(strides),
true);
2185 PyObject *ptr = PyMemoryView_FromMemory(
2186 reinterpret_cast<char *>(mem), size, (readonly) ? PyBUF_READ : PyBUF_WRITE);
2197 #ifdef PYBIND11_HAS_STRING_VIEW 2198 static memoryview from_memory(std::string_view mem) {
2199 return from_memory(const_cast<char *>(mem.data()), static_cast<ssize_t>(mem.size()),
true);
2208 detail::any_container<ssize_t> shape,
2209 detail::any_container<ssize_t>
strides,
2211 size_t ndim = shape->size();
2213 pybind11_fail(
"memoryview: shape length doesn't match strides length");
2216 for (
size_t i = 0;
i < ndim; ++
i) {
2217 size *= (*shape)[
i];
2222 view.len = size * itemsize;
2223 view.readonly =
static_cast<int>(readonly);
2224 view.itemsize = itemsize;
2225 view.format =
const_cast<char *
>(
format);
2226 view.ndim =
static_cast<int>(ndim);
2227 view.shape = shape->data();
2228 view.strides =
strides->data();
2229 view.suboffsets =
nullptr;
2230 view.internal =
nullptr;
2231 PyObject *obj = PyMemoryView_FromBuffer(&view);
2266 PyObject *str_value = PyObject_Repr(h.
ptr());
2270 return reinterpret_steal<str>(str_value);
2274 PyObject *
result = PyObject_GetIter(obj.
ptr());
2278 return reinterpret_steal<iterator>(
result);
2283 template <
typename D>
2285 return iter(derived());
2287 template <
typename D>
2291 template <
typename D>
2293 return {derived(), reinterpret_borrow<object>(
key)};
2295 template <
typename D>
2297 return {derived(), std::move(
key)};
2299 template <
typename D>
2303 template <
typename D>
2305 return {derived(), reinterpret_borrow<object>(
key)};
2307 template <
typename D>
2309 return {derived(), std::move(
key)};
2311 template <
typename D>
2313 return {derived(), key};
2315 template <
typename D>
2319 template <
typename D>
2320 template <
typename T>
2322 return attr(
"__contains__")(std::forward<T>(item)).template cast<bool>();
2325 template <
typename D>
2330 template <
typename D>
2332 return attr(
"__doc__");
2335 template <
typename D>
2340 template <
typename D>
2342 int rv = PyObject_RichCompareBool(derived().ptr(), other.
derived().ptr(),
value);
2349 #define PYBIND11_MATH_OPERATOR_UNARY(op, fn) \ 2350 template <typename D> \ 2351 object object_api<D>::op() const { \ 2352 object result = reinterpret_steal<object>(fn(derived().ptr())); \ 2353 if (!result.ptr()) \ 2354 throw error_already_set(); \ 2358 #define PYBIND11_MATH_OPERATOR_BINARY(op, fn) \ 2359 template <typename D> \ 2360 object object_api<D>::op(object_api const &other) const { \ 2361 object result = reinterpret_steal<object>(fn(derived().ptr(), other.derived().ptr())); \ 2362 if (!result.ptr()) \ 2363 throw error_already_set(); \ 2388 #undef PYBIND11_MATH_OPERATOR_UNARY 2389 #undef PYBIND11_MATH_OPERATOR_BINARY
bytearray(const char *c, const SzType &n)
detail::list_iterator end() const
const gtsam::Symbol key('X', 0)
Quick proxy class needed to implement operator-> for iterators which can't return pointers...
detail::any_of< std::is_same< T, PyObject * >, std::is_same< T, PyObject *const >, std::is_same< T, std::nullptr_t > > is_pyobj_ptr_or_nullptr_t
Vector3_ operator*(const Double_ &s, const Vector3_ &v)
typename Policy::pointer pointer
def step(data, isam, result, truth, currPoseIndex)
detail::sequence_accessor operator[](size_t index) const
static iterator sentinel()
slice(ssize_t start_, ssize_t stop_, ssize_t step_)
bool equal(const sequence_fast_readonly &b) const
generic_iterator< iterator_policies::sequence_slow_readwrite > sequence_iterator
const object & value() const
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 & operator+=(bfloat16 &a, const bfloat16 &b)
static handle handle_of()
accessor< accessor_policies::list_item > list_accessor
bool PyNone_Check(PyObject *o)
typename Policy::reference reference
bool hasattr(handle obj, handle name)
void discard_as_unraisable(const char *err_context)
detail::item_accessor operator[](T &&o) const
friend It operator+(const It &a, difference_type n)
reference operator[](difference_type n) const
friend It operator-(const It &a, difference_type n)
bool contains(T &&item) const
Check if the given item is contained within this object, i.e. item in obj.
pointer operator->() const
bytes(const std::string &s)
std::is_same< args_proxy, T > is_s_unpacking
bool operator>(object_api const &other) const
EIGEN_DEVICE_FUNC static EIGEN_ALWAYS_INLINE std::size_t size()
PyObject * dict_getitemstring(PyObject *v, const char *key)
pybind11::str str() const
EIGEN_DEVICE_FUNC const CwiseBinaryOp< internal::scalar_boolean_xor_op, const Derived, const OtherDerived > operator^(const EIGEN_CURRENT_STORAGE_BASE_CLASS< OtherDerived > &other) const
iterator end() const
Return a sentinel which ends iteration.
bool isinstance_generic(handle obj, const std::type_info &tp)
bool isinstance< handle >(handle)=delete
static PyObject * raw_bool(PyObject *op)
Return the truth value of an object – always returns a new reference.
object(handle h, stolen_t)
PYBIND11_DEPRECATED("make_simple_namespace should be replaced with " "py::module_::import(\ypes\.attr(\impleNamespace\ ") object make_simple_namespace(Args &&...args_)
accessor(handle obj, key_type key)
object(handle h, borrowed_t)
static PyObject * raw_weakref(PyObject *o)
#define PYBIND11_LONG_CHECK(o)
bool matches(handle exc) const
detail::list_accessor operator[](size_t index) const
object(object &&other) noexcept
Move constructor; steals the object from other and preserves its reference count. ...
#define PYBIND11_OBJECT_CVT_DEFAULT(Name, Parent, CheckFun, ConvertFun)
std::string error_string()
args_proxy operator*() const
#define PYBIND11_SILENCE_MSVC_C4127(...)
bool operator<=(object_api const &other) const
#define PYBIND11_BYTES_FROM_STRING_AND_SIZE
friend bool operator<=(const It &a, const It &b)
set noclip points set clip one set noclip two set bar set border lt lw set xdata set ydata set zdata set x2data set y2data set boxwidth set dummy y set format x g set format y g set format x2 g set format y2 g set format z g set angles radians set nogrid set key title set key left top Right noreverse box linetype linewidth samplen spacing width set nolabel set noarrow set nologscale set logscale x set set pointsize set encoding default set nopolar set noparametric set view
sequence_slow_readwrite(handle obj, ssize_t index)
std::string m_lazy_error_string
friend bool operator>=(const It &a, const It &b)
typename Policy::iterator_category iterator_category
void raise_from(PyObject *type, const char *message)
void operator=(const accessor &a) &
accessor< accessor_policies::sequence_item > sequence_accessor
iterator iter(handle obj)
It & operator+=(difference_type n)
DiscreteKeys operator &(const DiscreteKey &key1, const DiscreteKey &key2)
Create a list from two keys.
#define PYBIND11_STR_CHECK_FUN
reference operator*() const
bool operator>=(object_api const &other) const
str_attr_accessor doc() const
Get or set the object's docstring, i.e. obj.__doc__.
friend bool operator!=(const iterator &a, const iterator &b)
bytes(const char *c, const SzType &n)
STL iterator template used for tuple, list, sequence and dict.
reference dereference() const
bool isinstance(handle obj)
void delattr(handle obj, handle name)
detail::dict_iterator begin() const
str(const std::string &s)
bool PyStaticMethod_Check(PyObject *o)
friend bool operator==(const iterator &a, const iterator &b)
static std::size_t inc_ref_counter(std::size_t add)
It & operator-=(difference_type n)
#define PYBIND11_NAMESPACE
bool equal(const sequence_slow_readwrite &b) const
static object ensure_object(handle h)
#define PYBIND11_OBJECT_CVT(Name, Parent, CheckFun, ConvertFun)
static memoryview from_memory(void *mem, ssize_t size, bool readonly=false)
detail::tuple_iterator begin() const
detail::dict_iterator end() const
static memoryview from_buffer(void *ptr, ssize_t itemsize, const char *format, detail::any_container< ssize_t > shape, detail::any_container< ssize_t > strides, bool readonly=false)
generic_iterator(handle seq, ssize_t index)
PyExc_RuntimeError [[noreturn]] PYBIND11_NOINLINE void pybind11_fail(const char *reason)
Used internally.
static std::size_t inc_ref_counter()
ssize_t distance_to(const sequence_fast_readonly &b) const
dict_readonly(handle obj, ssize_t pos)
const handle & inc_ref() const &
T reinterpret_borrow(handle h)
detail::enable_if_t<!detail::move_never< T >::value, T > move(object &&obj)
auto object_or_cast(T &&o) -> decltype(std::forward< T >(o))
accessor< accessor_policies::tuple_item > tuple_accessor
reference dereference() const
std::ostream & operator<<(std::ostream &s, const Jet< T, N > &z)
kwargs_proxy operator*() const
ssize_t ssize_t_cast(const IntType &val)
int ref_count() const
Return the object's current reference count.
std::is_same< kwargs_proxy, T > is_ds_unpacking
#define PYBIND11_BYTES_CHECK
istream & operator>>(istream &inputStream, Matrix &destinationMatrix)
item_accessor operator[](handle key) const
void operator=(T &&value) &
error_fetch_and_normalize(const char *called)
handle(T &obj)
Enable implicit conversion through T::operator PyObject *().
object & operator=(const object &other)
bool compute(size_t length, size_t *start, size_t *stop, size_t *step, size_t *slicelength) const
friend bool operator<(const It &a, const It &b)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_quotient_op< Scalar, typename OtherDerived::Scalar >, const Derived, const OtherDerived > operator/(const EIGEN_CURRENT_STORAGE_BASE_CLASS< OtherDerived > &other) const
friend bool operator==(const It &a, const It &b)
EIGEN_ALWAYS_INLINE DSizes< IndexType, NumDims > strides(const DSizes< IndexType, NumDims > &dimensions)
std::random_access_iterator_tag iterator_category
static PyObject * raw_str(PyObject *op)
Return string representation – always returns a new reference, even if already a str...
bool equal(object_api const &other) const
Equivalent to obj == other in Python.
Array< int, Dynamic, 1 > v
void discard_as_unraisable(object err_context)
EIGEN_DEVICE_FUNC NewType cast(const OldType &x)
Eigen::Triplet< double > T
#define PYBIND11_OBJECT_DEFAULT(Name, Parent, CheckFun)
std::string const & error_string() const
#define PYBIND11_FROM_STRING
bool is_cpp_function() const
bool rich_compare(object_api const &other, int value) const
void operator=(T &&value) &&
std::random_access_iterator_tag iterator_category
object(const object &o)
Copy constructor; always increases the reference count.
std::is_base_of< arg, T > is_keyword
Python argument categories (using PEP 448 terms)
const handle & dec_ref() const &
detail::item_accessor operator[](T &&o) const
str format(Args &&...args) const
const object & type() const
Unsigned as_unsigned(PyObject *o)
static PyObject * raw_dict(PyObject *op)
Call the dict Python type – always returns a new reference.
void set(Container &c, Position position, const Value &value)
handle get_function(handle value)
ssize_t distance_to(const sequence_slow_readwrite &b) const
const object & trace() const
bool operator<(object_api const &other) const
PyObject * dict_getitem(PyObject *v, PyObject *key)
bool not_equal(object_api const &other) const
detail::list_iterator begin() const
void operator=(const accessor &a) &&
void insert(const IdxType &index, ValType &&val)
const Derived & derived() const
str(const char *c, const SzType &n)
arrow_proxy(T &&value) noexcept
Python's dictionary protocol permits this to be a forward iterator.
friend It operator+(difference_type n, const It &b)
static memoryview from_buffer(const T *ptr, detail::any_container< ssize_t > shape, detail::any_container< ssize_t > strides)
#define PYBIND11_SLICE_OBJECT
Full read and write access using the sequence protocol: see detail::sequence_accessor ...
#define PYBIND11_EXPORT_EXCEPTION
static type of(handle h)
Return a type object from a handle or an object.
internal::enable_if<!(symbolic::is_symbolic< FirstType >::value||symbolic::is_symbolic< LastType >::value), ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, Index > >::type seq(FirstType f, LastType l)
Helper class which collects positional, keyword, * and ** arguments for a Python function call...
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 & operator/=(bfloat16 &a, const bfloat16 &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 & operator*=(bfloat16 &a, const bfloat16 &b)
Tag and check to identify a class which implements the Python object API.
void check(bool b, bool ref)
pointer operator->() const
object & get_cache() const
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 & operator-=(bfloat16 &a, const bfloat16 &b)
#define PYBIND11_LONG_AS_LONGLONG(o)
std::input_iterator_tag iterator_category
detail::sequence_iterator end() const
std::pair< handle, handle > value_type
constexpr bool args_are_all_keyword_or_ds()
std::shared_ptr< detail::error_fetch_and_normalize > m_fetched_error
reference operator*() const
generic_iterator< iterator_policies::sequence_fast_readonly > tuple_iterator
object getattr(handle obj, handle name)
RAII wrapper that temporarily clears any Python error state.
bool PyEllipsis_Check(PyObject *o)
bool PyIterable_Check(PyObject *obj)
reference dereference() const
bytearray(const std::string &s)
typename deferred_type< T, Us... >::type deferred_t
static EIGEN_DEPRECATED const end_t end
std::string format(const std::string &str, const std::vector< std::string > &find, const std::vector< std::string > &replace)
friend difference_type operator-(const It &a, const It &b)
detail::tuple_accessor operator[](size_t index) const
#define PYBIND11_MATH_OPERATOR_BINARY(op, fn)
obj_attr_accessor attr(handle key) const
Wraps an arbitrary C++ function/method/lambda function/.. into a callable Python object.
std::string format_value_and_trace() const
size_t len_hint(handle h)
#define PYBIND11_MATH_OPERATOR_UNARY(op, fn)
static memoryview from_buffer(T *ptr, detail::any_container< ssize_t > shape, detail::any_container< ssize_t > strides, bool readonly=false)
typename std::enable_if< B, T >::type enable_if_t
from cpp_future import (convenient aliases from C++14/17)
Jet< T, N > operator-(const Jet< T, N > &f)
object & operator=(object &&other) noexcept
bool compute(ssize_t length, ssize_t *start, ssize_t *stop, ssize_t *step, ssize_t *slicelength) const
graph add(PriorFactor< Pose2 >(1, priorMean, priorNoise))
typename Policy::value_type value_type
std::forward_iterator_tag iterator_category
T reinterpret_steal(handle h)
bool isinstance< object >(handle obj)
detail::tuple_iterator end() const
Annotation for function names.
generic_iterator< iterator_policies::sequence_fast_readonly > list_iterator
friend bool operator>(const It &a, const It &b)
int EIGEN_BLAS_FUNC() copy(int *n, RealScalar *px, int *incx, RealScalar *py, int *incy)
generic_iterator< iterator_policies::dict_readonly > dict_iterator
Signature operator|(const DiscreteKey &key, const DiscreteKey &parent)
Information record describing a Python buffer object.
PyObject * ptr() const
Return the underlying PyObject * pointer.
bool equal(const dict_readonly &b) const
bool matches(handle exc) const
Container::iterator get(Container &c, Position position)
accessor< accessor_policies::generic_item > item_accessor
size_t len(handle h)
Get the length of a Python object.
const value_type reference
typename Policy::key_type key_type
internal::enable_if< internal::valid_indexed_view_overload< RowIndices, ColIndices >::value &&internal::traits< typename EIGEN_INDEXED_VIEW_METHOD_TYPE< RowIndices, ColIndices >::type >::ReturnAsIndexedView, typename EIGEN_INDEXED_VIEW_METHOD_TYPE< RowIndices, ColIndices >::type >::type operator()(const RowIndices &rowIndices, const ColIndices &colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST
void setattr(handle obj, handle name, handle value)
bool contains(T &&key) const
return_value_policy
Approach used to cast a previously unknown C++ instance into a Python object.
~object()
Destructor; automatically calls handle::dec_ref()
static memoryview from_memory(const void *mem, ssize_t size)
static object index_to_object(T index)
Jet< T, N > const & operator+(const Jet< T, N > &f)
detail::sequence_iterator begin() const
#define PYBIND11_NAMESPACE_END(name)
static memoryview from_buffer(const void *ptr, ssize_t itemsize, const char *format, detail::any_container< ssize_t > shape, detail::any_container< ssize_t > strides)
bool contains(T &&val) const
friend bool operator!=(const It &a, const It &b)
#define PYBIND11_OBJECT(Name, Parent, CheckFun)
std::is_base_of< pyobject_tag, remove_reference_t< T > > is_pyobject
bool is(object_api const &other) const
Equivalent to obj is other in Python.
#define PYBIND11_NAMESPACE_BEGIN(name)
PYBIND11_DEPRECATED("Use of obj.attr(...) as bool is deprecated in favor of pybind11::hasattr(obj, ...)") explicit operator enable_if_t< std
sequence_fast_readonly(handle obj, ssize_t n)
const char * obj_class_name(PyObject *obj)
#define PYBIND11_BYTES_FROM_STRING
bool is_none() const
Equivalent to obj is None in Python.
detail::item_accessor operator[](T &&o) const
Lightweight iterator policy using just a simple pointer: see PySequence_Fast_ITEMS ...