limited api: Remove PyTuple_GET_ITEM, PyTuple_SET_ITEM, and PyTuple_GET_SIZE macros

Removing old macros for compatibility with the limited api, and refactoring some of their usages Change-Id: I33954199d2ef9884c64b963863b97aed851c440f Pick-to: 6.8 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io>
author: Cristián Maureira-Fredes <cristian.maureira-fredes@qt.io> 2024-11-06 11:10:03 +0100
committer: Cristián Maureira-Fredes <Cristian.Maureira-Fredes@qt.io> 2024-11-08 14:24:28 +0100
commit: 65a9ae9a853fa68ff997edbe3d6fd4eed022f1a0 (patch)
tree: 735b82851430560a81ec28a848cdd09fdb2c36c0
parent: c951f11196d0572b7250a74197937c02b74604dd (diff)
43 files changed, 222 insertions, 224 deletions
diff --git a/sources/pyside6/PySide6/QtCore/glue/core_snippets.cpp b/sources/pyside6/PySide6/QtCore/glue/core_snippets.cpp
index 3f8172871..c073c8bc1 100644
--- a/sources/pyside6/PySide6/QtCore/glue/core_snippets.cpp
+++ b/sources/pyside6/PySide6/QtCore/glue/core_snippets.cpp
@@ -45,8 +45,8 @@ QMetaType QVariant_resolveMetaType(PyTypeObject *type)
     // that has added any python fields or slots to its object layout.
     // See https://mail.python.org/pipermail/python-list/2009-January/520733.html
     if (type->tp_bases) {
-        for (Py_ssize_t i = 0, size = PyTuple_GET_SIZE(type->tp_bases); i < size; ++i) {
-            auto baseType = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(type->tp_bases, i));
+        for (Py_ssize_t i = 0, size = PyTuple_Size(type->tp_bases); i < size; ++i) {
+            auto baseType = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(type->tp_bases, i));
             const QMetaType derived = QVariant_resolveMetaType(baseType);
             if (derived.isValid())
                 return derived;
@@ -224,13 +224,13 @@ void qObjectFindChildren(const QObject *parent, const QRegularExpression &patter
 QString qObjectTr(PyTypeObject *type, const char *sourceText, const char *disambiguation, int n)
 {
     PyObject *mro = type->tp_mro;
-    auto len = PyTuple_GET_SIZE(mro);
+    auto len = PyTuple_Size(mro);
     QString result = QString::fromUtf8(sourceText);
     QString oldResult = result;
     static auto *sbkObjectType = reinterpret_cast<PyTypeObject *>(SbkObject_TypeF());
     for (Py_ssize_t idx = 0; idx < len - 1; ++idx) {
         // Skip the last class which is `object`.
-        auto *type = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
+        auto *type = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(mro, idx));
         if (type == sbkObjectType)
             continue;
         const char *context = type->tp_name;
diff --git a/sources/pyside6/PySide6/QtDesigner/qpydesignercustomwidgetcollection.cpp b/sources/pyside6/PySide6/QtDesigner/qpydesignercustomwidgetcollection.cpp
index 31f8ec152..19e974233 100644
--- a/sources/pyside6/PySide6/QtDesigner/qpydesignercustomwidgetcollection.cpp
+++ b/sources/pyside6/PySide6/QtDesigner/qpydesignercustomwidgetcollection.cpp
@@ -114,7 +114,7 @@ QWidget *PyDesignerCustomWidget::createWidget(QWidget *parent)
     }
 
     Shiboken::AutoDecRef pyArgs(PyTuple_New(1));
-    PyTuple_SET_ITEM(pyArgs, 0, pyParent); // tuple will keep pyParent reference
+    PyTuple_SetItem(pyArgs, 0, pyParent); // tuple will keep pyParent reference
 
     // Call python constructor
     auto result = reinterpret_cast<SbkObject *>(PyObject_CallObject(m_pyTypeObject, pyArgs));
diff --git a/sources/pyside6/PySide6/QtWebEngineCore/glue/webenginepage_functors.cpp b/sources/pyside6/PySide6/QtWebEngineCore/glue/webenginepage_functors.cpp
index 0328a9f6a..3591591a7 100644
--- a/sources/pyside6/PySide6/QtWebEngineCore/glue/webenginepage_functors.cpp
+++ b/sources/pyside6/PySide6/QtWebEngineCore/glue/webenginepage_functors.cpp
@@ -22,7 +22,7 @@ void RunJavascriptFunctor::operator()(const QVariant &result)
     case QMetaType::Bool: {
         PyObject *pyValue = result.toBool() ? Py_True : Py_False;
         Py_INCREF(pyValue);
-        PyTuple_SET_ITEM(arglist, 0, pyValue);
+        PyTuple_SetItem(arglist, 0, pyValue);
     }
     break;
     case QMetaType::Int:
@@ -30,11 +30,11 @@ void RunJavascriptFunctor::operator()(const QVariant &result)
     case QMetaType::LongLong:
     case QMetaType::ULongLong:
     case QMetaType::Double:
-        PyTuple_SET_ITEM(arglist, 0, PyFloat_FromDouble(result.toDouble()));
+        PyTuple_SetItem(arglist, 0, PyFloat_FromDouble(result.toDouble()));
     break;
     default: {
         const QString value = result.toString();
-        PyTuple_SET_ITEM(arglist, 0, PySide::qStringToPyUnicode(value));
+        PyTuple_SetItem(arglist, 0, PySide::qStringToPyUnicode(value));
     }
     break;
     }
@@ -49,7 +49,7 @@ void PrintToPdfFunctor::operator()(const QByteArray &pdf)
 
     Shiboken::Conversions::SpecificConverter converter("QByteArray");
     PyObject *pyPdf = converter.toPython(&pdf);
-    PyTuple_SET_ITEM(arglist, 0, pyPdf);
+    PyTuple_SetItem(arglist, 0, pyPdf);
     Shiboken::AutoDecRef ret(PyObject_CallObject(object(), arglist));
     release(); // single shot
 }
diff --git a/sources/pyside6/PySide6/glue/qhttpserver.cpp b/sources/pyside6/PySide6/glue/qhttpserver.cpp
index c3afafb95..dd08a38af 100644
--- a/sources/pyside6/PySide6/glue/qhttpserver.cpp
+++ b/sources/pyside6/PySide6/glue/qhttpserver.cpp
@@ -15,7 +15,7 @@ bool cppResult = %CPPSELF.%FUNCTION_NAME(rule,
     Shiboken::GilState state;
     auto *requestPtr = &request;
     Shiboken::AutoDecRef arglist(PyTuple_New(1));
-    PyTuple_SET_ITEM(arglist, 0,
+    PyTuple_SetItem(arglist, 0,
                      %CONVERTTOPYTHON[QHttpServerRequest *](requestPtr));
     PyObject *ret = PyObject_CallObject(callable, arglist);
     if (PyErr_Occurred())
@@ -38,9 +38,9 @@ auto callback = [callable](const QHttpServerRequest &request,
     Shiboken::AutoDecRef arglist(PyTuple_New(2));
     auto *responsePtr = &response;
     auto *requestPtr = &request;
-    PyTuple_SET_ITEM(arglist, 0,
+    PyTuple_SetItem(arglist, 0,
                      %CONVERTTOPYTHON[QHttpServerRequest *](requestPtr));
-    PyTuple_SET_ITEM(arglist, 1,
+    PyTuple_SetItem(arglist, 1,
                      %CONVERTTOPYTHON[QHttpServerResponse *](responsePtr));
     PyObject_CallObject(callable, arglist);
     if (PyErr_Occurred())
diff --git a/sources/pyside6/PySide6/glue/qtcore.cpp b/sources/pyside6/PySide6/glue/qtcore.cpp
index 0c113aed8..6734f3bfb 100644
--- a/sources/pyside6/PySide6/glue/qtcore.cpp
+++ b/sources/pyside6/PySide6/glue/qtcore.cpp
@@ -322,7 +322,7 @@ QByteArray uncompressed = %FUNCTION_NAME(ptr, %2);
 QList<QByteArray> version = QByteArray(qVersion()).split('.');
 PyObject *pyQtVersion = PyTuple_New(3);
 for (int i = 0; i < 3; ++i)
-    PyTuple_SET_ITEM(pyQtVersion, i, PyLong_FromLong(version[i].toInt()));
+    PyTuple_SetItem(pyQtVersion, i, PyLong_FromLong(version[i].toInt()));
 PyModule_AddObject(module, "__version_info__", pyQtVersion);
 PyModule_AddStringConstant(module, "__version__", qVersion());
 // @snippet qt-version
@@ -434,11 +434,11 @@ static void msgHandlerCallback(QtMsgType type, const QMessageLogContext &ctx, co
 {
     Shiboken::GilState state;
     Shiboken::AutoDecRef arglist(PyTuple_New(3));
-    PyTuple_SET_ITEM(arglist, 0, %CONVERTTOPYTHON[QtMsgType](type));
-    PyTuple_SET_ITEM(arglist, 1, %CONVERTTOPYTHON[QMessageLogContext &](ctx));
+    PyTuple_SetItem(arglist, 0, %CONVERTTOPYTHON[QtMsgType](type));
+    PyTuple_SetItem(arglist, 1, %CONVERTTOPYTHON[QMessageLogContext &](ctx));
     QByteArray array = msg.toUtf8();  // Python handler requires UTF-8
     const char *data = array.constData();
-    PyTuple_SET_ITEM(arglist, 2, %CONVERTTOPYTHON[const char *](data));
+    PyTuple_SetItem(arglist, 2, %CONVERTTOPYTHON[const char *](data));
     Shiboken::AutoDecRef ret(PyObject_CallObject(qtmsghandler, arglist));
 }
 // @snippet qt-messagehandler
@@ -474,8 +474,8 @@ namespace PySide {
 QPointF p;
 %RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(%ARGUMENT_NAMES, &p);
 %PYARG_0 = PyTuple_New(2);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QPointF](p));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[QPointF](p));
 // @snippet qlinef-intersect
 
 // @snippet qresource-data
@@ -498,17 +498,17 @@ if (!PyDateTimeAPI)
 int year, month, day;
 %CPPSELF.%FUNCTION_NAME(&year, &month, &day);
 %PYARG_0 = PyTuple_New(3);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[int](year));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[int](month));
-PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[int](day));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[int](year));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[int](month));
+PyTuple_SetItem(%PYARG_0, 2, %CONVERTTOPYTHON[int](day));
 // @snippet qdate-getdate
 
 // @snippet qdate-weeknumber
 int yearNumber;
 int week = %CPPSELF.%FUNCTION_NAME(&yearNumber);
 %PYARG_0 = PyTuple_New(2);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[int](week));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[int](yearNumber));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[int](week));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[int](yearNumber));
 // @snippet qdate-weeknumber
 
 // @snippet qdatetime-1
