{

if (!_self) {

_self = new PythonQt(flags, pythonQtModuleName);

_self->_p->_PythonQtObjectPtr_metaId = qRegisterMetaType<PythonQtObjectPtr>("PythonQtObjectPtr");

PythonQtConv::registerMetaTypeToPythonConverter(_self->_p->_PythonQtObjectPtr_metaId,

PythonQtConv::convertFromPythonQtObjectPtr);

PythonQtConv::registerPythonToMetaTypeConverter(_self->_p->_PythonQtObjectPtr_metaId,

PythonQtConv::convertToPythonQtObjectPtr);

_self->_p->_PythonQtSafeObjectPtr_metaId = qRegisterMetaType<PythonQtSafeObjectPtr>("PythonQtSafeObjectPtr");

PythonQtConv::registerMetaTypeToPythonConverter(_self->_p->_PythonQtSafeObjectPtr_metaId,

PythonQtConv::convertFromPythonQtSafeObjectPtr);

PythonQtConv::registerPythonToMetaTypeConverter(_self->_p->_PythonQtSafeObjectPtr_metaId,

PythonQtConv::convertToPythonQtSafeObjectPtr);

PythonQtObjectPtr importlib;

importlib.setNewRef(PyImport_ImportModule("importlib.machinery"));

if (importlib) {

_self->_p->_pySourceFileLoader = importlib.getVariable("SourceFileLoader");

_self->_p->_pySourcelessFileLoader = importlib.getVariable("SourcelessFileLoader");

}

// Import asyncio only when not explicitly disabled.

// Importing asyncio on Py3.12+ pulls in ssl/_ssl; some environments/tests

// want to avoid that during early embedded init.

if (!qEnvironmentVariableIsSet("PYTHONQT_DISABLE_ASYNCIO")) {

PythonQtObjectPtr asyncio;

asyncio.setNewRef(PyImport_ImportModule("asyncio"));

if (asyncio) {

_self->_p->_pyEnsureFuture = asyncio.getVariable("ensure_future");

_self->_p->_pyFutureClass = asyncio.getVariable("Future");

}

}

PythonQt::priv()->setupSharedLibrarySuffixes();

PythonQtMethodInfo::addParameterTypeAlias("QObjectList", "QList<QObject*>");

qRegisterMetaType<QList<QObject*>>("QList<void*>");

// QObjectList might already be registered by other modules (e.g. QtScript) or under different type names.

// To avoid conflicts or warnings, only register it if it is currently unknown.

if (QMetaType::type("QObjectList") == QMetaType::UnknownType) {

qRegisterMetaType<QObjectList>("QObjectList");

}

qRegisterMetaType<QList<QObject*>>("QList<QObject*>");

if (QT_POINTER_SIZE == 8) {

qRegisterMetaType<quint64>("size_t");

} else {

qRegisterMetaType<quint32>("size_t");

}

PythonQtConv::registerStringViewTypes();

int objectPtrListId = qRegisterMetaType<QList<PythonQtObjectPtr>>("QList<PythonQtObjectPtr>");

PythonQtConv::registerMetaTypeToPythonConverter(objectPtrListId, PythonQtConv::convertFromQListOfPythonQtObjectPtr);

PythonQtConv::registerPythonToMetaTypeConverter(objectPtrListId, PythonQtConv::convertToQListOfPythonQtObjectPtr);

PythonQtRegisterToolClassesTemplateConverter(int);

PythonQtRegisterToolClassesTemplateConverter(bool);

PythonQtRegisterToolClassesTemplateConverter(float);

PythonQtRegisterToolClassesTemplateConverter(double);

PythonQtRegisterToolClassesTemplateConverter(qint32);

PythonQtRegisterToolClassesTemplateConverter(quint32);

PythonQtRegisterToolClassesTemplateConverter(qint64);

PythonQtRegisterToolClassesTemplateConverter(quint64);

#ifdef PYTHONQT_SUPPORT_ML_TYPES

PythonQtMethodInfo::addParameterTypeAlias("QList<MLfloat>", "QList<float>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<MLfloat>", "QVector<float>");

PythonQtMethodInfo::addParameterTypeAlias("QList<MLdouble>", "QList<double>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<MLdouble>", "QVector<double>");

PythonQtMethodInfo::addParameterTypeAlias("QList<MLuint32>", "QList<quint32>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<MLuint32>", "QVector<quint32>");

PythonQtMethodInfo::addParameterTypeAlias("QList<MLint32>", "QList<qint32>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<MLint32>", "QVector<qint32>");

PythonQtMethodInfo::addParameterTypeAlias("QList<MLuint64>", "QList<quint64>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<MLuint64>", "QVector<quint64>");

PythonQtMethodInfo::addParameterTypeAlias("QList<MLint64>", "QList<qint64>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<MLint64>", "QVector<qint64>");

PythonQtMethodInfo::addParameterTypeAlias("QList<MLuint>", "QList<quint64>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<MLuint>", "QVector<quint64>");

PythonQtMethodInfo::addParameterTypeAlias("QList<MLint>", "QList<qint64>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<MLint>", "QVector<qint64>");

#endif

PythonQtMethodInfo::addParameterTypeAlias("QList<qreal>", "QList<double>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<qreal>", "QVector<double>");

PythonQtMethodInfo::addParameterTypeAlias("QList<unsigned int>", "QList<quint32>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<unsigned int>", "QVector<quint32>");

// Qt 4 uses uint, while Qt 5 uses unsigned int, seems to be a moc change...

PythonQtMethodInfo::addParameterTypeAlias("QList<uint>", "QList<quint32>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<uint>", "QVector<quint32>");

PythonQtMethodInfo::addParameterTypeAlias("QList<int>", "QList<qint32>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<int>", "QVector<qint32>");

PythonQtMethodInfo::addParameterTypeAlias("QList<GLint>", "QList<qint32>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<GLint>", "QVector<qint32>");

PythonQtMethodInfo::addParameterTypeAlias("QList<GLuint>", "QList<qint32>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<GLuint>", "QVector<quint32>");

PythonQtMethodInfo::addParameterTypeAlias("QList<GLuint64>", "QList<quint64>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<GLuint64>", "QVector<quint64>");

PythonQtMethodInfo::addParameterTypeAlias("QList<GLint64>", "QList<qint64>");

PythonQtMethodInfo::addParameterTypeAlias("QVector<GLint64>", "QVector<qint64>");

PythonQtMethodInfo::addParameterTypeAlias("QList<QLocale::Country>", "QList<int>");

PythonQtMethodInfo::addParameterTypeAlias("QList<Qt::DayOfWeek>", "QList<int>");

// register some QPairs that are used in the Qt interfaces:

PythonQtRegisterQPairConverter(int, int);

PythonQtRegisterQPairConverter(float, float);

PythonQtRegisterQPairConverter(double, double);

PythonQtRegisterQPairConverter(QString, QString);

PythonQtRegisterQPairConverter(QByteArray, QByteArray);

PythonQtRegisterQPairConverter(double, QColor);

PythonQtRegisterQPairConverter(double, QPointF);

PythonQtRegisterQPairConverter(double, QVariant);

PythonQtRegisterQPairConverter(QString, QSizeF);

PythonQtMethodInfo::addParameterTypeAlias("QPair<qreal,qreal>", "QPair<double,double>");

PythonQtMethodInfo::addParameterTypeAlias("QPair<qreal,QColor>", "QPair<double,QColor>");

PythonQtMethodInfo::addParameterTypeAlias("QPair<qreal,QPointF>", "QPair<double,QPointF>");

PythonQtMethodInfo::addParameterTypeAlias("QPair<qreal,QVariant>", "QPair<double,QVariant>");

PythonQtMethodInfo::addParameterTypeAlias("QPair<QOpenGLTexture::Filter,QOpenGLTexture::Filter>", "QPair<int,int>");

// register some QList/QVector of QPairs that are used in the Qt interfaces:

PythonQtRegisterListTemplateQPairConverter(QVector, double, QVariant);

PythonQtRegisterListTemplateQPairConverter(QVector, double, QColor);

// NOTE: the extra space between the > is needed (and added by the moc)

PythonQtMethodInfo::addParameterTypeAlias("QVector<QPair<qreal,QVariant> >", "QVector<QPair<double,QVariant> >");

PythonQtMethodInfo::addParameterTypeAlias("QVector<QPair<qreal,QColor> >", "QVector<QPair<double,QColor> >");

PythonQtRegisterListTemplateQPairConverter(QList, QByteArray, QByteArray);

PythonQtRegisterListTemplateQPairConverter(QList, QString, QString);

PythonQtRegisterListTemplateQPairConverter(QList, QString, QSizeF);

PythonQtRegisterListTemplateQPairConverter(QList, double, QPointF);

PythonQtRegisterListTemplateQPairConverter(QList, double, double);

// NOTE: the extra space between the > is needed (and added by the moc)

PythonQtMethodInfo::addParameterTypeAlias("QList<QPair<qreal,QPointF> >", "QList<QPair<double,QPointF> >");

PythonQtMethodInfo::addParameterTypeAlias("QList<QPair<qreal,qreal> >", "QList<QPair<double,double> >");

PythonQtRegisterIntegerMapConverter(QMap, QByteArray);

PythonQtRegisterIntegerMapConverter(QMap, QVariant);

PythonQtRegisterIntegerMapConverter(QMap, QString);

PythonQtRegisterIntegerMapConverter(QHash, QByteArray);

PythonQtRegisterIntegerMapConverter(QHash, QVariant);

PythonQtRegisterIntegerMapConverter(QHash, QString);

PythonQtMethodInfo::addParameterTypeAlias("QHash<QNetworkRequest::Attribute,QVariant>", "QHash<int,QVariant>");

PythonQt_init_QtCoreBuiltin(nullptr);

PythonQt_init_QtGuiBuiltin(nullptr);

PythonQt::self()->addDecorators(new PythonQtStdDecorators());

PythonQt::self()->registerCPPClass("QMetaObject", nullptr, "QtCore",

PythonQtCreateObject<PythonQtWrapper_QMetaObject>);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QByteArray);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QDate);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QTime);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QDateTime);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QUrl);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QLocale);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QRect);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QRectF);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QSize);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QSizeF);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QLine);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QLineF);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QPoint);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QPointF);

