diff --git a/sources/pyside2/PySide2/glue/qtcore.cpp b/sources/pyside2/PySide2/glue/qtcore.cpp
index 6b23a9b7..1daf835c 100644
--- a/sources/pyside2/PySide2/glue/qtcore.cpp
+++ b/sources/pyside2/PySide2/glue/qtcore.cpp
@@ -347,34 +347,44 @@ static bool isDecorator(PyObject *method, PyObject *self)
 
 static bool getReceiver(QObject *source, const char *signal, PyObject *callback, QObject **receiver, PyObject **self, QByteArray *callbackSig)
 {
+    qDebug() << __FUNCTION__ << source << signal;
     bool forceGlobalReceiver = false;
     if (PyMethod_Check(callback)) {
         *self = PyMethod_GET_SELF(callback);
         if (%CHECKTYPE[QObject *](*self))
             *receiver = %CONVERTTOCPP[QObject *](*self);
         forceGlobalReceiver = isDecorator(callback, *self);
+        qDebug() << __FUNCTION__ << "forceGlobalReceiver due to decorator" << forceGlobalReceiver;
     } else if (PyCFunction_Check(callback)) {
         *self = PyCFunction_GET_SELF(callback);
         if (*self && %CHECKTYPE[QObject *](*self))
             *receiver = %CONVERTTOCPP[QObject *](*self);
+        qDebug() << __FUNCTION__ << receiver << "from PyCFunction_Check";
     } else if (PyCallable_Check(callback)) {
         // Ok, just a callable object
         *receiver = nullptr;
+        qDebug() << __FUNCTION__ << "just a callable object";
         *self = nullptr;
     }
 
     bool usingGlobalReceiver = !*receiver || forceGlobalReceiver;
+    qDebug() << __FUNCTION__ << "usingGlobalReceiver=" << usingGlobalReceiver;
 
     // Check if this callback is a overwrite of a non-virtual Qt slot.
     if (!usingGlobalReceiver && receiver && self) {
         *callbackSig = PySide::Signal::getCallbackSignature(signal, *receiver, callback, usingGlobalReceiver).toLatin1();
         const QMetaObject *metaObject = (*receiver)->metaObject();
         int slotIndex = metaObject->indexOfSlot(callbackSig->constData());
+        qDebug() << __FUNCTION__ << "slotIndex=" << slotIndex
+                 << "callbackSig=" << *callbackSig << "metaObject->methodOffset()="
+                 << metaObject->methodOffset() << '(' << metaObject->className() << ')';
         if (slotIndex != -1 && slotIndex < metaObject->methodOffset() && PyMethod_Check(callback))
             usingGlobalReceiver = true;
+         qDebug() << __FUNCTION__ << "usingGlobalReceiver=" << usingGlobalReceiver;
     }
 
     if (usingGlobalReceiver) {
+        qDebug() << __FUNCTION__ << "usingGlobalReceiver from  PySide::SignalManager::instance()";
         PySide::SignalManager &signalManager = PySide::SignalManager::instance();
         *receiver = signalManager.globalReceiver(source, callback);
         *callbackSig = PySide::Signal::getCallbackSignature(signal, *receiver, callback, usingGlobalReceiver).toLatin1();
@@ -385,6 +395,8 @@ static bool getReceiver(QObject *source, const char *signal, PyObject *callback,
 
 static bool qobjectConnect(QObject *source, const char *signal, QObject *receiver, const char *slot, Qt::ConnectionType type)
 {
+    qDebug() << __FUNCTION__ << source << signal << receiver << slot << type
+             << "thread=" << QThread::currentThreadId();
     if (!signal || !slot)
         return false;
 
@@ -399,7 +411,7 @@ static bool qobjectConnect(QObject *source, const char *signal, QObject *receive
     slot++;
     PySide::SignalManager::registerMetaMethod(receiver, slot, isSignal ? QMetaMethod::Signal : QMetaMethod::Slot);
     bool connection;
-    connection = QObject::connect(source, signal - 1, receiver, slot - 1, type);
+    connection = QObject::connect(source, signal - 1, receiver, slot - 1, type);    
     return connection;
 }
 
@@ -410,6 +422,8 @@ static bool qobjectConnect(QObject *source, QMetaMethod signal, QObject *receive
 
 static bool qobjectConnectCallback(QObject *source, const char *signal, PyObject *callback, Qt::ConnectionType type)
 {
+    qDebug() << __FUNCTION__ << source << signal << callback << type
+                << "thread=" << QThread::currentThreadId();
     if (!signal || !PySide::Signal::checkQtSignal(signal))
         return false;
     signal++;
@@ -425,6 +439,8 @@ static bool qobjectConnectCallback(QObject *source, const char *signal, PyObject
     PyObject *self = nullptr;
     QByteArray callbackSig;
     bool usingGlobalReceiver = getReceiver(source, signal, callback, &receiver, &self, &callbackSig);
+    qDebug() << __FUNCTION__ << "usingGlobalReceiver=" << usingGlobalReceiver << source << receiver
+             << callbackSig;
     if (receiver == nullptr && self == nullptr)
         return false;
 
@@ -432,6 +448,8 @@ static bool qobjectConnectCallback(QObject *source, const char *signal, PyObject
     const char *slot = callbackSig.constData();
     int slotIndex = metaObject->indexOfSlot(slot);
     QMetaMethod signalMethod = metaObject->method(signalIndex);
+    qDebug() << __FUNCTION__ << "slotIndex=" << slotIndex;
+
 
     if (slotIndex == -1) {
         if (!usingGlobalReceiver && self && !Shiboken::Object::hasCppWrapper(reinterpret_cast<SbkObject *>(self))) {
diff --git a/sources/pyside2/libpyside/dynamicqmetaobject.cpp b/sources/pyside2/libpyside/dynamicqmetaobject.cpp
index 2fbda3f6..37b9f9af 100644
--- a/sources/pyside2/libpyside/dynamicqmetaobject.cpp
+++ b/sources/pyside2/libpyside/dynamicqmetaobject.cpp
@@ -53,6 +53,7 @@
 #include <QtCore/QStringList>
 #include <QtCore/QTextStream>
 #include <QtCore/QVector>
+#include <QtCore/QDebug>
 #include <private/qmetaobjectbuilder_p.h>
 
 #include <cstring>
@@ -538,6 +539,7 @@ void MetaObjectBuilderPrivate::parsePythonType(PyTypeObject *type)
                 // Register slots.
                 if (PyObject_HasAttr(value, slotAttrName)) {
                     PyObject *signatureList = PyObject_GetAttr(value, slotAttrName);
+                    qDebug() << __FUNCTION__ << PyList_Size(signatureList) << "slots";
                     for (Py_ssize_t i = 0, i_max = PyList_Size(signatureList); i < i_max; ++i) {
                         PyObject *pySignature = PyList_GET_ITEM(signatureList, i);
                         QByteArray signature(String::toCString(pySignature));
@@ -549,6 +551,7 @@ void MetaObjectBuilderPrivate::parsePythonType(PyTypeObject *type)
                             signature.remove(0, spacePos + 1);
                         }
                         const int index = m_baseObject->indexOfSlot(signature);
+                        qDebug() << __FUNCTION__ << '#' << index << signature << type;
                         if (index == -1) {
                             if (type.isEmpty() || type == "void")
                                 addSlot(signature);
diff --git a/sources/pyside2/libpyside/globalreceiverv2.cpp b/sources/pyside2/libpyside/globalreceiverv2.cpp
index 0377f769..d665abd9 100644
--- a/sources/pyside2/libpyside/globalreceiverv2.cpp
+++ b/sources/pyside2/libpyside/globalreceiverv2.cpp
@@ -43,10 +43,14 @@
 #include "signalmanager.h"
 
 #include <autodecref.h>
+#include <helper.h>
 #include <gilstate.h>
+#include <iostream>
 
 #include <QtCore/QMetaMethod>
 #include <QtCore/QSet>
+#include <QtCore/QThread>
+#include <QtCore/QDebug>
 
 #define RECEIVER_DESTROYED_SLOT_NAME "__receiverDestroyed__(QObject*)"
 
@@ -93,6 +97,9 @@ using namespace PySide;
 DynamicSlotDataV2::DynamicSlotDataV2(PyObject *callback, GlobalReceiverV2 *parent)
     : m_pythonSelf(0), m_pyClass(0), m_weakRef(0), m_parent(parent)
 {
+    std::cerr  << __FUNCTION__  << ' ' << Shiboken::debugPyObject(callback)
+               << '\n';
+    qDebug() << "parent=" << parent;
     Shiboken::GilState gil;
 
     m_isMethod = PyMethod_Check(callback);
@@ -148,6 +155,8 @@ PyObject *DynamicSlotDataV2::callback()
     else
         Py_INCREF(callback);
 
+    qDebug() << __FUNCTION__ << "rets" << callback;
+
     return callback;
 }
 
@@ -159,6 +168,8 @@ int DynamicSlotDataV2::id(const char *signature) const
 
 int DynamicSlotDataV2::addSlot(const char *signature)
 {
+    qDebug() << "DynamicSlotDataV2" << __FUNCTION__ << signature
+                << "thread=" << QThread::currentThreadId();
     int index = id(signature);
     if (index == -1)
         index = m_signatures[signature] = m_parent->metaObjectBuilder().addSlot(signature);
@@ -167,6 +178,7 @@ int DynamicSlotDataV2::addSlot(const char *signature)
 
 void DynamicSlotDataV2::onCallbackDestroyed(void *data)
 {
+    qDebug() << "DynamicSlotDataV2" << __FUNCTION__ ;
     auto self = reinterpret_cast<DynamicSlotDataV2 *>(data);
     self->m_weakRef = 0;
     Py_BEGIN_ALLOW_THREADS
@@ -190,6 +202,8 @@ GlobalReceiverV2::GlobalReceiverV2(PyObject *callback, SharedMap map) :
     m_metaObject("__GlobalReceiver__", &QObject::staticMetaObject),
     m_sharedMap(std::move(map))
 {
+    qDebug() << "GlobalReceiverV2::GlobalReceiverV2";
+
     m_data = new DynamicSlotDataV2(callback, this);
     m_metaObject.addSlot(RECEIVER_DESTROYED_SLOT_NAME);
     m_metaObject.update();
@@ -224,6 +238,8 @@ GlobalReceiverV2::~GlobalReceiverV2()
 
 int GlobalReceiverV2::addSlot(const char *signature)
 {
+    qDebug() << "GlobalReceiverV2" << __FUNCTION__ << signature
+                  << "thread=" << QThread::currentThreadId();
     return m_data->addSlot(signature);
 }
 
@@ -313,6 +329,8 @@ const QMetaObject *GlobalReceiverV2::metaObject() const
 
 int GlobalReceiverV2::qt_metacall(QMetaObject::Call call, int id, void **args)
 {
+     qDebug() << "GlobalReceiverV2::qt_metacall" <<  call << id
+                   << "thread=" << QThread::currentThreadId();
     Shiboken::GilState gil;
     Q_ASSERT(call == QMetaObject::InvokeMetaMethod);
     Q_ASSERT(id >= QObject::staticMetaObject.methodCount());
@@ -339,6 +357,8 @@ int GlobalReceiverV2::qt_metacall(QMetaObject::Call call, int id, void **args)
     } else {
         bool isShortCuit = (strstr(slot.methodSignature(), "(") == 0);
         Shiboken::AutoDecRef callback(m_data->callback());
+        qDebug() << __FUNCTION__  << "calling SignalManager::callPythonMetaMethod()"
+                      << "thread=" << QThread::currentThreadId();
         SignalManager::callPythonMetaMethod(slot, args, callback, isShortCuit);
     }
 
diff --git a/sources/pyside2/libpyside/pyside.cpp b/sources/pyside2/libpyside/pyside.cpp
index 66e93116..3c551d6f 100644
--- a/sources/pyside2/libpyside/pyside.cpp
+++ b/sources/pyside2/libpyside/pyside.cpp
@@ -66,6 +66,8 @@
 #include <QtCore/QFileInfo>
 #include <QtCore/QSharedPointer>
 #include <QtCore/QStack>
+#include <QtCore/QDebug>
+#include <QtCore/QThread>
 
 #include <algorithm>
 #include <cstring>
@@ -350,6 +352,9 @@ PyObject *getMetaDataFromQObject(QObject *cppSelf, PyObject *self, PyObject *nam
                         if (func) {
                             PyObject *result = reinterpret_cast<PyObject *>(func);
                             PyObject_SetAttr(self, name, result);
+                            qDebug() << __FUNCTION__ <<  "new PySideMetaFunction "
+                                         << methSig_ <<i << "self=" << result
+                                              << "thread=" << QThread::currentThreadId();
                             return result;
                         }
                     }
diff --git a/sources/pyside2/libpyside/pysidemetafunction.cpp b/sources/pyside2/libpyside/pysidemetafunction.cpp
index f4b95385..22655c3c 100644
--- a/sources/pyside2/libpyside/pysidemetafunction.cpp
+++ b/sources/pyside2/libpyside/pysidemetafunction.cpp
@@ -44,6 +44,8 @@
 #include <signature.h>
 
 #include <QtCore/QMetaMethod>
+#include <QtCore/QDebug>
+#include <QtCore/QThread>
 
 extern "C"
 {
@@ -92,6 +94,8 @@ PyObject *functionCall(PyObject *self, PyObject *args, PyObject * /* kw */)
     PySideMetaFunction *function = reinterpret_cast<PySideMetaFunction *>(self);
 
     PyObject *retVal;
+    qDebug() << __FUNCTION__ << function->d->qobject << function->d->methodIndex
+                  << "thread=" << QThread::currentThreadId();
     if (!PySide::MetaFunction::call(function->d->qobject, function->d->methodIndex, args, &retVal))
         return 0;
     return retVal;
@@ -134,6 +138,8 @@ PySideMetaFunction *newObject(QObject *source, int methodIndex)
 bool call(QObject *self, int methodIndex, PyObject *args, PyObject **retVal)
 {
 
+    qDebug() << __FUNCTION__ << self << methodIndex
+                << "thread=" << QThread::currentThreadId();
     QMetaMethod method = self->metaObject()->method(methodIndex);
     QList<QByteArray> argTypes = method.parameterTypes();
 
@@ -204,6 +210,7 @@ bool call(QObject *self, int methodIndex, PyObject *args, PyObject **retVal)
     bool ok = i == numArgs;
     if (ok) {
         Py_BEGIN_ALLOW_THREADS
+        qDebug() << __FUNCTION__ << self << method.methodIndex();
         QMetaObject::metacall(self, QMetaObject::InvokeMetaMethod, method.methodIndex(), methArgs);
         Py_END_ALLOW_THREADS
 
diff --git a/sources/pyside2/libpyside/pysideslot.cpp b/sources/pyside2/libpyside/pysideslot.cpp
index 7bfd1719..25b6881b 100644
--- a/sources/pyside2/libpyside/pysideslot.cpp
+++ b/sources/pyside2/libpyside/pysideslot.cpp
@@ -45,6 +45,7 @@
 
 #include <QtCore/QMetaObject>
 #include <QtCore/QString>
+#include <QtCore/QDebug>
 #include <signature.h>
 
 using namespace Shiboken;
@@ -127,6 +128,7 @@ int slotTpInit(PyObject *self, PyObject *args, PyObject *kw)
 
     data->slotData->resultType = argResult
         ? PySide::Signal::getTypeName(argResult) : PySide::Signal::voidType();
+    qDebug() << __FUNCTION__ << "slot" << data->slotData->resultType  << "N" << data->slotData->name << "Args" << data->slotData->args;
 
     return 0;
 }
@@ -138,8 +140,10 @@ PyObject *slotCall(PyObject *self, PyObject *args, PyObject * /* kw */)
     callback = PyTuple_GetItem(args, 0);
     Py_INCREF(callback);
 
+    qDebug() << __FUNCTION__ << '>';
     if (Py_TYPE(callback)->tp_call != nullptr) {
         PySideSlot *data = reinterpret_cast<PySideSlot *>(self);
+         qDebug() << __FUNCTION__ << "recreating";
 
         if (!data->slotData)
             data->slotData = new SlotData;
@@ -148,7 +152,9 @@ PyObject *slotCall(PyObject *self, PyObject *args, PyObject * /* kw */)
             // PYSIDE-198: Use PyObject_GetAttr instead of PepFunction_GetName to support Nuitka.
             AutoDecRef funcName(PyObject_GetAttr(callback, PyMagicName::name()));
             data->slotData->name = String::toCString(funcName);
+            qDebug() << __FUNCTION__ << "empty name" << data->slotData->name;
         }
+        qDebug() << __FUNCTION__ << "slot" << data->slotData->resultType  << "N" << data->slotData->name << "Args" << data->slotData->args;
         const QByteArray returnType = QMetaObject::normalizedType(data->slotData->resultType);
         const QByteArray signature =
             returnType + ' ' + data->slotData->name + '(' + data->slotData->args + ')';
@@ -157,12 +163,16 @@ PyObject *slotCall(PyObject *self, PyObject *args, PyObject * /* kw */)
             pySlotName = String::fromCString(PYSIDE_SLOT_LIST_ATTR);
 
         PyObject *pySignature = String::fromCString(signature);
+        qDebug() << __FUNCTION__ <<  "rett" << returnType << "sig" << signature
+                 << "pySlotName=" <<  _PepUnicode_AsString(pySlotName);
         PyObject *signatureList = 0;
         if (PyObject_HasAttr(callback, pySlotName)) {
             signatureList = PyObject_GetAttr(callback, pySlotName);
+            qDebug() << __FUNCTION__ <<  "retrieved sig list";
         } else {
             signatureList = PyList_New(0);
             PyObject_SetAttr(callback, pySlotName, signatureList);
+            qDebug() << __FUNCTION__ <<  "set sig list";
             Py_DECREF(signatureList);
         }
 
@@ -173,7 +183,14 @@ PyObject *slotCall(PyObject *self, PyObject *args, PyObject * /* kw */)
         delete data->slotData;
         data->slotData = nullptr;
         return callback;
+    } else {
+        PySideSlot *data = reinterpret_cast<PySideSlot *>(self);
+        qDebug() << __FUNCTION__ << "existing";
+        if (data)
+            qDebug() << __FUNCTION__ << "slot" << data->slotData->resultType  << "N" << data->slotData->name << "Args" << data->slotData->args;
+
     }
+    qDebug() << __FUNCTION__ << '<';
     return callback;
 }
 
diff --git a/sources/pyside2/libpyside/signalmanager.cpp b/sources/pyside2/libpyside/signalmanager.cpp
index 93847e06..02a6113a 100644
--- a/sources/pyside2/libpyside/signalmanager.cpp
+++ b/sources/pyside2/libpyside/signalmanager.cpp
@@ -51,14 +51,17 @@
 #include <basewrapper.h>
 #include <bindingmanager.h>
 #include <gilstate.h>
+#include <helper.h>
 #include <sbkconverter.h>
 #include <sbkstring.h>
 #include <sbkstaticstrings.h>
 
 #include <QtCore/QDebug>
 #include <QtCore/QHash>
+#include <QtCore/QThread>
 
 #include <algorithm>
+#include <iostream>
 #include <limits>
 
 // These private headers are needed to throw JavaScript exceptions
@@ -312,6 +315,7 @@ SignalManager &SignalManager::instance()
 
 QObject *SignalManager::globalReceiver(QObject *sender, PyObject *callback)
 {
+    qDebug() << __FUNCTION__ << "sender=" << sender << callback;
     SharedMap globalReceivers = m_d->m_globalReceivers;
     QByteArray hash = GlobalReceiverV2::hash(callback);
     GlobalReceiverV2 *gr = nullptr;
@@ -355,17 +359,21 @@ void SignalManager::releaseGlobalReceiver(const QObject *source, QObject *receiv
 
 int SignalManager::globalReceiverSlotIndex(QObject *receiver, const char *signature) const
 {
-    return reinterpret_cast<GlobalReceiverV2 *>(receiver)->addSlot(signature);
+    int r = reinterpret_cast<GlobalReceiverV2 *>(receiver)->addSlot(signature);
+    qDebug() << __FUNCTION__ << receiver << signature << "rets" << r;
+    return r;
 }
 
 bool SignalManager::emitSignal(QObject *source, const char *signal, PyObject *args)
 {
+    qDebug() << __FUNCTION__ << source << signal<< "thread=" << QThread::currentThreadId();
     if (!Signal::checkQtSignal(signal))
         return false;
     signal++;
 
     int signalIndex = source->metaObject()->indexOfSignal(signal);
     if (signalIndex != -1) {
+        qDebug() << __FUNCTION__ << "emit";
         // cryptic but works!
         // if the signature doesn't have a '(' it's a shor circuited signal, i.e. std::find
         // returned the string null terminator.
@@ -380,6 +388,8 @@ bool SignalManager::emitSignal(QObject *source, const char *signal, PyObject *ar
 
 int SignalManager::qt_metacall(QObject *object, QMetaObject::Call call, int id, void **args)
 {
+    qDebug() << "SignalManager::qt_metacall()" << object << call  << id
+                << "thread=" << QThread::currentThreadId();
     const QMetaObject *metaObject = object->metaObject();
     PySideProperty *pp = nullptr;
     PyObject *pp_name = nullptr;
@@ -422,6 +432,7 @@ int SignalManager::qt_metacall(QObject *object, QMetaObject::Call call, int id,
             break;
 #endif
         case QMetaObject::InvokeMetaMethod:
+            qDebug() << "SignalManager::qt_metacall(InvokeMetaMethod" <<  object<<  id;
             id = callMethod(object, id, args);
             break;
 
@@ -518,6 +529,8 @@ int SignalManager::callPythonMetaMethod(const QMetaMethod &method, void **args,
 
     Shiboken::GilState gil;
     PyObject *pyArguments = nullptr;
+    qDebug() << "SignalManager:" << __FUNCTION__ << method.name() << "isShortCuit=" << isShortCuit
+             << "thread=" << QThread::currentThreadId();
 
     if (isShortCuit){
         pyArguments = reinterpret_cast<PyObject *>(args[1]);
@@ -536,7 +549,9 @@ int SignalManager::callPythonMetaMethod(const QMetaMethod &method, void **args,
             }
         }
 
+        qDebug() << "SignalManager:" << __FUNCTION__ << ">Calling";
         Shiboken::AutoDecRef retval(PyObject_CallObject(pyMethod, pyArguments));
+        qDebug() << "SignalManager:" << __FUNCTION__ << "<Calling";
 
         if (!isShortCuit && pyArguments){
             Py_DECREF(pyArguments);
@@ -581,6 +596,9 @@ static MetaObjectBuilder *metaBuilderFromDict(PyObject *dict)
 
 int SignalManager::registerMetaMethodGetIndex(QObject *source, const char *signature, QMetaMethod::MethodType type)
 {
+    qDebug() << __FUNCTION__ <<  source << signature << type
+                << "thread=" << QThread::currentThreadId();
+
     if (!source) {
         qWarning("SignalManager::registerMetaMethodGetIndex(\"%s\") called with source=nullptr.",
                  signature);
@@ -588,8 +606,11 @@ int SignalManager::registerMetaMethodGetIndex(QObject *source, const char *signa
     }
     const QMetaObject *metaObject = source->metaObject();
     int methodIndex = metaObject->indexOfMethod(signature);
+    qDebug() << __FUNCTION__ <<  source << signature << type;
     // Create the dynamic signal is needed
     if (methodIndex == -1) {
+        qDebug() << __FUNCTION__ <<  " dynamic signal "
+                    << "thread=" << QThread::currentThreadId();
         SbkObject *self = Shiboken::BindingManager::instance().retrieveWrapper(source);
         if (!Shiboken::Object::hasCppWrapper(self)) {
             qWarning() << "Invalid Signal signature:" << signature;
@@ -618,6 +639,7 @@ int SignalManager::registerMetaMethodGetIndex(QObject *source, const char *signa
                 return dmo->addSlot(signature);
         }
     }
+    qDebug() << __FUNCTION__ <<  "rets"<< methodIndex;
     return methodIndex;
 }
 
@@ -644,6 +666,8 @@ namespace {
 
 static int callMethod(QObject *object, int id, void **args)
 {
+    qDebug() << __FUNCTION__ << object << "id=" << id << "thread=" << QThread::currentThreadId();
+    static int n = 0;
     const QMetaObject *metaObject = object->metaObject();
     QMetaMethod method = metaObject->method(id);
 
@@ -655,8 +679,15 @@ static int callMethod(QObject *object, int id, void **args)
         auto self = reinterpret_cast<PyObject *>(Shiboken::BindingManager::instance().retrieveWrapper(object));
         QByteArray methodName = method.methodSignature();
         methodName.truncate(methodName.indexOf('('));
+        qDebug() << __FUNCTION__ << "id=" << id << method.methodSignature() << "methodName=" << methodName;
         Shiboken::AutoDecRef pyMethod(PyObject_GetAttrString(self, methodName));
-        return SignalManager::callPythonMetaMethod(method, args, pyMethod, false);
+        std::cerr << __FUNCTION__ << ' ' << "obj self=" << pyMethod.object()
+                  << ' ' << methodName.constData() << ' ' << Shiboken::debugPyObject(pyMethod) << '\n';
+        int r = SignalManager::callPythonMetaMethod(method, args, pyMethod, false);
+        qDebug() << __FUNCTION__ <<  object << id << "rets"<<  r;
+        if (n++ > 40)
+            qFatal("REC!");
+
     }
     return -1;
 }