@@ -1136,8 +1136,8 @@ if (msec == 0) {
 qint64 pid;
 %RETURN_TYPE retval = %TYPE::%FUNCTION_NAME(%1, %2, %3, &pid);
 %PYARG_0 = PyTuple_New(2);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[qint64](pid));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[qint64](pid));
 // @snippet qprocess-startdetached
 
 // @snippet qcoreapplication-init
@@ -1145,7 +1145,7 @@ static void QCoreApplicationConstructor(PyObject *self, PyObject *pyargv, QCoreA
 {
     static int argc;
     static char **argv;
-    PyObject *stringlist = PyTuple_GET_ITEM(pyargv, 0);
+    PyObject *stringlist = PyTuple_GetItem(pyargv, 0);
     if (Shiboken::listToArgcArgv(stringlist, &argc, &argv, "PySideApp")) {
         *cptr = new QCoreApplicationWrapper(argc, argv);
         Shiboken::Object::releaseOwnership(reinterpret_cast<SbkObject *>(self));
@@ -1354,7 +1354,7 @@ Py_END_ALLOW_THREADS
     if (!atexit.isNull() && !regFunc.isNull()){
         PyObject *shutDownFunc = PyObject_GetAttrString(module, "__moduleShutdown");
         Shiboken::AutoDecRef args(PyTuple_New(1));
-        PyTuple_SET_ITEM(args, 0, shutDownFunc);
+        PyTuple_SetItem(args, 0, shutDownFunc);
         Shiboken::AutoDecRef retval(PyObject_Call(regFunc, args, nullptr));
         Q_ASSERT(!retval.isNull());
     }
@@ -2079,7 +2079,7 @@ auto callback = [callable, arg_qpermission](const QPermission &permission) -> vo
     Shiboken::GilState state;
     if (arg_qpermission) {
         Shiboken::AutoDecRef arglist(PyTuple_New(1));
-        PyTuple_SET_ITEM(arglist.object(), 0, %CONVERTTOPYTHON[QPermission](permission));
+        PyTuple_SetItem(arglist.object(), 0, %CONVERTTOPYTHON[QPermission](permission));
         Shiboken::AutoDecRef ret(PyObject_CallObject(callable, arglist));
     } else {
         Shiboken::AutoDecRef ret(PyObject_CallObject(callable, nullptr));
@@ -2098,9 +2098,9 @@ qint64 pid{};
 QString hostname, appname;
 %CPPSELF.%FUNCTION_NAME(&pid, &hostname, &appname);
 %PYARG_0 = PyTuple_New(3);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[qint64](pid));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QString](hostname));
-PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[QString](appname));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[qint64](pid));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[QString](hostname));
+PyTuple_SetItem(%PYARG_0, 2, %CONVERTTOPYTHON[QString](appname));
 // @snippet qlockfile-getlockinfo
 
 // @snippet darwin_permission_plugin
diff --git a/sources/pyside6/PySide6/glue/qtgui.cpp b/sources/pyside6/PySide6/glue/qtgui.cpp
index 0c6c4961c..d248ef2d3 100644
--- a/sources/pyside6/PySide6/glue/qtgui.cpp
+++ b/sources/pyside6/PySide6/glue/qtgui.cpp
@@ -84,8 +84,8 @@ QAccessibleInterface *PySideAccessibleFactory::callFactories(const QString &key,
 {
     Shiboken::GilState state;
     Shiboken::AutoDecRef arglist(PyTuple_New(2));
-    PyTuple_SET_ITEM(arglist, 0, %CONVERTTOPYTHON[QString](key));
-    PyTuple_SET_ITEM(arglist, 1, %CONVERTTOPYTHON[QObject *](o));
+    PyTuple_SetItem(arglist, 0, %CONVERTTOPYTHON[QString](key));
+    PyTuple_SetItem(arglist, 1, %CONVERTTOPYTHON[QObject *](o));
 
     for (auto *f : m_factoryFunctions) {
         if (PyObject *pyResult = PyObject_CallObject(f, arglist)) {
@@ -305,8 +305,8 @@ QBitmap %0 = QBitmap::fromData(%1, buffer, %3);
 // @snippet qtextline-cursortox
 %RETURN_TYPE %0 = %CPPSELF->::%TYPE::%FUNCTION_NAME(&%1, %2);
 %PYARG_0 = PyTuple_New(2);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](%0));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG1_TYPE](%1));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](%0));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG1_TYPE](%1));
 // @snippet qtextline-cursortox
 
 // @snippet qkeysequence-getitem
@@ -412,8 +412,8 @@ static void imageDecrefDataHandler(void *data)
 // @snippet qimage-scanline
 
 // @snippet qcolor-setstate
-Shiboken::AutoDecRef func(PyObject_GetAttr(%PYSELF, PyTuple_GET_ITEM(%1, 0)));
-PyObject *args = PyTuple_GET_ITEM(%1, 1);
+Shiboken::AutoDecRef func(PyObject_GetAttr(%PYSELF, PyTuple_GetItem(%1, 0)));
+PyObject *args = PyTuple_GetItem(%1, 1);
 %PYARG_0 = PyObject_Call(func, args, nullptr);
 // @snippet qcolor-setstate
 
@@ -688,8 +688,8 @@ for (int r=0, r_max = %CPPSELF.rowCount(); r < r_max; r++) {
 %RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(%1, %2);
 %END_ALLOW_THREADS
 %PYARG_0 = PyTuple_New(2);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG1_TYPE](%1));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG1_TYPE](%1));
 // @snippet qclipboard-text
 
 // @snippet qpainter-drawpointsnp-numpy-x-y
@@ -733,7 +733,7 @@ float values[16];
 %PYARG_0 = PyTuple_New(16);
 for (Py_ssize_t i = 0; i < 16; ++i) {
   PyObject *v = PyFloat_FromDouble(values[i]);
-  PyTuple_SET_ITEM(%PYARG_0, i, v);
+  PyTuple_SetItem(%PYARG_0, i, v);
 }
 // @snippet qmatrix4x4-copydatato
 
@@ -758,7 +758,7 @@ static void QGuiApplicationConstructor(PyObject *self, PyObject *pyargv, QGuiApp
 {
     static int argc;
     static char **argv;
-    PyObject *stringlist = PyTuple_GET_ITEM(pyargv, 0);
+    PyObject *stringlist = PyTuple_GetItem(pyargv, 0);
     if (Shiboken::listToArgcArgv(stringlist, &argc, &argv, "PySideApp")) {
         *cptr = new QGuiApplicationWrapper(argc, argv, 0);
         Shiboken::Object::releaseOwnership(reinterpret_cast<SbkObject *>(self));
@@ -895,17 +895,17 @@ QVector3D outVec{};
 float angle{};
 %CPPSELF.%FUNCTION_NAME(&outVec, &angle);
 %PYARG_0 = PyTuple_New(2);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[QVector3D](outVec));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[float](angle));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[QVector3D](outVec));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[float](angle));
 // @snippet qquaternion-getaxisandangle-vector3d-float
 
 // @snippet qquaternion-geteulerangles
 float pitch{}, yaw{}, roll{};
 %CPPSELF.%FUNCTION_NAME(&pitch, &yaw, &roll);
 %PYARG_0 = PyTuple_New(3);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[float](pitch));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[float](yaw));
-PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[float](roll));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[float](pitch));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[float](yaw));
+PyTuple_SetItem(%PYARG_0, 2, %CONVERTTOPYTHON[float](roll));
 // @snippet qquaternion-geteulerangles
 
 // @snippet qregion-len
diff --git a/sources/pyside6/PySide6/glue/qtnetwork.cpp b/sources/pyside6/PySide6/glue/qtnetwork.cpp
index 07993f30a..7b1c2d564 100644
--- a/sources/pyside6/PySide6/glue/qtnetwork.cpp
+++ b/sources/pyside6/PySide6/glue/qtnetwork.cpp
@@ -10,9 +10,9 @@ quint16 port;
 %END_ALLOW_THREADS
 QByteArray ba(data, retval);
 %PYARG_0 = PyTuple_New(3);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[QByteArray](ba));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QHostAddress](ha));
-PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[quint16](port));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[QByteArray](ba));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[QHostAddress](ha));
+PyTuple_SetItem(%PYARG_0, 2, %CONVERTTOPYTHON[quint16](port));
 // @snippet qudpsocket-readdatagram
 
 // @snippet qhostinfo-lookuphost-functor
@@ -29,7 +29,7 @@ void QHostInfoFunctor::operator()(const QHostInfo &hostInfo)
     Shiboken::GilState state;
     Shiboken::AutoDecRef arglist(PyTuple_New(1));
     auto *pyHostInfo = %CONVERTTOPYTHON[QHostInfo](hostInfo);
-    PyTuple_SET_ITEM(arglist.object(), 0, pyHostInfo);
+    PyTuple_SetItem(arglist.object(), 0, pyHostInfo);
     Shiboken::AutoDecRef ret(PyObject_CallObject(object(), arglist));
     release(); // single shot
 }
@@ -89,7 +89,7 @@ void QRestFunctor::operator()(QRestReply &restReply)
     Shiboken::AutoDecRef arglist(PyTuple_New(1));
     auto *restReplyPtr = &restReply;
     auto *pyRestReply = %CONVERTTOPYTHON[QRestReply*](restReplyPtr);
-    PyTuple_SET_ITEM(arglist.object(), 0, pyRestReply);
+    PyTuple_SetItem(arglist.object(), 0, pyRestReply);
     Shiboken::AutoDecRef ret(PyObject_CallObject(m_callable, arglist));
     Py_DECREF(m_callable);
     m_callable = nullptr;
diff --git a/sources/pyside6/PySide6/glue/qtnetworkauth.cpp b/sources/pyside6/PySide6/glue/qtnetworkauth.cpp
index 7877a8dd5..1594c4add 100644
--- a/sources/pyside6/PySide6/glue/qtnetworkauth.cpp
+++ b/sources/pyside6/PySide6/glue/qtnetworkauth.cpp
@@ -21,8 +21,8 @@ void QAbstractOAuthModifyFunctor::operator()(QAbstractOAuth::Stage stage,
     Shiboken::GilState state;
     QMultiMap<QString, QVariant> dict = *dictPointer;
     Shiboken::AutoDecRef arglist(PyTuple_New(2));
-    PyTuple_SET_ITEM(arglist, 0, %CONVERTTOPYTHON[QAbstractOAuth::Stage](stage));
-    PyTuple_SET_ITEM(arglist, 1, %CONVERTTOPYTHON[QMultiMap<QString, QVariant>](dict));
+    PyTuple_SetItem(arglist, 0, %CONVERTTOPYTHON[QAbstractOAuth::Stage](stage));
+    PyTuple_SetItem(arglist, 1, %CONVERTTOPYTHON[QMultiMap<QString, QVariant>](dict));
     Shiboken::AutoDecRef ret(PyObject_CallObject(callable, arglist));
 
     if (!ret.isNull() && PyDict_Check(ret.object()) != 0) {
diff --git a/sources/pyside6/PySide6/glue/qtquick3d.cpp b/sources/pyside6/PySide6/glue/qtquick3d.cpp
index 0139913ad..eee286455 100644
--- a/sources/pyside6/PySide6/glue/qtquick3d.cpp
+++ b/sources/pyside6/PySide6/glue/qtquick3d.cpp
@@ -16,6 +16,6 @@ return resultPair.first;
 int count{};
 %RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(&count);
 %PYARG_0 = PyTuple_New(2);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[int](count));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[int](count));
 // @snippet qquick3dinstancing-getinstancebuffer-return