#if QT_VERSION < 0x060000

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QRegExp);

#endif

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QRegularExpression);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QFont);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QPixmap);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QBrush);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QColor);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QPalette);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QIcon);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QImage);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QPolygon);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QRegion);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QBitmap);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QCursor);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QSizePolicy);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QKeySequence);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QPen);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QTextLength);

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QTextFormat);

#if QT_VERSION < 0x060000

PythonQtRegisterToolClassesTemplateConverterForKnownClass(QMatrix);

#endif

PyObject* pack = PythonQt::priv()->packageByName("QtCore");

PyObject* pack2 = PythonQt::priv()->packageByName("Qt");

PyObject* qtNamespace = PythonQt::priv()->getClassInfo("Qt")->pythonQtClassWrapper();

const char* names[16] = {"SIGNAL", "SLOT", "qAbs", "qBound", "qDebug", "qWarning", "qCritical", "qFatal",

"qFuzzyCompare", "qMax", "qMin", "qRound", "qRound64", "qVersion", "qrand", "qsrand"};

for (unsigned int i = 0; i < sizeof(names) / sizeof(names[0]); i++) {

PyObject* obj = PyObject_GetAttrString(qtNamespace, names[i]);

if (obj) {

if (PyModule_AddObject(pack, names[i], obj) < 0) {

std::cerr << "failed to add " << names[i] << " to QtCore\n";

} else {

Py_INCREF(obj);

}

if (PyModule_AddObject(pack2, names[i], obj) < 0) {

Py_DECREF(obj);

std::cerr << "failed to add " << names[i] << " to Qt\n";

}

} else {

std::cerr << "method not found " << names[i] << std::endl;

}

}