diff --git a/sources/pyside6/PySide6/glue/qtserialbus.cpp b/sources/pyside6/PySide6/glue/qtserialbus.cpp
index cfff36056..0bf918fde 100644
--- a/sources/pyside6/PySide6/glue/qtserialbus.cpp
+++ b/sources/pyside6/PySide6/glue/qtserialbus.cpp
@@ -9,16 +9,16 @@
 QString errorMessage;
 const QList<QCanBusDeviceInfo> result = %CPPSELF.%FUNCTION_NAME(&errorMessage);
 %PYARG_0 = PyTuple_New(2);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[QList<QCanBusDeviceInfo>](result));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QString](errorMessage));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[QList<QCanBusDeviceInfo>](result));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[QString](errorMessage));
 // @snippet qcanbus-available-devices
 
 // @snippet qcanbus-available-devices-plugin
 QString errorMessage;
 const QList<QCanBusDeviceInfo> result = %CPPSELF.%FUNCTION_NAME(%1, &errorMessage);
 %PYARG_0 = PyTuple_New(2);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[QList<QCanBusDeviceInfo>](result));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QString](errorMessage));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[QList<QCanBusDeviceInfo>](result));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[QString](errorMessage));
 // @snippet qcanbus-available-devices-plugin
 
 // @snippet qcanbus-createdevice
@@ -33,6 +33,6 @@ if (auto *device = %CPPSELF.%FUNCTION_NAME(%1, %2, &errorMessage)) {
     Py_INCREF(pyDevice);
 }
 %PYARG_0 = PyTuple_New(2);
-PyTuple_SET_ITEM(%PYARG_0, 0, pyDevice);
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QString](errorMessage));
+PyTuple_SetItem(%PYARG_0, 0, pyDevice);
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[QString](errorMessage));
 // @snippet qcanbus-createdevice
diff --git a/sources/pyside6/PySide6/glue/qtuitools.cpp b/sources/pyside6/PySide6/glue/qtuitools.cpp
index 1835ed096..3fe3554c4 100644
--- a/sources/pyside6/PySide6/glue/qtuitools.cpp
+++ b/sources/pyside6/PySide6/glue/qtuitools.cpp
@@ -207,6 +207,6 @@ if (%PYARG_0 == nullptr) {
     qCritical() << "Error while creating the return Tuple";
     Py_RETURN_NONE;
 }
-PyTuple_SET_ITEM(%PYARG_0, 0, classObj);
-PyTuple_SET_ITEM(%PYARG_0, 1, baseClassObj);
+PyTuple_SetItem(%PYARG_0, 0, classObj);
+PyTuple_SetItem(%PYARG_0, 1, baseClassObj);
 // @snippet loaduitype
diff --git a/sources/pyside6/PySide6/glue/qtwebenginecore.cpp b/sources/pyside6/PySide6/glue/qtwebenginecore.cpp
index 9ce620bff..42ac6e768 100644
--- a/sources/pyside6/PySide6/glue/qtwebenginecore.cpp
+++ b/sources/pyside6/PySide6/glue/qtwebenginecore.cpp
@@ -14,7 +14,7 @@ bool QWebEngineCookieFilterFunctor::operator()(const QWebEngineCookieStore::Filt
 {
     Shiboken::GilState state;
     Shiboken::AutoDecRef arglist(PyTuple_New(1));
-    PyTuple_SET_ITEM(arglist, 0,
+    PyTuple_SetItem(arglist, 0,
                      %CONVERTTOPYTHON[QWebEngineCookieStore::FilterRequest](filterRequest));
     Shiboken::AutoDecRef ret(PyObject_CallObject(object(), arglist));
     return ret.object() == Py_True;
@@ -39,7 +39,7 @@ void QWebEngineNotificationFunctor::operator()
     Shiboken::GilState state;
     Shiboken::AutoDecRef arglist(PyTuple_New(1));
     auto *notification = webEngineNotification.release();
-    PyTuple_SET_ITEM(arglist.object(), 0,
+    PyTuple_SetItem(arglist.object(), 0,
                      %CONVERTTOPYTHON[QWebEngineNotification*](notification));
     Shiboken::AutoDecRef ret(PyObject_CallObject(object(), arglist));
 };
@@ -59,8 +59,8 @@ return resultPair.first;
 QString str;
 %RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(%1, %2, %3, &str);
 %PYARG_0 = PyTuple_New(2);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QString](str));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[QString](str));
 // @snippet qwebenginepage-javascriptprompt-return
 
 // @snippet qwebenginepage-findtext
@@ -69,7 +69,7 @@ auto callback = [callable](const QWebEngineFindTextResult &result)
 {
     Shiboken::GilState state;
     Shiboken::AutoDecRef arglist(PyTuple_New(1));
-    PyTuple_SET_ITEM(arglist, 0, %CONVERTTOPYTHON[QWebEngineFindTextResult](result));
+    PyTuple_SetItem(arglist, 0, %CONVERTTOPYTHON[QWebEngineFindTextResult](result));
     Shiboken::AutoDecRef ret(PyObject_CallObject(callable, arglist));
     Py_DECREF(callable);
 
@@ -89,7 +89,7 @@ auto callback = [printer, callable](bool succeeded)
     }
     Shiboken::GilState state;
     Shiboken::AutoDecRef arglist(PyTuple_New(1));
-    PyTuple_SET_ITEM(arglist, 0, %CONVERTTOPYTHON[bool](succeeded));
+    PyTuple_SetItem(arglist, 0, %CONVERTTOPYTHON[bool](succeeded));
     Shiboken::AutoDecRef ret(PyObject_CallObject(callable, arglist));
     Py_DECREF(callable);
     Py_DECREF(printer);
@@ -106,7 +106,7 @@ auto callback = [callable](const QString &text)
 {
     Shiboken::GilState state;
     Shiboken::AutoDecRef arglist(PyTuple_New(1));
-    PyTuple_SET_ITEM(arglist, 0, %CONVERTTOPYTHON[QString](text));
+    PyTuple_SetItem(arglist, 0, %CONVERTTOPYTHON[QString](text));
     Shiboken::AutoDecRef ret(PyObject_CallObject(callable, arglist));
     Py_DECREF(callable);
 };
diff --git a/sources/pyside6/PySide6/glue/qtwidgets.cpp b/sources/pyside6/PySide6/glue/qtwidgets.cpp
index eeab64a43..bc9dc99d6 100644
--- a/sources/pyside6/PySide6/glue/qtwidgets.cpp
+++ b/sources/pyside6/PySide6/glue/qtwidgets.cpp
@@ -36,8 +36,8 @@ if (%0) {
 QGraphicsItem *item_ = nullptr;
 %RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(&item_);
 %PYARG_0 = PyTuple_New(2);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QGraphicsItem *](item_));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[QGraphicsItem *](item_));
 // @snippet qgraphicsitem-isblockedbymodalpanel
 
 // @snippet qitemeditorfactory-registereditor
@@ -60,13 +60,13 @@ int _row;
 QFormLayout::ItemRole _role;
 %CPPSELF->%FUNCTION_NAME(%ARGUMENT_NAMES, &_row, &_role);
 %PYARG_0 = PyTuple_New(2);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[int](_row));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[int](_row));
 // On the C++ side, *rolePtr is not set if row == -1, in which case on
 // the Python side this gets converted to a random value outside the
 // enum range. Fix this by setting _role to a default value here.
 if (_row == -1)
     _role = QFormLayout::LabelRole;
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QFormLayout::ItemRole](_role));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[QFormLayout::ItemRole](_role));
 // @snippet qformlayout-fix-args
 
 // @snippet qfiledialog-return
@@ -74,8 +74,8 @@ PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QFormLayout::ItemRole](_role));
 %RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(%1, %2, %3, %4, &%5, %6);
 %END_ALLOW_THREADS
 %PYARG_0 = PyTuple_New(2);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QString](%5));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[QString](%5));
 // @snippet qfiledialog-return
 
 // @snippet qwidget-addaction-glue
@@ -392,10 +392,10 @@ removeLayoutOwnership(%CPPSELF, %1);
 int a, b, c, d;
 %CPPSELF.%FUNCTION_NAME(%1, &a, &b, &c, &d);
 %PYARG_0 = PyTuple_New(4);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[int](a));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[int](b));
-PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[int](c));
-PyTuple_SET_ITEM(%PYARG_0, 3, %CONVERTTOPYTHON[int](d));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[int](a));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[int](b));
+PyTuple_SetItem(%PYARG_0, 2, %CONVERTTOPYTHON[int](c));
+PyTuple_SetItem(%PYARG_0, 3, %CONVERTTOPYTHON[int](d));
 // @snippet qgridlayout-getitemposition
 
 // @snippet qgraphicsscene-destroyitemgroup
@@ -569,7 +569,7 @@ static void QApplicationConstructor(PyObject *self, PyObject *pyargv, QApplicati
 {
     static int argc;
     static char **argv;
-    PyObject *stringlist = PyTuple_GET_ITEM(pyargv, 0);
+    PyObject *stringlist = PyTuple_GetItem(pyargv, 0);
     if (Shiboken::listToArgcArgv(stringlist, &argc, &argv, "PySideApp")) {
         *cptr = new QApplicationWrapper(argc, argv, 0);
         Shiboken::Object::releaseOwnership(reinterpret_cast<SbkObject *>(self));
diff --git a/sources/pyside6/PySide6/glue/qtxml.cpp b/sources/pyside6/PySide6/glue/qtxml.cpp
index 120579927..b97d774e7 100644
--- a/sources/pyside6/PySide6/glue/qtxml.cpp
+++ b/sources/pyside6/PySide6/glue/qtxml.cpp
@@ -10,8 +10,8 @@ bool _ret_ = %CPPSELF.%FUNCTION_NAME(%ARGUMENT_NAMES, &_errorMsg_, &_errorLine_,
     &_errorColumn_);
 %END_ALLOW_THREADS
 %PYARG_0 = PyTuple_New(4);
-PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[bool](_ret_));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QString](_errorMsg_));
-PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[int](_errorLine_));
-PyTuple_SET_ITEM(%PYARG_0, 3, %CONVERTTOPYTHON[int](_errorColumn_));
+PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[bool](_ret_));
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[QString](_errorMsg_));
+PyTuple_SetItem(%PYARG_0, 2, %CONVERTTOPYTHON[int](_errorLine_));
+PyTuple_SetItem(%PYARG_0, 3, %CONVERTTOPYTHON[int](_errorColumn_));
 // @snippet qdomdocument-setcontent
diff --git a/sources/pyside6/PySide6/templates/core_common.xml b/sources/pyside6/PySide6/templates/core_common.xml
index 7f18318ae..c794e7b8f 100644
--- a/sources/pyside6/PySide6/templates/core_common.xml
+++ b/sources/pyside6/PySide6/templates/core_common.xml
@@ -7,8 +7,8 @@
 
     <template name="tuple_ok_retval">
         %PYARG_0 = PyTuple_New(2);
-        PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[bool](ok_));
-        PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
+        PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[bool](ok_));
+        PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
     </template>
 
     <template name="bool*_fix,arg">
@@ -26,8 +26,8 @@
     <!-- Templates to fix bool* parameters -->
     <template name="tuple_retval_ok">
         %PYARG_0 = PyTuple_New(2);
-        PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
-        PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[bool](ok_));
+        PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
+        PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[bool](ok_));
     </template>
 
     <template name="fix_bool*">
@@ -129,16 +129,16 @@
         char val_{};
         %RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(&amp;val_);
         %PYARG_0 = PyTuple_New(2);
-        PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
-        PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[char](val_));
+        PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
+        PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[char](val_));
     </template>
 
     <template name="tuple_abcd_same_type">
         %PYARG_0 = PyTuple_New(4);
-        PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[$TYPE](a));
-        PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[$TYPE](b));
-        PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[$TYPE](c));
-        PyTuple_SET_ITEM(%PYARG_0, 3, %CONVERTTOPYTHON[$TYPE](d));
+        PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[$TYPE](a));
+        PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[$TYPE](b));
+        PyTuple_SetItem(%PYARG_0, 2, %CONVERTTOPYTHON[$TYPE](c));
+        PyTuple_SetItem(%PYARG_0, 3, %CONVERTTOPYTHON[$TYPE](d));
     </template>
 
     <template name="fix_number*,number*,number*,number*">
@@ -178,19 +178,19 @@
         $TYPE a, b, c, d, e;
         %CPPSELF.%FUNCTION_NAME(&amp;a, &amp;b, &amp;c, &amp;d, &amp;e);
         %PYARG_0 = PyTuple_New(5);
-        PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[$TYPE](a));
-        PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[$TYPE](b));
-        PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[$TYPE](c));
-        PyTuple_SET_ITEM(%PYARG_0, 3, %CONVERTTOPYTHON[$TYPE](d));
-        PyTuple_SET_ITEM(%PYARG_0, 4, %CONVERTTOPYTHON[$TYPE](e));
+        PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[$TYPE](a));
+        PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[$TYPE](b));
+        PyTuple_SetItem(%PYARG_0, 2, %CONVERTTOPYTHON[$TYPE](c));
+        PyTuple_SetItem(%PYARG_0, 3, %CONVERTTOPYTHON[$TYPE](d));
+        PyTuple_SetItem(%PYARG_0, 4, %CONVERTTOPYTHON[$TYPE](e));
     </template>
 
     <template name="fix_args,number*,number*">
         $TYPE a, b;
         %CPPSELF.%FUNCTION_NAME(%ARGUMENT_NAMES, &amp;a, &amp;b);
         %PYARG_0 = PyTuple_New(2);
-        PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[$TYPE](a));
-        PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[$TYPE](b));
+        PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[$TYPE](a));
+        PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[$TYPE](b));
     </template>
 
     <template name="fix_arg,int*,int*">
@@ -198,17 +198,17 @@
     int a, b;
     _ret = %CPPSELF.%FUNCTION_NAME(%1, &amp;a, &amp;b);
     %PYARG_0 = PyTuple_New(3);
-    PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](_ret));
-    PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[int](a));
-    PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[int](b));
+    PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](_ret));
+    PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[int](a));
+    PyTuple_SetItem(%PYARG_0, 2, %CONVERTTOPYTHON[int](b));
     </template>
 
     <template name="return_tuple_QValidator_QString_int">
         %RETURN_TYPE retval_ = %RETURN_TYPE(%CPPSELF.%FUNCTION_NAME(%1, %2));
         %PYARG_0 = PyTuple_New(3);
-        PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
-        PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG1_TYPE](%1));
-        PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[%ARG2_TYPE](%2));
+        PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
+        PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG1_TYPE](%1));
+        PyTuple_SetItem(%PYARG_0, 2, %CONVERTTOPYTHON[%ARG2_TYPE](%2));
     </template>
 
     <template name="repr_code">
@@ -256,8 +256,8 @@
 
     <template name="return_native_eventfilter">
         %PYARG_0 = PyTuple_New(2);
-        PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](%0));
-        PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[long](*result_out));
+        PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](%0));
+        PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[long](*result_out));
     </template>
 
     <!-- templates for __reduce__ -->
diff --git a/sources/pyside6/PySide6/templates/gui_common.xml b/sources/pyside6/PySide6/templates/gui_common.xml
index 5d2222d26..9264d7349 100644
--- a/sources/pyside6/PySide6/templates/gui_common.xml
+++ b/sources/pyside6/PySide6/templates/gui_common.xml
@@ -46,8 +46,8 @@
         %ARG1_TYPE a, b;
         %CPPSELF.%FUNCTION_NAME(%1, %2, &amp;a, &amp;b);
         %PYARG_0 = PyTuple_New(2);
-        PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%ARG1_TYPE](a));
-        PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG1_TYPE](b));
+        PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%ARG1_TYPE](a));
+        PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG1_TYPE](b));
     </template>
 
     <template name="qimage_buffer_constructor">
@@ -205,7 +205,7 @@
         PyObject *pyData = PyTuple_New(%MATRIX_SIZE);
         if (data) {
             for(int i=0; i &lt; %MATRIX_SIZE; i++)
-                PyTuple_SET_ITEM(pyData, i, %CONVERTTOPYTHON[float](data[i]));
+                PyTuple_SetItem(pyData, i, %CONVERTTOPYTHON[float](data[i]));
         }
         return pyData;
     </template>
diff --git a/sources/pyside6/libpyside/dynamicqmetaobject.cpp b/sources/pyside6/libpyside/dynamicqmetaobject.cpp
index 94ce20226..95acab869 100644
--- a/sources/pyside6/libpyside/dynamicqmetaobject.cpp
+++ b/sources/pyside6/libpyside/dynamicqmetaobject.cpp
@@ -582,8 +582,8 @@ void MetaObjectBuilderPrivate::parsePythonType(PyTypeObject *type)
     // This enforces registering of all signals and slots at type parsing time, and not later at
     // signal connection time, thus making sure no method indices change which would break
     // existing connections.
-    const PyObject *mro = type->tp_mro;
-    const Py_ssize_t basesCount = PyTuple_GET_SIZE(mro);
+    PyObject *mro = type->tp_mro;
+    const Py_ssize_t basesCount = PyTuple_Size(mro);
 
     std::vector<PyTypeObject *> basesToCheck;
     // Prepend the actual type that we are parsing.
@@ -593,7 +593,7 @@ void MetaObjectBuilderPrivate::parsePythonType(PyTypeObject *type)
     auto *sbkObjTypeF = SbkObject_TypeF();
     auto *baseObjType = reinterpret_cast<PyTypeObject *>(&PyBaseObject_Type);
     for (Py_ssize_t i = 0; i < basesCount; ++i) {
-        auto *baseType = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, i));
+        auto *baseType = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(mro, i));
         if (baseType != sbkObjTypeF && baseType != baseObjType
             && !PySide::isQObjectDerived(baseType, false)) {
             basesToCheck.push_back(baseType);
diff --git a/sources/pyside6/libpyside/feature_select.cpp b/sources/pyside6/libpyside/feature_select.cpp
index 3d61f148f..305095d1f 100644
--- a/sources/pyside6/libpyside/feature_select.cpp
+++ b/sources/pyside6/libpyside/feature_select.cpp
@@ -347,10 +347,10 @@ static inline void SelectFeatureSet(PyTypeObject *type)
     last_select_id = select_id;
 
     auto *mro = type->tp_mro;
-    const Py_ssize_t n = PyTuple_GET_SIZE(mro);
+    const Py_ssize_t n = PyTuple_Size(mro);
     // We leave 'Shiboken.Object' and 'object' alone, therefore "n - 2".
     for (Py_ssize_t idx = 0; idx < n - 2; idx++) {
-        auto *sub_type = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
+        auto *sub_type = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(mro, idx));
         SelectFeatureSetSubtype(sub_type, select_id);
     }
     // PYSIDE-1436: Clear all caches for the type and subtypes.
@@ -627,10 +627,10 @@ static QByteArrayList GetPropertyStringsMro(PyTypeObject *type)
     auto res = QByteArrayList();
 
     PyObject *mro = type->tp_mro;
-    const Py_ssize_t n = PyTuple_GET_SIZE(mro);
+    const Py_ssize_t n = PyTuple_Size(mro);
     // We leave 'Shiboken.Object' and 'object' alone, therefore "n - 2".
     for (Py_ssize_t idx = 0; idx < n - 2; idx++) {
-        auto *subType = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
+        auto *subType = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(mro, idx));
         auto *props = SbkObjectType_GetPropertyStrings(subType);
         if (props != nullptr)
             for (; *props != nullptr; ++props)