int enumValues[] = {QtDebugMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg, QtSystemMsg};

const char* enumNames[] = {"QtDebugMsg", "QtWarningMsg", "QtCriticalMsg", "QtFatalMsg", "QtSystemMsg"};

for (auto i = 0u; i < sizeof(enumValues) / sizeof(int); i++) {

PyObject* obj = PyLong_FromLong(enumValues[i]);

if (PyModule_AddObject(pack, enumNames[i], obj) == 0) {

Py_INCREF(obj);

}

if (PyModule_AddObject(pack2, enumNames[i], obj) < 0) {

Py_DECREF(obj);

}

}

_self->priv()->pythonQtModule().addObject("Debug", _self->priv()->_debugAPI);

_self->priv()->pythonQtModule().addObject("Config", _self->priv()->_configAPI);

Py_INCREF((PyObject*)&PythonQtSlotDecorator_Type);

Py_INCREF((PyObject*)&PythonQtSignalFunction_Type);

Py_INCREF((PyObject*)&PythonQtProperty_Type);

PyModule_AddObject(pack, "Slot", (PyObject*)&PythonQtSlotDecorator_Type);

PyModule_AddObject(pack, "Signal", (PyObject*)&PythonQtSignalFunction_Type);

PyModule_AddObject(pack, "Property", (PyObject*)&PythonQtProperty_Type);

}