diff --git a/sources/pyside6/libpyside/pyside.cpp b/sources/pyside6/libpyside/pyside.cpp
index fe1da77a1..272a006fc 100644
--- a/sources/pyside6/libpyside/pyside.cpp
+++ b/sources/pyside6/libpyside/pyside.cpp
@@ -222,10 +222,10 @@ static QByteArrayList _SbkType_LookupProperty(PyTypeObject *type,
     if (origName.isEmpty())
         return QByteArrayList{};
     PyObject *mro = type->tp_mro;
-    auto n = PyTuple_GET_SIZE(mro);
+    auto n = PyTuple_Size(mro);
     auto len = std::strlen(origName);
     for (Py_ssize_t idx = 0; idx < n; idx++) {
-        auto *base = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
+        auto *base = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(mro, idx));
         if (!SbkObjectType_Check(base))
             continue;
         auto *props = SbkObjectType_GetPropertyStrings(base);
@@ -499,20 +499,19 @@ void initQObjectSubType(PyTypeObject *type, PyObject *args, PyObject * /* kwds *
 {
     PyTypeObject *qObjType = Shiboken::Conversions::getPythonTypeObject("QObject*");
 
-    PyObject *bases = PyTuple_GET_ITEM(args, 1);
-    int numBases = PyTuple_GET_SIZE(bases);
+    PyObject *bases = PyTuple_GetItem(args, 1);
 
     TypeUserData *userData = nullptr;
 
-    for (int i = 0; i < numBases; ++i) {
-        auto *base = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(bases, i));
+    for (Py_ssize_t i = 0, numBases = PyTuple_Size(bases); i < numBases; ++i) {
+        auto *base = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(bases, i));
         if (PyType_IsSubtype(base, qObjType)) {
             userData = retrieveTypeUserData(base);
             break;
         }
     }
     if (!userData) {
-        const char *className = Shiboken::String::toCString(PyTuple_GET_ITEM(args, 0));
+        const char *className = Shiboken::String::toCString(PyTuple_GetItem(args, 0));
         qWarning("Sub class of QObject not inheriting QObject!? Crash will happen when using %s.",
                  className);
         return;
diff --git a/sources/pyside6/libpyside/pysideclassdecorator.cpp b/sources/pyside6/libpyside/pysideclassdecorator.cpp
index eee49939a..4386dcba6 100644
--- a/sources/pyside6/libpyside/pysideclassdecorator.cpp
+++ b/sources/pyside6/libpyside/pysideclassdecorator.cpp
@@ -59,7 +59,7 @@ int StringDecoratorPrivate::convertToString(PyObject *self, PyObject *args)
 {
     int result = -1;
     if (PyTuple_Size(args) == 1) {
-        PyObject *arg = PyTuple_GET_ITEM(args, 0);
+        PyObject *arg = PyTuple_GetItem(args, 0);
         if (PyUnicode_Check(arg)) {
             auto *pData = DecoratorPrivate::get<StringDecoratorPrivate>(self);
             result = 0;
@@ -90,7 +90,7 @@ int TypeDecoratorPrivate::convertToType(PyObject *self, PyObject *args)
     int result = -1;
     const auto argsCount = PyTuple_Size(args);
     if (argsCount == 1) {
-        PyObject *arg = PyTuple_GET_ITEM(args, 0);
+        PyObject *arg = PyTuple_GetItem(args, 0);
         if (PyType_Check(arg)) {
             result = 0;
             auto *pData = DecoratorPrivate::get<TypeDecoratorPrivate>(self);
diff --git a/sources/pyside6/libpyside/pysideclassinfo.cpp b/sources/pyside6/libpyside/pysideclassinfo.cpp
index d2067e96c..db643df92 100644
--- a/sources/pyside6/libpyside/pysideclassinfo.cpp
+++ b/sources/pyside6/libpyside/pysideclassinfo.cpp
@@ -69,7 +69,7 @@ int ClassInfoPrivate::tp_init(PyObject *self, PyObject *args, PyObject *kwds)
     PyObject *infoDict = nullptr;
     auto size = PyTuple_Size(args);
     if (size == 1 && kwds == nullptr) {
-        PyObject *tmp = PyTuple_GET_ITEM(args, 0);
+        PyObject *tmp = PyTuple_GetItem(args, 0);
         if (PyDict_Check(tmp))
             infoDict = tmp;
     } else if (size == 0 && kwds && PyDict_Check(kwds)) {
diff --git a/sources/pyside6/libpyside/pysideproperty.cpp b/sources/pyside6/libpyside/pysideproperty.cpp
index bbc289231..7c0400051 100644
--- a/sources/pyside6/libpyside/pysideproperty.cpp
+++ b/sources/pyside6/libpyside/pysideproperty.cpp
@@ -99,7 +99,7 @@ PyObject *PySidePropertyPrivate::getValue(PyObject *source) const
     if (fget) {
         Shiboken::AutoDecRef args(PyTuple_New(1));
         Py_INCREF(source);
-        PyTuple_SET_ITEM(args, 0, source);
+        PyTuple_SetItem(args, 0, source);
         return  PyObject_CallObject(fget, args);
     }
     return nullptr;
@@ -109,8 +109,8 @@ int PySidePropertyPrivate::setValue(PyObject *source, PyObject *value)
 {
     if (fset && value) {
         Shiboken::AutoDecRef args(PyTuple_New(2));
-        PyTuple_SET_ITEM(args, 0, source);
-        PyTuple_SET_ITEM(args, 1, value);
+        PyTuple_SetItem(args, 0, source);
+        PyTuple_SetItem(args, 1, value);
         Py_INCREF(source);
         Py_INCREF(value);
         Shiboken::AutoDecRef result(PyObject_CallObject(fset, args));
@@ -118,7 +118,7 @@ int PySidePropertyPrivate::setValue(PyObject *source, PyObject *value)
     }
     if (fdel) {
         Shiboken::AutoDecRef args(PyTuple_New(1));
-        PyTuple_SET_ITEM(args, 0, source);
+        PyTuple_SetItem(args, 0, source);
         Py_INCREF(source);
         Shiboken::AutoDecRef result(PyObject_CallObject(fdel, args));
         return (result.isNull() ? -1 : 0);
@@ -132,7 +132,7 @@ int PySidePropertyPrivate::reset(PyObject *source)
     if (freset) {
         Shiboken::AutoDecRef args(PyTuple_New(1));
         Py_INCREF(source);
-        PyTuple_SET_ITEM(args, 0, source);
+        PyTuple_SetItem(args, 0, source);
         Shiboken::AutoDecRef result(PyObject_CallObject(freset, args));
         return (result.isNull() ? -1 : 0);
     }
@@ -456,9 +456,9 @@ static PyObject *getFromType(PyTypeObject *type, PyObject *name)
     auto *attr = PyDict_GetItem(tpDict.object(), name);
     if (!attr) {
         PyObject *bases = type->tp_bases;
-        const Py_ssize_t size = PyTuple_GET_SIZE(bases);
+        const Py_ssize_t size = PyTuple_Size(bases);
         for (Py_ssize_t i = 0; i < size; ++i) {
-            PyObject *base = PyTuple_GET_ITEM(bases, i);
+            PyObject *base = PyTuple_GetItem(bases, i);
             attr = getFromType(reinterpret_cast<PyTypeObject *>(base), name);
             if (attr)
                 return attr;
diff --git a/sources/pyside6/libpyside/pysidesignal.cpp b/sources/pyside6/libpyside/pysidesignal.cpp
index aaffc9548..0ce9fda61 100644
--- a/sources/pyside6/libpyside/pysidesignal.cpp
+++ b/sources/pyside6/libpyside/pysidesignal.cpp
@@ -277,7 +277,7 @@ static int signalTpInit(PyObject *obSelf, PyObject *args, PyObject *kwds)
     self->data->signalArguments = argumentNamesOpt.value();
 
     for (Py_ssize_t i = 0, i_max = PyTuple_Size(args); i < i_max; i++) {
-        PyObject *arg = PyTuple_GET_ITEM(args, i);
+        PyObject *arg = PyTuple_GetItem(args, i);
         if (PySequence_Check(arg) && !Shiboken::String::check(arg) && !PyEnumMeta_Check(arg)) {
             tupledArgs = true;
             self->data->signatures.append(PySide::Signal::parseSignature(arg));
@@ -677,8 +677,8 @@ static PyObject *signalInstanceDisconnect(PyObject *self, PyObject *args)
     Shiboken::AutoDecRef pyArgs(PyList_New(0));
 
     PyObject *slot = Py_None;
-    if (PyTuple_Check(args) && PyTuple_GET_SIZE(args))
-        slot = PyTuple_GET_ITEM(args, 0);
+    if (PyTuple_Check(args) && PyTuple_Size(args))
+        slot = PyTuple_GetItem(args, 0);
 
     bool match = false;
     if (Py_TYPE(slot) == PySideSignalInstance_TypeF()) {
@@ -802,10 +802,10 @@ static PyObject *_getHomonymousMethod(PySideSignalInstance *inst)
     auto signalName = inst->d->signalName;
     Shiboken::AutoDecRef name(Shiboken::String::fromCString(signalName));
     auto *mro = Py_TYPE(inst->d->source)->tp_mro;
-    const Py_ssize_t n = PyTuple_GET_SIZE(mro);
+    const Py_ssize_t n = PyTuple_Size(mro);
 
     for (Py_ssize_t idx = 0; idx < n; idx++) {
-        auto *sub_type = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
+        auto *sub_type = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(mro, idx));
         Shiboken::AutoDecRef tpDict(PepType_GetDict(sub_type));
         auto *hom = PyDict_GetItem(tpDict, name);
         if (hom != nullptr && PyCallable_Check(hom) != 0) {
diff --git a/sources/pyside6/libpyside/pysideslot.cpp b/sources/pyside6/libpyside/pysideslot.cpp
index 0a448852e..5232b4e4c 100644
--- a/sources/pyside6/libpyside/pysideslot.cpp
+++ b/sources/pyside6/libpyside/pysideslot.cpp
@@ -88,7 +88,7 @@ int slotTpInit(PyObject *self, PyObject *args, PyObject *kw)
     if (!data->slotData)
         data->slotData = new SlotData;
     for(Py_ssize_t i = 0, i_max = PyTuple_Size(args); i < i_max; i++) {
-        PyObject *argType = PyTuple_GET_ITEM(args, i);
+        PyObject *argType = PyTuple_GetItem(args, i);
         const auto typeName = PySide::Signal::getTypeName(argType);
         if (typeName.isEmpty()) {
             PyErr_Format(PyExc_TypeError, "Unknown signal argument type: %s", Py_TYPE(argType)->tp_name);
diff --git a/sources/pyside6/libpyside/pysideweakref.cpp b/sources/pyside6/libpyside/pysideweakref.cpp
index e4d6a9a3d..48f9b3d03 100644
--- a/sources/pyside6/libpyside/pysideweakref.cpp
+++ b/sources/pyside6/libpyside/pysideweakref.cpp
@@ -45,7 +45,7 @@ static PyObject *CallableObject_call(PyObject *callable_object, PyObject *args,
     auto *obj = reinterpret_cast<PySideCallableObject *>(callable_object);
     obj->weakref_func(obj->user_data);
 
-    Py_XDECREF(PyTuple_GET_ITEM(args, 0)); //kill weak ref object
+    Py_XDECREF(PyTuple_GetItem(args, 0)); //kill weak ref object
     Py_RETURN_NONE;
 }
 
diff --git a/sources/pyside6/libpyside/signalmanager.cpp b/sources/pyside6/libpyside/signalmanager.cpp
index c3d66f3bc..3fe7416a4 100644
--- a/sources/pyside6/libpyside/signalmanager.cpp
+++ b/sources/pyside6/libpyside/signalmanager.cpp
@@ -473,7 +473,7 @@ static int callPythonMetaMethodHelper(const QByteArrayList &paramTypes,
         Shiboken::Conversions::SpecificConverter converter(param.constData());
         if (!converter.isValid())
             return CallResult::CallArgumentError + int(i);
-        PyTuple_SET_ITEM(preparedArgs, i, converter.toPython(data));
+        PyTuple_SetItem(preparedArgs, i, converter.toPython(data));
     }
 
     QScopedPointer<Shiboken::Conversions::SpecificConverter> retConverter;
diff --git a/sources/pyside6/libpysideqml/pysideqmlextended.cpp b/sources/pyside6/libpysideqml/pysideqmlextended.cpp
index fdd71ded6..9953c3623 100644
--- a/sources/pyside6/libpysideqml/pysideqmlextended.cpp
+++ b/sources/pyside6/libpysideqml/pysideqmlextended.cpp
@@ -97,7 +97,7 @@ static QObject *extensionFactory(QObject *o)
     }
 
     Shiboken::AutoDecRef args(PyTuple_New(1));
-    PyTuple_SET_ITEM(args.object(), 0, pyObj);
+    PyTuple_SetItem(args.object(), 0, pyObj);
     auto *extensionTypeObj = reinterpret_cast<PyObject *>(info->extensionType);
     Shiboken::AutoDecRef pyResult(PyObject_Call(extensionTypeObj, args, nullptr));
     if (pyResult.isNull() || PyErr_Occurred()) {
diff --git a/sources/pyside6/libpysideqml/pysideqmllistproperty.cpp b/sources/pyside6/libpysideqml/pysideqmllistproperty.cpp
index 5722dd441..447d16564 100644
--- a/sources/pyside6/libpysideqml/pysideqmllistproperty.cpp
+++ b/sources/pyside6/libpysideqml/pysideqmllistproperty.cpp
@@ -139,9 +139,9 @@ void propListAppender(QQmlListProperty<QObject> *propList, QObject *item)
 
     Shiboken::AutoDecRef args(PyTuple_New(2));
     PyTypeObject *qobjectType = qObjectType();
-    PyTuple_SET_ITEM(args, 0,
+    PyTuple_SetItem(args, 0,
                      Shiboken::Conversions::pointerToPython(qobjectType, propList->object));
-    PyTuple_SET_ITEM(args, 1,
+    PyTuple_SetItem(args, 1,
                      Shiboken::Conversions::pointerToPython(qobjectType, item));
 
     auto *data = reinterpret_cast<QmlListPropertyPrivate *>(propList->data);
@@ -157,7 +157,7 @@ qsizetype propListCount(QQmlListProperty<QObject> *propList)
     Shiboken::GilState state;
 
     Shiboken::AutoDecRef args(PyTuple_New(1));
-    PyTuple_SET_ITEM(args, 0,
+    PyTuple_SetItem(args, 0,
                      Shiboken::Conversions::pointerToPython(qObjectType(), propList->object));
 
     auto *data = reinterpret_cast<QmlListPropertyPrivate *>(propList->data);
@@ -183,10 +183,10 @@ QObject *propListAt(QQmlListProperty<QObject> *propList, qsizetype index)
 
     Shiboken::AutoDecRef args(PyTuple_New(2));
     PyTypeObject *qobjectType = qObjectType();
-    PyTuple_SET_ITEM(args, 0,
+    PyTuple_SetItem(args, 0,
                      Shiboken::Conversions::pointerToPython(qobjectType, propList->object));
     auto *converter = Shiboken::Conversions::PrimitiveTypeConverter<qsizetype>();
-    PyTuple_SET_ITEM(args, 1,
+    PyTuple_SetItem(args, 1,
                      Shiboken::Conversions::copyToPython(converter, &index));
 
     auto *data = reinterpret_cast<QmlListPropertyPrivate *>(propList->data);
@@ -207,7 +207,7 @@ void propListClear(QQmlListProperty<QObject> * propList)
 
     Shiboken::AutoDecRef args(PyTuple_New(1));
     PyTypeObject *qobjectType = qObjectType();
-    PyTuple_SET_ITEM(args, 0,
+    PyTuple_SetItem(args, 0,
                      Shiboken::Conversions::pointerToPython(qobjectType, propList->object));
 
     auto *data = reinterpret_cast<QmlListPropertyPrivate *>(propList->data);
@@ -224,12 +224,12 @@ void propListReplace(QQmlListProperty<QObject> *propList, qsizetype index, QObje
 
     Shiboken::AutoDecRef args(PyTuple_New(3));
     PyTypeObject *qobjectType = qObjectType();
-    PyTuple_SET_ITEM(args, 0,
+    PyTuple_SetItem(args, 0,
                      Shiboken::Conversions::pointerToPython(qobjectType, propList->object));
     auto *converter = Shiboken::Conversions::PrimitiveTypeConverter<qsizetype>();
-    PyTuple_SET_ITEM(args, 1,
+    PyTuple_SetItem(args, 1,
                      Shiboken::Conversions::copyToPython(converter, &index));
-    PyTuple_SET_ITEM(args, 2,
+    PyTuple_SetItem(args, 2,
                      Shiboken::Conversions::pointerToPython(qobjectType, value));
 
     auto *data = reinterpret_cast<QmlListPropertyPrivate *>(propList->data);
@@ -246,7 +246,7 @@ void propListRemoveLast(QQmlListProperty<QObject> *propList)
 
     Shiboken::AutoDecRef args(PyTuple_New(1));
     PyTypeObject *qobjectType = qObjectType();
-    PyTuple_SET_ITEM(args, 0,
+    PyTuple_SetItem(args, 0,
                      Shiboken::Conversions::pointerToPython(qobjectType, propList->object));
 
     auto *data = reinterpret_cast<QmlListPropertyPrivate *>(propList->data);
diff --git a/sources/pyside6/libpysideqml/pysideqmlregistertype.cpp b/sources/pyside6/libpysideqml/pysideqmlregistertype.cpp
index 9e1c570d4..5fa53bb7a 100644
--- a/sources/pyside6/libpysideqml/pysideqmlregistertype.cpp
+++ b/sources/pyside6/libpysideqml/pysideqmlregistertype.cpp
@@ -438,7 +438,7 @@ public:
     {
         Shiboken::GilState gil;
         Shiboken::AutoDecRef args(PyTuple_New(1));
-        PyTuple_SET_ITEM(args, 0,
+        PyTuple_SetItem(args, 0,
                          Shiboken::Conversions::pointerToPython(qQmlEngineType(), engine));
         PyObject *retVal = PyObject_CallObject(data()->callable, args);
         QObject *result = handleReturnValue(retVal);
@@ -540,7 +540,7 @@ static int qmlRegisterSingletonType(PyObject *pyObj, const ImportData &importDat
                 Shiboken::GilState gil;
                 AutoDecRef args(PyTuple_New(1));
 
-                PyTuple_SET_ITEM(args, 0, Conversions::pointerToPython(
+                PyTuple_SetItem(args, 0, Conversions::pointerToPython(
                                  qQmlEngineType(), engine));
 
                 AutoDecRef retVal(PyObject_CallObject(callback, args));
diff --git a/sources/pyside6/libpysideqml/pysideqmluncreatable.cpp b/sources/pyside6/libpysideqml/pysideqmluncreatable.cpp
index 7c0f6b8ff..938b6a858 100644
--- a/sources/pyside6/libpysideqml/pysideqmluncreatable.cpp
+++ b/sources/pyside6/libpysideqml/pysideqmluncreatable.cpp
@@ -50,7 +50,7 @@ int PySideQmlUncreatablePrivate::tp_init(PyObject *self, PyObject *args, PyObjec
     if (argsCount == 0) {
         result = 0; // QML-generated reason
     } else if (argsCount == 1) {
-        PyObject *arg = PyTuple_GET_ITEM(args, 0);
+        PyObject *arg = PyTuple_GetItem(args, 0);
         result = arg == Py_None
             ? 0 // QML-generated reason
             : convertToString(self, args);
diff --git a/sources/pyside6/plugins/uitools/customwidget.cpp b/sources/pyside6/plugins/uitools/customwidget.cpp
index 976754feb..8142ed5fd 100644
--- a/sources/pyside6/plugins/uitools/customwidget.cpp
+++ b/sources/pyside6/plugins/uitools/customwidget.cpp
@@ -79,7 +79,7 @@ QWidget *PyCustomWidget::createWidget(QWidget *parent)
     }
 
     Shiboken::AutoDecRef pyArgs(PyTuple_New(1));
-    PyTuple_SET_ITEM(pyArgs.object(), 0, pyParent); // tuple will keep pyParent reference
+    PyTuple_SetItem(pyArgs.object(), 0, pyParent); // tuple will keep pyParent reference
 
     // Call python constructor
     auto *result = reinterpret_cast<SbkObject *>(PyObject_CallObject(m_pyObject, pyArgs));
diff --git a/sources/shiboken6/ApiExtractor/predefined_templates.cpp b/sources/shiboken6/ApiExtractor/predefined_templates.cpp
index 758e2ec20..f1c96133b 100644
--- a/sources/shiboken6/ApiExtractor/predefined_templates.cpp
+++ b/sources/shiboken6/ApiExtractor/predefined_templates.cpp
@@ -184,8 +184,8 @@ Shiboken::AutoDecRef objsecond(PySequence_GetItem(%in, 1));
 
     {u"shiboken_conversion_cpppair_to_pytuple"_s,
     uR"(PyObject *%out = PyTuple_New(2);
-PyTuple_SET_ITEM(%out, 0, %CONVERTTOPYTHON[%INTYPE_0](%in.first));
-PyTuple_SET_ITEM(%out, 1, %CONVERTTOPYTHON[%INTYPE_1](%in.second));
+PyTuple_SetItem(%out, 0, %CONVERTTOPYTHON[%INTYPE_0](%in.first));
+PyTuple_SetItem(%out, 1, %CONVERTTOPYTHON[%INTYPE_1](%in.second));
 return %out;
 )"_s},
 
diff --git a/sources/shiboken6/doc/typesystem_variables.rst b/sources/shiboken6/doc/typesystem_variables.rst
index d40891b9b..5eb5d5abe 100644
--- a/sources/shiboken6/doc/typesystem_variables.rst
+++ b/sources/shiboken6/doc/typesystem_variables.rst
@@ -223,7 +223,7 @@ Variables
 
   .. code-block:: c++
 
-      long a = PyLong_AS_LONG(PyTuple_GET_ITEM(%PYTHON_ARGUMENTS, 0));
+      long a = PyLong_AS_LONG(PyTuple_GetItem(%PYTHON_ARGUMENTS, 0));
 
 
   The generator tries to be smart with attributions, but it will work for the
@@ -241,8 +241,8 @@ Variables
 
   .. code-block:: c++
 
-      Py_DECREF(PyTuple_GET_ITEM(%PYTHON_ARGUMENTS, 0));
-      PyTuple_SET_ITEM(%PYTHON_ARGUMENTS, 0, PyLong_FromLong(10));
+      Py_DECREF(PyTuple_GetItem(%PYTHON_ARGUMENTS, 0));
+      PyTuple_SetItem(%PYTHON_ARGUMENTS, 0, PyLong_FromLong(10));
 
 
 .. _pyself:
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.cpp b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
index 3644f3c98..4fbbf9881 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
@@ -1191,7 +1191,7 @@ void CppGenerator::writeVirtualMethodNativeArgs(TextStream &s,
         << indent << argConversions.join(u",\n"_s) << outdent << "\n));\n";
 
     for (int index : std::as_const(invalidateArgs)) {
-        s << "bool invalidateArg" << index << " = Py_REFCNT(PyTuple_GET_ITEM(" << PYTHON_ARGS
+        s << "bool invalidateArg" << index << " = Py_REFCNT(PyTuple_GetItem(" << PYTHON_ARGS
             << ", " << index - 1 << ")) == 1;\n";
     }
 }
@@ -1411,7 +1411,7 @@ void CppGenerator::writeVirtualMethodPythonOverride(TextStream &s,
 
         for (int argIndex : std::as_const(invalidateArgs)) {
             s << "if (invalidateArg" << argIndex << ")\n" << indent
-                << "Shiboken::Object::invalidate(PyTuple_GET_ITEM(" << PYTHON_ARGS
+                << "Shiboken::Object::invalidate(PyTuple_GetItem(" << PYTHON_ARGS
                 << ", " << (argIndex - 1) << "));\n" << outdent;
         }
         if (generateNewCall)
@@ -2390,7 +2390,7 @@ void CppGenerator::writeArgumentsInitializer(TextStream &s, const OverloadData &
                                              ErrorReturn errorReturn)
 {
     const auto rfunc = overloadData.referenceFunction();
-    s << "PyTuple_GET_SIZE(args);\n" << sbkUnusedVariableCast("numArgs");
+    s << "PyTuple_Size(args);\n" << sbkUnusedVariableCast("numArgs");
 
     int minArgs = overloadData.minArgs();
     int maxArgs = overloadData.maxArgs();
diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
index 31b22108b..fa55ad09a 100644
--- a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
@@ -1505,9 +1505,9 @@ void ShibokenGenerator::writeCodeSnips(TextStream &s,
         // Python argument on the binding virtual method.
         static const QRegularExpression pyArgsAttributionRegex("%PYARG_(\\d+)\\s*=[^=]\\s*([^;]+)"_L1);
         Q_ASSERT(pyArgsAttributionRegex.isValid());
-        code.replace(pyArgsAttributionRegex, u"PyTuple_SET_ITEM("_s
+        code.replace(pyArgsAttributionRegex, u"PyTuple_SetItem("_s
                      + PYTHON_ARGS + u".object(), \\1-1, \\2)"_s);
-        code.replace(pyArgsRegex, u"PyTuple_GET_ITEM("_s
+        code.replace(pyArgsRegex, u"PyTuple_GetItem("_s
                      + PYTHON_ARGS + u".object(), \\1-1)"_s);
     }
 
diff --git a/sources/shiboken6/libshiboken/basewrapper.cpp b/sources/shiboken6/libshiboken/basewrapper.cpp
index 53c58fd0c..b1f7bea9b 100644
--- a/sources/shiboken6/libshiboken/basewrapper.cpp
+++ b/sources/shiboken6/libshiboken/basewrapper.cpp
@@ -579,8 +579,8 @@ static PyTypeObject *SbkObjectType_tp_new(PyTypeObject *metatype, PyObject *args
                                      &PyDict_Type, &dict))
         return nullptr;
 
-    for (int i=0, i_max=PyTuple_GET_SIZE(pyBases); i < i_max; i++) {
-        PyObject *baseType = PyTuple_GET_ITEM(pyBases, i);
+    for (Py_ssize_t i=0, i_max=PyTuple_Size(pyBases); i < i_max; i++) {
+        PyObject *baseType = PyTuple_GetItem(pyBases, i);
         if (PepExt_Type_GetNewSlot(reinterpret_cast<PyTypeObject *>(baseType)) == SbkDummyNew) {
             // PYSIDE-595: A base class does not allow inheritance.
             return reinterpret_cast<PyTypeObject *>(SbkDummyNew(metatype, args, kwds));
diff --git a/sources/shiboken6/libshiboken/bindingmanager.cpp b/sources/shiboken6/libshiboken/bindingmanager.cpp
index 6e8c120e7..9c33f85b0 100644
--- a/sources/shiboken6/libshiboken/bindingmanager.cpp
+++ b/sources/shiboken6/libshiboken/bindingmanager.cpp
@@ -392,11 +392,12 @@ PyObject *BindingManager::getOverride(const void *cptr,
     if (method != nullptr) {
         PyObject *mro = Py_TYPE(wrapper)->tp_mro;
 
+        int size = PyTuple_Size(mro);
         bool defaultFound = false;
         // The first class in the mro (index 0) is the class being checked and it should not be tested.
         // The last class in the mro (size - 1) is the base Python object class which should not be tested also.
-        for (Py_ssize_t idx = 1, size = PyTuple_GET_SIZE(mro); idx < size - 1; ++idx) {
-            auto *parent = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
+        for (int idx = 1; idx < size - 1; ++idx) {
+            auto *parent = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(mro, idx));
             AutoDecRef parentDict(PepType_GetDict(parent));
             if (parentDict) {
                 if (PyObject *defaultMethod = PyDict_GetItem(parentDict.object(), pyMethodName)) {
@@ -500,10 +501,10 @@ static bool _callInheritedInit(PyObject *self, PyObject *args, PyObject *kwds,
     auto *startType = Py_TYPE(self);
     auto *mro = startType->tp_mro;
     Py_ssize_t idx = 0;
-    const Py_ssize_t n = PyTuple_GET_SIZE(mro);
+    const Py_ssize_t n = PyTuple_Size(mro);
     /* No need to check the last one: it's gonna be skipped anyway.  */
     for ( ; idx + 1 < n; ++idx) {
-        auto *lookType = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
+        auto *lookType = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(mro, idx));
         if (className == lookType->tp_name)
             break;
     }
@@ -511,14 +512,14 @@ static bool _callInheritedInit(PyObject *self, PyObject *args, PyObject *kwds,
     // mro: ('C', 'A', 'QObject', 'Object', 'B', 'object')
     // We want to catch class `B` and call its `__init__`.
     for (idx += 1; idx + 1 < n; ++idx) {
-        auto *t = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
+        auto *t = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(mro, idx));
         if (isPythonType(t))
             break;
     }
     if (idx >= n)
         return false;
 
-    auto *obSubType = PyTuple_GET_ITEM(mro, idx);
+    auto *obSubType = PyTuple_GetItem(mro, idx);
     auto *subType = reinterpret_cast<PyTypeObject *>(obSubType);
     if (subType == &PyBaseObject_Type)
         return false;
@@ -532,7 +533,7 @@ static bool _callInheritedInit(PyObject *self, PyObject *args, PyObject *kwds,
     AutoDecRef newArgs(PyTuple_New(1));
     auto *newArgsOb = newArgs.object();
     Py_INCREF(self);
-    PyTuple_SET_ITEM(newArgsOb, 0, self);
+    PyTuple_SetItem(newArgsOb, 0, self);
     // Note: This can fail, so please always check the error status.
     AutoDecRef result(PyObject_Call(func, newArgs, kwds));
     return true;
diff --git a/sources/shiboken6/libshiboken/pep384impl.cpp b/sources/shiboken6/libshiboken/pep384impl.cpp
index dbc0aa88b..bdb273c10 100644
--- a/sources/shiboken6/libshiboken/pep384impl.cpp
+++ b/sources/shiboken6/libshiboken/pep384impl.cpp
@@ -188,9 +188,9 @@ find_name_in_mro(PyTypeObject *type, PyObject *name, int *error)
        during dict lookup, e.g. when comparing to non-string keys. */
     Py_INCREF(mro);
     assert(PyTuple_Check(mro));
-    n = PyTuple_GET_SIZE(mro);
+    n = PyTuple_Size(mro);
     for (i = 0; i < n; i++) {
-        base = PyTuple_GET_ITEM(mro, i);
+        base = PyTuple_GetItem(mro, i);
         assert(PyType_Check(base));
         auto *type = reinterpret_cast<PyTypeObject *>(base);
         Shiboken::AutoDecRef dict(PepType_GetDict(type));
diff --git a/sources/shiboken6/libshiboken/sbkenum.cpp b/sources/shiboken6/libshiboken/sbkenum.cpp
index cee1ae7fe..787d4ac0d 100644
--- a/sources/shiboken6/libshiboken/sbkenum.cpp
+++ b/sources/shiboken6/libshiboken/sbkenum.cpp
@@ -102,9 +102,9 @@ int enumIsFlag(PyObject *ob_type)
     if (metatype != reinterpret_cast<PyTypeObject *>(PyEnumMeta))
         return -1;
     auto *mro = reinterpret_cast<PyTypeObject *>(ob_type)->tp_mro;
-    const Py_ssize_t n = PyTuple_GET_SIZE(mro);
+    const Py_ssize_t n = PyTuple_Size(mro);
     for (Py_ssize_t idx = 0; idx < n; ++idx) {
-        auto *sub_type = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
+        auto *sub_type = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(mro, idx));
         if (sub_type == reinterpret_cast<PyTypeObject *>(PyFlag))
             return 1;
     }
@@ -401,8 +401,8 @@ static PyTypeObject *createPythonEnumHelper(PyObject *module,
         auto *key = PyUnicode_FromString(kv);
         auto *value = toPyObject(enumValues[idx]);
         auto *key_value = PyTuple_New(2);
-        PyTuple_SET_ITEM(key_value, 0, key);
-        PyTuple_SET_ITEM(key_value, 1, value);
+        PyTuple_SetItem(key_value, 0, key);
+        PyTuple_SetItem(key_value, 1, value);
         PyList_Append(pyEnumItems, key_value);
     }
     return createEnumForPython(module, fullName, pyEnumItems);
diff --git a/sources/shiboken6/libshiboken/sbkfeature_base.cpp b/sources/shiboken6/libshiboken/sbkfeature_base.cpp
index 07f3ff73d..fe32d8ca2 100644
--- a/sources/shiboken6/libshiboken/sbkfeature_base.cpp
+++ b/sources/shiboken6/libshiboken/sbkfeature_base.cpp
@@ -243,9 +243,8 @@ static PyObject *lookupUnqualifiedOrOldEnum(PyTypeObject *type, PyObject *name)
     PyObject *mro = type->tp_mro;
     PyObject *result{};
     assert(PyTuple_Check(mro));
-    Py_ssize_t idx, n = PyTuple_GET_SIZE(mro);
-    for (idx = 0; idx < n; ++idx) {
-        auto *base = PyTuple_GET_ITEM(mro, idx);
+    for (Py_ssize_t idx = 0, n = PyTuple_Size(mro); idx < n; ++idx) {
+        auto *base = PyTuple_GetItem(mro, idx);
         auto *type_base = reinterpret_cast<PyTypeObject *>(base);
         if (!SbkObjectType_Check(type_base))
             continue;
diff --git a/sources/shiboken6/libshiboken/sbktypefactory.cpp b/sources/shiboken6/libshiboken/sbktypefactory.cpp
index 079548eed..f8d8b9104 100644
--- a/sources/shiboken6/libshiboken/sbktypefactory.cpp
+++ b/sources/shiboken6/libshiboken/sbktypefactory.cpp
@@ -63,9 +63,8 @@ static PyObject *_PyType_FromSpecWithBasesHack(PyType_Spec *spec,
             bases = basesPatch.object();
         }
 
-        Py_ssize_t n = PyTuple_GET_SIZE(bases);
-        for (auto idx = 0; idx < n; ++idx) {
-            PyTypeObject *base = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(bases, idx));
+        for (Py_ssize_t idx = 0, n = PyTuple_Size(bases); idx < n; ++idx) {
+            PyTypeObject *base = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(bases, idx));
             PyTypeObject *meta = Py_TYPE(base);
             if (meta->tp_new != PyType_Type.tp_new) {
                 // make sure there is no second meta class
@@ -87,7 +86,7 @@ static PyObject *_PyType_FromSpecWithBasesHack(PyType_Spec *spec,
         keepMeta->tp_new = keepNew;
     if (basesPatch.object()) {
         // undo the metaclass patch.
-        auto *base = PyTuple_GET_ITEM(basesPatch.object(), 0);
+        auto *base = PyTuple_GetItem(basesPatch.object(), 0);
         base->ob_type = &PyType_Type;
     }
     return ret;
@@ -273,7 +272,7 @@ static PyTypeObject *
 best_base(PyObject *bases)
 {
     // We always have only one base
-    return reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(bases, 0));
+    return reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(bases, 0));
 }
 
 static PyObject *
diff --git a/sources/shiboken6/shibokenmodule/shibokenmodule.cpp b/sources/shiboken6/shibokenmodule/shibokenmodule.cpp
index 16cb0fcd3..7eb7e37f4 100644
--- a/sources/shiboken6/shibokenmodule/shibokenmodule.cpp
+++ b/sources/shiboken6/shibokenmodule/shibokenmodule.cpp
@@ -26,7 +26,7 @@ if (Shiboken::Object::checkType(%1)) {
     std::vector<void*> ptrs = Shiboken::Object::cppPointers(reinterpret_cast<SbkObject *>(%1));
     %PYARG_0 = PyTuple_New(ptrs.size());
     for (std::size_t i = 0; i < ptrs.size(); ++i)
-        PyTuple_SET_ITEM(%PYARG_0, i, PyLong_FromVoidPtr(ptrs[i]));
+        PyTuple_SetItem(%PYARG_0, i, PyLong_FromVoidPtr(ptrs[i]));
 } else {
     PyErr_SetString(PyExc_TypeError, "You need a shiboken-based type.");
 }
@@ -112,11 +112,11 @@ Shiboken::Conversions::dumpConverters();
 // @snippet init
 // Add __version__ and __version_info__ attributes to the module
 PyObject* version = PyTuple_New(5);
-PyTuple_SET_ITEM(version, 0, PyLong_FromLong(SHIBOKEN_MAJOR_VERSION));
-PyTuple_SET_ITEM(version, 1, PyLong_FromLong(SHIBOKEN_MINOR_VERSION));
-PyTuple_SET_ITEM(version, 2, PyLong_FromLong(SHIBOKEN_MICRO_VERSION));
-PyTuple_SET_ITEM(version, 3, Shiboken::String::fromCString(SHIBOKEN_RELEASE_LEVEL));
-PyTuple_SET_ITEM(version, 4, PyLong_FromLong(SHIBOKEN_SERIAL));
+PyTuple_SetItem(version, 0, PyLong_FromLong(SHIBOKEN_MAJOR_VERSION));
+PyTuple_SetItem(version, 1, PyLong_FromLong(SHIBOKEN_MINOR_VERSION));
+PyTuple_SetItem(version, 2, PyLong_FromLong(SHIBOKEN_MICRO_VERSION));
+PyTuple_SetItem(version, 3, Shiboken::String::fromCString(SHIBOKEN_RELEASE_LEVEL));
+PyTuple_SetItem(version, 4, PyLong_FromLong(SHIBOKEN_SERIAL));
 PyModule_AddObject(module, "__version_info__", version);
 PyModule_AddStringConstant(module, "__version__", SHIBOKEN_VERSION);
 VoidPtr::addVoidPtrToModule(module);
diff --git a/sources/shiboken6/tests/samplebinding/typesystem_sample.xml b/sources/shiboken6/tests/samplebinding/typesystem_sample.xml
index d28a7973b..e70144468 100644
--- a/sources/shiboken6/tests/samplebinding/typesystem_sample.xml
+++ b/sources/shiboken6/tests/samplebinding/typesystem_sample.xml
@@ -317,7 +317,7 @@
         PyObject* result = PyTuple_New(size);
         for (int i = 0; i &lt; size; ++i) {
             Shiboken::Conversions::SpecificConverter converter(typeName[i]);
-            PyTuple_SET_ITEM(result, i, converter.toPython(values[i]));
+            PyTuple_SetItem(result, i, converter.toPython(values[i]));
         }
         return result;
     }
@@ -858,27 +858,27 @@
 
     <template name="boolptr_fix_end">
         PyObject* _tuple_ = PyTuple_New(2);
-        PyTuple_SET_ITEM(_tuple_, 0, %PYARG_0);
+        PyTuple_SetItem(_tuple_, 0, %PYARG_0);
         PyObject* _item_ = %CONVERTTOPYTHON[bool](__ok__);
-        PyTuple_SET_ITEM(_tuple_, 1, _item_);
+        PyTuple_SetItem(_tuple_, 1, _item_);
         %PYARG_0 = _tuple_;
     </template>
 
     <template name="return_4_arguments_as_tuple">
         %PYARG_0 = PyTuple_New(4);
-        PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%ARG1_TYPE](%1));
-        PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG2_TYPE](%2));
-        PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[%ARG3_TYPE](%3));
-        PyTuple_SET_ITEM(%PYARG_0, 3, %CONVERTTOPYTHON[%ARG4_TYPE](%4));
+        PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%ARG1_TYPE](%1));
+        PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG2_TYPE](%2));
+        PyTuple_SetItem(%PYARG_0, 2, %CONVERTTOPYTHON[%ARG3_TYPE](%3));
+        PyTuple_SetItem(%PYARG_0, 3, %CONVERTTOPYTHON[%ARG4_TYPE](%4));
     </template>
 
     <template name="return_5_arguments_as_tuple">
         %PYARG_0 = PyTuple_New(5);
-        PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%ARG1_TYPE](%1));
-        PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG2_TYPE](%2));
-        PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[%ARG3_TYPE](%3));
-        PyTuple_SET_ITEM(%PYARG_0, 3, %CONVERTTOPYTHON[%ARG4_TYPE](%4));
-        PyTuple_SET_ITEM(%PYARG_0, 4, %CONVERTTOPYTHON[%ARG5_TYPE](%5));
+        PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%ARG1_TYPE](%1));
+        PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG2_TYPE](%2));
+        PyTuple_SetItem(%PYARG_0, 2, %CONVERTTOPYTHON[%ARG3_TYPE](%3));
+        PyTuple_SetItem(%PYARG_0, 3, %CONVERTTOPYTHON[%ARG4_TYPE](%4));
+        PyTuple_SetItem(%PYARG_0, 4, %CONVERTTOPYTHON[%ARG5_TYPE](%5));
     </template>
 
     <template name="return_none">
@@ -1162,8 +1162,8 @@
         </template>
         <template name="differenceOfPointCoordinates_returnTarget">
         %PYARG_0 = PyTuple_New(2);
-        PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[bool](*%2));
-        PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%RETURN_TYPE](%0));
+        PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[bool](*%2));
+        PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[%RETURN_TYPE](%0));
         </template>
         <modify-function signature="differenceOfPointCoordinates(const Point*, bool*)">
             <modify-argument index="2">