{

if (_self) {

// Remove all created signal receivers

_self->removeSignalHandlers();

delete _self;

_self = nullptr;

}

{

_p = new PythonQtPrivate;

_p->_initFlags = flags;

if ((flags & PythonAlreadyInitialized) == 0) {

Py_SetProgramName(const_cast<wchar_t*>(L"PythonQt"));

if (flags & IgnoreSiteModule) {

// this prevents the automatic importing of Python site files

Py_NoSiteFlag = 1;

}

Py_Initialize();

}

// add our own python object types for qt object slots

if (PyType_Ready(&PythonQtSlotFunction_Type) < 0) {

std::cerr << "could not initialize PythonQtSlotFunction_Type" << ", in " << __FILE__ << ":" << __LINE__

<< std::endl;

}

Py_INCREF(&PythonQtSlotFunction_Type);

if (PyType_Ready(&PythonQtSignalFunction_Type) < 0) {

std::cerr << "could not initialize PythonQtSignalFunction_Type" << ", in " << __FILE__ << ":" << __LINE__

<< std::endl;

}

Py_INCREF(&PythonQtSignalFunction_Type);

if (PyType_Ready(&PythonQtSlotDecorator_Type) < 0) {

std::cerr << "could not initialize PythonQtSlotDecorator_Type" << ", in " << __FILE__ << ":" << __LINE__

<< std::endl;

}

Py_INCREF(&PythonQtSlotDecorator_Type);

if (PyType_Ready(&PythonQtProperty_Type) < 0) {

std::cerr << "could not initialize PythonQtProperty_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;

}

Py_INCREF(&PythonQtProperty_Type);

PythonQtBoolResult_Type.tp_new = PyType_GenericNew;

if (PyType_Ready(&PythonQtBoolResult_Type) < 0) {

std::cerr << "could not initialize PythonQtBoolResult_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;

}

Py_INCREF(&PythonQtBoolResult_Type);

// according to Python docs, set the type late here, since it can not safely be stored in the struct when declaring it

PythonQtClassWrapper_Type.tp_base = &PyType_Type;

// add our own python object types for classes

if (PyType_Ready(&PythonQtClassWrapper_Type) < 0) {

std::cerr << "could not initialize PythonQtClassWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__

<< std::endl;

}

Py_INCREF(&PythonQtClassWrapper_Type);

// add our own python object types for CPP instances

if (PyType_Ready(&PythonQtInstanceWrapper_Type) < 0) {

PythonQt::handleError();

std::cerr << "could not initialize PythonQtInstanceWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__

<< std::endl;

}

Py_INCREF(&PythonQtInstanceWrapper_Type);

// add our own python object types for redirection of stdout

if (PyType_Ready(&PythonQtStdOutRedirectType) < 0) {

std::cerr << "could not initialize PythonQtStdOutRedirectType" << ", in " << __FILE__ << ":" << __LINE__

<< std::endl;

}

Py_INCREF(&PythonQtStdOutRedirectType);

// add our own python object types for redirection of stdin

if (PyType_Ready(&PythonQtStdInRedirectType) < 0) {

std::cerr << "could not initialize PythonQtStdInRedirectType" << ", in " << __FILE__ << ":" << __LINE__

<< std::endl;

}

Py_INCREF(&PythonQtStdInRedirectType);

initPythonQtModule(flags & RedirectStdOut, pythonQtModuleName);

{

PythonQtObjectPtr result;

if (!PyCoro_CheckExact(object)) {

return result;

}

if (!_pyEnsureFuture) {

std::cerr << "PythonQt: ensure_future not initialized" << std::endl;

return PythonQtObjectPtr();

}

PyObject* args = PyTuple_New(1);

PyObject* coro = object.object();

Py_INCREF(coro);

PyTuple_SetItem(args, 0, coro);

PyObject* r = PyObject_CallObject(_pyEnsureFuture, args);

result.setNewRef(r);

if (_pyTaskDoneCallback) {

PyObject* methodName = PyUnicode_FromString("add_done_callback");

PyObject_CallMethodObjArgs(r, methodName, _pyTaskDoneCallback.object(), nullptr);

Py_XDECREF(methodName);

}

Py_XDECREF(args);

return result;

{

if (!_pyFutureClass) {

std::cerr << "PythonQt: _pyFutureClass not initialized" << std::endl;

return nullptr;

}

return _pyFutureClass.call();

{

if (!callback) {

std::cerr << "PythonQt::setRedirectStdInCallback - callback parameter is NULL !" << std::endl;

return;

}

PythonQtObjectPtr sys;

PythonQtObjectPtr in;

sys.setNewRef(PyImport_ImportModule("sys"));

// Backup original 'sys.stdin' if not yet done

if (!PyObject_HasAttrString(sys.object(), "pythonqt_original_stdin")) {

PyObject_SetAttrString(sys.object(), "pythonqt_original_stdin", PyObject_GetAttrString(sys.object(), "stdin"));

}

in = PythonQtStdInRedirectType.tp_new(&PythonQtStdInRedirectType, nullptr, nullptr);

((PythonQtStdInRedirect*)in.object())->_cb = callback;

((PythonQtStdInRedirect*)in.object())->_callData = callbackData;

// replace the built in file objects with our own objects

PyModule_AddObject(sys.object(), "stdin", in);

// Backup custom 'stdin' into 'pythonqt_stdin'

Py_INCREF(in); // AddObject steals the reference, so increment it

PyModule_AddObject(sys.object(), "pythonqt_stdin", in);

{

PythonQtObjectPtr sys;

sys.setNewRef(PyImport_ImportModule("sys"));

if (enabled) {

if (PyObject_HasAttrString(sys.object(), "pythonqt_stdin")) {

PyObject_SetAttrString(sys.object(), "stdin", PyObject_GetAttrString(sys.object(), "pythonqt_stdin"));

}

} else {

if (PyObject_HasAttrString(sys.object(), "pythonqt_original_stdin")) {

PyObject_SetAttrString(sys.object(), "stdin", PyObject_GetAttrString(sys.object(), "pythonqt_original_stdin"));

}

}

{

if (_self->_p->_noLongerWrappedCB) {

(*_self->_p->_noLongerWrappedCB)(o);

}

{

if (_self && _self->_p && _self->_p->_qObjectMissingAttribCB) {

return _self->_p->_qObjectMissingAttribCB(o, attribute);

} else {

return QString();

}

PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell)

{

_p->registerClass(metaobject, package, wrapperCreator, shell);

PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell, PyObject* module,

int typeSlots)

{

// we register all classes in the hierarchy

const QMetaObject* m = metaobject;

bool first = true;

while (m) {

PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(m->className());

if (!info->pythonQtClassWrapper()) {

info->setTypeSlots(typeSlots);

info->setupQObject(m);

createPythonQtClassWrapper(info, package, module);

if (m->superClass()) {

PythonQtClassInfo* parentInfo = lookupClassInfoAndCreateIfNotPresent(m->superClass()->className());

info->addParentClass(PythonQtClassInfo::ParentClassInfo(parentInfo));

}

} else if (first && (module || (package && package[0]))) {

// There is a wrapper already, but if we got a module, we want to place the wrapper into that module as well,

// since it might have been placed into "private" earlier on.

// If the wrapper was already added to module before, it is just readded, which does no harm.

PyObject* classWrapper = info->pythonQtClassWrapper();

// AddObject steals a reference, so we need to INCREF

Py_INCREF(classWrapper);

PyObject* pack = module ? module : packageByName(package); // same logic like in createPythonQtClassWrapper

if (PyModule_AddObject(pack, info->className(), classWrapper) < 0) {

Py_DECREF(classWrapper);

}

}

if (first) {

first = false;

if (wrapperCreator) {

info->setDecoratorProvider(wrapperCreator);

}

if (shell) {

info->setShellSetInstanceWrapperCB(shell);

}

}

m = m->superClass();

}

{

QByteArray pythonClassName = info->className();

int nestedClassIndex = pythonClassName.indexOf("::");

bool isNested = false;

if (nestedClassIndex > 0) {

pythonClassName = pythonClassName.mid(nestedClassIndex + 2);

isNested = true;

}

PyObject* pack = module ? module : packageByName(package);

PyObject* pyobj = (PyObject*)createNewPythonQtClassWrapper(info, pack, pythonClassName);

if (isNested) {

QByteArray outerClass = QByteArray(info->className()).mid(0, nestedClassIndex);

PythonQtClassInfo* outerClassInfo = lookupClassInfoAndCreateIfNotPresent(outerClass);

outerClassInfo->addNestedClass(info);

} else {

if (PyModule_AddObject(pack, info->className(), pyobj) == 0) {

// since PyModule_AddObject steals the reference, we need a incref once more...

Py_INCREF(pyobj);

}

}

if (!module && package && strncmp(package, "Qt", 2) == 0) {

// put all qt objects into Qt as well

if (PyModule_AddObject(packageByName("Qt"), info->className(), pyobj) == 0) {

// since PyModule_AddObject steals the reference, we need a incref once more...

Py_INCREF(pyobj);

}

}

info->setPythonQtClassWrapper(pyobj);

{

PythonQtObjectPtr callable = lookupCallable(module, objectname);

if (callable) {

return _p->addSignalHandler(obj, signal, callable);

}

// callable not found

return false;

{

PythonQtObjectPtr callable = lookupCallable(module, objectname);

if (callable) {

return _p->removeSignalHandler(obj, signal, callable);

}

// callable not found

return false;

{

PythonQtObjectPtr p = lookupObject(module, name);

if (p) {

if (PyCallable_Check(p)) {

return p;

}

}

PyErr_Clear();

return nullptr;

{

QStringList l = name.split('.');

PythonQtObjectPtr p = module;

PythonQtObjectPtr prev;

QByteArray b;

for (QStringList::ConstIterator i = l.begin(); i != l.end() && p; ++i) {

prev = p;

b = QStringToPythonEncoding(*i);

if (PyDict_Check(p)) {

p = PyDict_GetItemString(p, b.data());

} else {

p.setNewRef(PyObject_GetAttrString(p, b.data()));

}

}

PyErr_Clear();

return p;

{

//both borrowed

PythonQtObjectPtr dict = PyImport_GetModuleDict();

return PyDict_GetItemString(dict, "__main__");

{

PythonQtObjectPtr mod;

mod.setNewRef(PyImport_ImportModule(QStringToPythonCharPointer(name)));

return mod;

{

QVariant result;

clearError();

if (pycode) {

PyObject* dict = nullptr;

PyObject* globals = nullptr;

if (PyModule_Check(object)) {

dict = PyModule_GetDict(object);

globals = dict;

} else if (PyDict_Check(object)) {

dict = object;

globals = dict;

} else {

dict = PyObject_GetAttrString(object, "__dict__");

globals = PyObject_GetAttrString(

PyImport_ImportModule(PyUnicode_AsUTF8(PyObject_GetAttrString(object, "__module__"))), "__dict__");

}

PyObject* r = nullptr;

if (dict) {

r = PyEval_EvalCode(pycode, globals, dict);

}

if (r) {

result = PythonQtConv::PyObjToQVariant(r);

Py_DECREF(r);

} else {

handleError();

}

} else {

handleError();

}

return result;

{

QVariant result;

PythonQtObjectPtr p;

PyObject* dict = nullptr;

clearError();

if (PyModule_Check(object)) {

dict = PyModule_GetDict(object);

} else if (PyDict_Check(object)) {

dict = object;

}

if (dict) {