@@ -1216,8 +1216,8 @@
           %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(&amp;tmpObject);
           %END_ALLOW_THREADS
           %PYARG_0 = PyTuple_New(2);
-          PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](%0));
-          PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[ObjectType*](tmpObject));
+          PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](%0));
+          PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[ObjectType*](tmpObject));
           </inject-code>
         </modify-function>
         <modify-function signature="passOddBool(OddBool)" rename="invertBoolean">
@@ -1350,9 +1350,9 @@
             <inject-code class="target" position="end">
                 %PYARG_0 = PyTuple_New(2);
                 PyObject* _item_ = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
-                PyTuple_SET_ITEM(%PYARG_0, 0, _item_);
+                PyTuple_SetItem(%PYARG_0, 0, _item_);
                 _item_ = %CONVERTTOPYTHON[Str*](_str_arg_);
-                PyTuple_SET_ITEM(%PYARG_0, 1, _item_);
+                PyTuple_SetItem(%PYARG_0, 1, _item_);
             </inject-code>
         </modify-function>
         <modify-function signature="callCreateStr(const char*, Str*&amp;)">
@@ -1369,9 +1369,9 @@
             <inject-code class="target" position="end">
                 %PYARG_0 = PyTuple_New(2);
                 PyObject* _item_ = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
-                PyTuple_SET_ITEM(%PYARG_0, 0, _item_);
+                PyTuple_SetItem(%PYARG_0, 0, _item_);
                 _item_ = %CONVERTTOPYTHON[Str*](_str_arg_);
-                PyTuple_SET_ITEM(%PYARG_0, 1, _item_);
+                PyTuple_SetItem(%PYARG_0, 1, _item_);
             </inject-code>
         </modify-function>
         <template name="fix_int*,int*,int*,int*">
@@ -1380,10 +1380,10 @@
         %CPPSELF->::%TYPE::%FUNCTION_NAME(&amp;a0, &amp;a1, &amp;a2, &amp;a3);
         %END_ALLOW_THREADS
         %PYARG_0 = PyTuple_New(4);
-        PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[int](a0));
-        PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[int](a1));
-        PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[int](a2));
-        PyTuple_SET_ITEM(%PYARG_0, 3, %CONVERTTOPYTHON[int](a3));
+        PyTuple_SetItem(%PYARG_0, 0, %CONVERTTOPYTHON[int](a0));
+        PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[int](a1));
+        PyTuple_SetItem(%PYARG_0, 2, %CONVERTTOPYTHON[int](a2));
+        PyTuple_SetItem(%PYARG_0, 3, %CONVERTTOPYTHON[int](a3));
         </template>
         <template name="fix_native_return_int*,int*,int*,int*">
             PyObject* _obj = %PYARG_0;
@@ -2318,7 +2318,7 @@
 
     <add-function signature="countVarargs(int, ...)" return-type="int">
         <inject-code class="target" position="beginning">
-        %RETURN_TYPE %0 = PyTuple_GET_SIZE(%PYARG_2);
+        %RETURN_TYPE %0 = PyTuple_Size(%PYARG_2);
         %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
         </inject-code>
     </add-function>
author	Cristián Maureira-Fredes <cristian.maureira-fredes@qt.io>	2024-11-06 11:10:03 +0100
committer	Cristián Maureira-Fredes <Cristian.Maureira-Fredes@qt.io>	2024-11-08 14:24:28 +0100
commit	65a9ae9a853fa68ff997edbe3d6fd4eed022f1a0 (patch)
tree	735b82851430560a81ec28a848cdd09fdb2c36c0
parent	c951f11196d0572b7250a74197937c02b74604dd (diff)