#include <pyside.h>
// Uses the stream version for security reasons
// see gcc man page at -Wformat-security
%FUNCTION_NAME() << %1;
// qFatal doesn't have a stream version, so we do a
// qWarning call followed by a qFatal() call using a
// literal.
qWarning() << %1;
qFatal("[A qFatal() call was made from Python code]");
return PyBool_FromLong((bool)%in);
%out = %OUTTYPE(%in == Py_True);
return PyLong_FromLong(%in);
%out = %OUTTYPE(PyLong_AsLong(%in));
return PyLong_FromUnsignedLong(%in);
%out = %OUTTYPE(PyLong_AsUnsignedLong(%in));
return PyLong_FromLong(%in);
%out = %OUTTYPE(PyLong_AsLong(%in));
bool py2kStrCheck(PyObject *obj)
{
#ifdef IS_PY3K
return false;
#else
return PyString_Check(obj);
#endif
}
QByteArray ba = %in.toUtf8();
PyObject *%out = PyUnicode_FromStringAndSize(ba.constData(), ba.size());
return %out;
#ifndef Py_LIMITED_API
Py_UNICODE* unicode = PyUnicode_AS_UNICODE(%in);
# if defined(Py_UNICODE_WIDE)
// cast as Py_UNICODE can be a different type
%out = QString::fromUcs4((const uint*)unicode);
# else
%out = QString::fromUtf16((const ushort*)unicode, PyUnicode_GET_SIZE(%in));
# endif
#else
wchar_t *temp = PyUnicode_AsWideCharString(%in, NULL);
%out = QString::fromWCharArray(temp);
PyMem_Free(temp);
#endif
#ifndef IS_PY3K
const char* str = %CONVERTTOCPP[const char*](%in);
%out = %OUTTYPE(str);
#endif
%out = %OUTTYPE();
const int N = %in.toString().length();
wchar_t *str = new wchar_t[N];
%in.toString().toWCharArray(str);
PyObject *%out = PyUnicode_FromWideChar(str, N);
delete[] str;
return %out;
wchar_t c = (wchar_t)%in.unicode();
return PyUnicode_FromWideChar(&c, 1);
char c = %CONVERTTOCPP[char](%in);
%out = %OUTTYPE(c);
int i = %CONVERTTOCPP[int](%in);
%out = %OUTTYPE(i);
%out = %OUTTYPE();
if (!%in.isValid())
Py_RETURN_NONE;
if (qstrcmp(%in.typeName(), "QVariantList") == 0) {
QList<QVariant> var = %in.value<QVariantList>();
return %CONVERTTOPYTHON[QList<QVariant>](var);
}
if (qstrcmp(%in.typeName(), "QStringList") == 0) {
QStringList var = %in.value<QStringList>();
return %CONVERTTOPYTHON[QList<QString>](var);
}
if (qstrcmp(%in.typeName(), "QVariantMap") == 0) {
QMap<QString, QVariant> var = %in.value<QVariantMap>();
return %CONVERTTOPYTHON[QMap<QString, QVariant>](var);
}
Shiboken::Conversions::SpecificConverter converter(cppInRef.typeName());
if (converter) {
void *ptr = cppInRef.data();
return converter.toPython(ptr);
}
PyErr_Format(PyExc_RuntimeError, "Can't find converter for '%s'.", %in.typeName());
return 0;
%out = %OUTTYPE(%in == Py_True);
%out = %OUTTYPE();
QString in = %CONVERTTOCPP[QString](%in);
%out = %OUTTYPE(in);
QByteArray in = %CONVERTTOCPP[QByteArray](%in);
%out = %OUTTYPE(in);
double in = %CONVERTTOCPP[double](%in);
%out = %OUTTYPE(in);
qlonglong in = %CONVERTTOCPP[qlonglong](%in);
%out = %OUTTYPE(in);
qlonglong in = %CONVERTTOCPP[qlonglong](%in);
%out = %OUTTYPE(in);
int in = %CONVERTTOCPP[int](%in);
%out = %OUTTYPE(in);
// a class supported by QVariant?
int typeCode;
const char *typeName = QVariant_resolveMetaType(Py_TYPE(%in), &typeCode);
if (!typeCode || !typeName)
return;
QVariant var(typeCode, (void*)0);
Shiboken::Conversions::SpecificConverter converter(typeName);
converter.toCpp(pyIn, var.data());
%out = var;
QVariant ret = QVariant_convertToVariantMap(%in);
%out = ret.isValid() ? ret : QVariant::fromValue<PySide::PyObjectWrapper>(%in);
QVariant ret = QVariant_convertToVariantList(%in);
%out = ret.isValid() ? ret : QVariant::fromValue<PySide::PyObjectWrapper>(%in);
// Is a shiboken type not known by Qt
%out = QVariant::fromValue<PySide::PyObjectWrapper>(%in);
static const char *QVariant_resolveMetaType(PyTypeObject *type, int *typeId)
{
if (PyObject_TypeCheck(type, SbkObjectType_TypeF())) {
SbkObjectType* sbkType = (SbkObjectType*)type;
const char* typeName = Shiboken::ObjectType::getOriginalName(sbkType);
if (!typeName)
return 0;
bool valueType = '*' != typeName[qstrlen(typeName) - 1];
// Do not convert user type of value
if (valueType && Shiboken::ObjectType::isUserType(type))
return 0;
int obTypeId = QMetaType::type(typeName);
if (obTypeId) {
*typeId = obTypeId;
return typeName;
}
// Do not resolve types to value type
if (valueType)
return 0;
// Find in base types. First check tp_bases, and only after check tp_base, because
// tp_base does not always point to the first base class, but rather to the first
// 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 (PepType(type)->tp_bases) {
for (int i = 0; i < PyTuple_GET_SIZE(PepType(type)->tp_bases); ++i) {
const char *derivedName = QVariant_resolveMetaType((PyTypeObject*)PyTuple_GET_ITEM(
PepType(type)->tp_bases, i), typeId);
if (derivedName)
return derivedName;
}
}
else if (PepType(type)->tp_base) {
return QVariant_resolveMetaType(PepType(type)->tp_base, typeId);
}
}
*typeId = 0;
return 0;
}
static QVariant QVariant_convertToValueList(PyObject *list)
{
if (PySequence_Size(list) < 0) {
// clear the error if < 0 which means no length at all
PyErr_Clear();
return QVariant();
}
Shiboken::AutoDecRef element(PySequence_GetItem(list, 0));
int typeId;
const char *typeName = QVariant_resolveMetaType(element.cast<PyTypeObject*>(), &typeId);
if (typeName) {
QByteArray listTypeName("QList<");
listTypeName += typeName;
listTypeName += '>';
typeId = QMetaType::type(listTypeName);
if (typeId > 0) {
Shiboken::Conversions::SpecificConverter converter(listTypeName);
if (converter) {
QVariant var(typeId, (void*)0);
converter.toCpp(list, &var);
return var;
}
qWarning() << "Type converter for :" << listTypeName << "not registered.";
}
}
return QVariant();
}
static bool QVariant_isStringList(PyObject *list)
{
bool allString = true;
if (PySequence_Check(list)) {
if (PySequence_Size(list) < 0) {
// clear the error if < 0 which means no length at all
PyErr_Clear();
return false;
}
Shiboken::AutoDecRef fast(PySequence_Fast(list, "Failed to convert QVariantList"));
Py_ssize_t size = PySequence_Fast_GET_SIZE(fast.object());
for (int i = 0; i < size; ++i) {
PyObject *item = PySequence_Fast_GET_ITEM(fast.object(), i);
if (!%CHECKTYPE[QString](item)) {
allString = false;
break;
}
}
} else {
// If it is not a list or a derived list class
// we assume that will not be a String list neither.
allString = false;
}
return allString;
}
static QVariant QVariant_convertToVariantMap(PyObject *map)
{
Py_ssize_t pos = 0;
Shiboken::AutoDecRef keys(PyDict_Keys(map));
if (!QVariant_isStringList(keys))
return QVariant();
PyObject *key;
PyObject *value;
QMap<QString,QVariant> ret;
while (PyDict_Next(map, &pos, &key, &value)) {
QString cppKey = %CONVERTTOCPP[QString](key);
QVariant cppValue = %CONVERTTOCPP[QVariant](value);
ret.insert(cppKey, cppValue);
}
return QVariant(ret);
}
static QVariant QVariant_convertToVariantList(PyObject *list)
{
if (QVariant_isStringList(list)) {
QList<QString > lst = %CONVERTTOCPP[QList<QString>](list);
return QVariant(QStringList(lst));
}
QVariant valueList = QVariant_convertToValueList(list);
if (valueList.isValid())
return valueList;
if (PySequence_Size(list) < 0) {
// clear the error if < 0 which means no length at all
PyErr_Clear();
return QVariant();
}
QList<QVariant> lst;
Shiboken::AutoDecRef fast(PySequence_Fast(list, "Failed to convert QVariantList"));
Py_ssize_t size = PySequence_Fast_GET_SIZE(fast.object());
for (int i = 0; i < size; ++i) {
PyObject *pyItem = PySequence_Fast_GET_ITEM(fast.object(), i);
QVariant item = %CONVERTTOCPP[QVariant](pyItem);
lst.append(item);
}
return QVariant(lst);
}
const char *typeName = QVariant::typeToName(%in);
PyObject *%out;
PyTypeObject *pyType = nullptr;
if (typeName)
pyType = Shiboken::Conversions::getPythonTypeObject(typeName);
%out = pyType ? (reinterpret_cast<PyObject*>(pyType)) : Py_None;
Py_INCREF(%out);
return %out;
%out = QVariant::Invalid;
const char *typeName;
if (Shiboken::String::checkType(reinterpret_cast<PyTypeObject*>(%in)))
typeName = "QString";
else if (%in == reinterpret_cast<PyObject*>(&PyFloat_Type))
typeName = "double"; // float is a UserType in QVariant.
else if (%in == reinterpret_cast<PyObject*>(&PyLong_Type))
typeName = "int"; // long is a UserType in QVariant.
else if (Py_TYPE(%in) == SbkObjectType_TypeF())
typeName = Shiboken::ObjectType::getOriginalName((SbkObjectType*)%in);
else
typeName = PepType((reinterpret_cast<PyTypeObject*>(%in)))->tp_name;
%out = QVariant::nameToType(typeName);
%out = QVariant::nameToType(Shiboken::String::toCString(%in));
%out = QVariant::nameToType("QVariantMap");
%out = QVariantType_isStringList(%in) ? QVariant::StringList : QVariant::List;
Shiboken::Conversions::registerConverterName(SbkPySide2_QtCoreTypeConverters[SBK_QTCORE_QMAP_QSTRING_QVARIANT_IDX], "QVariantMap");
static bool QVariantType_isStringList(PyObject *list)
{
bool allString = true;
Shiboken::AutoDecRef fast(PySequence_Fast(list, "Failed to convert QVariantList"));
Py_ssize_t size = PySequence_Fast_GET_SIZE(fast.object());
for (int i=0; i < size; i++) {
PyObject *item = PySequence_Fast_GET_ITEM(fast.object(), i);
if (!%CHECKTYPE[QString](item)) {
allString = false;
break;
}
}
return allString;
}
static bool QVariantType_checkAllStringKeys(PyObject *dict)
{
Shiboken::AutoDecRef keys(PyDict_Keys(dict));
return QVariantType_isStringList(keys);
}
// The QVariantMap returned by QJsonObject seems to cause a segfault, so
// using QJsonObject.toVariantMap() won't work.
// Wrapping it in a QJsonValue first allows it to work
QJsonValue val(%in);
QVariant ret = val.toVariant();
return %CONVERTTOPYTHON[QVariant](ret);
QVariant dict = QVariant_convertToVariantMap(%in);
QJsonValue val = QJsonValue::fromVariant(dict);
%out = val.toObject();
PyObject *%out = PyDict_New();
for (%INTYPE::const_iterator it = %in.begin(), end = %in.end(); it != end; ++it) {
%INTYPE_0 key = it.key();
%INTYPE_1 value = it.value();
PyObject *pyKey = %CONVERTTOPYTHON[%INTYPE_0](key);
PyObject *pyValue = %CONVERTTOPYTHON[%INTYPE_1](value);
PyDict_SetItem(%out, pyKey, pyValue);
Py_DECREF(pyKey);
Py_DECREF(pyValue);
}
return %out;
PyObject *key;
PyObject *value;
Py_ssize_t pos = 0;
while (PyDict_Next(%in, &pos, &key, &value)) {
%OUTTYPE_0 cppKey = %CONVERTTOCPP[%OUTTYPE_0](key);
%OUTTYPE_1 cppValue = %CONVERTTOCPP[%OUTTYPE_1](value);
%out.insert(cppKey, cppValue);
}
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));
return %out;
%out.first = %CONVERTTOCPP[%OUTTYPE_0](PySequence_Fast_GET_ITEM(%in, 0));
%out.second = %CONVERTTOCPP[%OUTTYPE_1](PySequence_Fast_GET_ITEM(%in, 1));
double _abs = qAbs(%1);
%PYARG_0 = %CONVERTTOPYTHON[double](_abs);
namespace PySide {
static QStack<PyObject*> globalPostRoutineFunctions;
void globalPostRoutineCallback()
{
Shiboken::GilState state;
foreach(PyObject *callback, globalPostRoutineFunctions) {
Shiboken::AutoDecRef result(PyObject_CallObject(callback, NULL));
Py_DECREF(callback);
}
globalPostRoutineFunctions.clear();
}
void addPostRoutine(PyObject *callback)
{
if (PyCallable_Check(callback)) {
globalPostRoutineFunctions << callback;
Py_INCREF(callback);
} else {
PyErr_SetString(PyExc_TypeError, "qAddPostRoutine: The argument must be a callable object.");
}
}
} // namespace
PySide::addPostRoutine(%1);
qAddPostRoutine(PySide::globalPostRoutineCallback);
QList<QByteArray> version = QByteArray(qVersion()).split('.');
PyObject *pyQtVersion = PyTuple_New(3);
for (int i = 0; i < 3; ++i)
PyTuple_SET_ITEM(pyQtVersion, i, PyInt_FromLong(version[i].toInt()));
PyModule_AddObject(module, "__version_info__", pyQtVersion);
PyModule_AddStringConstant(module, "__version__", qVersion());
{ // Avoid name clash
Shiboken::AutoDecRef regFunc((PyObject*)NULL);
Shiboken::AutoDecRef atexit(Shiboken::Module::import("atexit"));
if (atexit.isNull()) {
qWarning() << "Module atexit not found for registering __moduleShutdown";
PyErr_Clear();
}else{
regFunc = PyObject_GetAttrString(atexit, "register");
if (regFunc.isNull()) {
qWarning() << "Function atexit.register not found for registering __moduleShutdown";
PyErr_Clear();
}
}
if (!atexit.isNull() && !regFunc.isNull()){
PyObject *shutDownFunc = PyObject_GetAttrString(module, "__moduleShutdown");
Shiboken::AutoDecRef args(PyTuple_New(1));
PyTuple_SET_ITEM(args, 0, shutDownFunc);
Shiboken::AutoDecRef retval(PyObject_Call(regFunc, args, 0));
Q_ASSERT(!retval.isNull());
}
}
PySide::runCleanupFunctions();
Shiboken::Conversions::registerConverterName(SbkPySide2_QtCoreTypeConverters[SBK_QSTRING_IDX], "unicode");
Shiboken::Conversions::registerConverterName(SbkPySide2_QtCoreTypeConverters[SBK_QSTRING_IDX], "str");
Shiboken::Conversions::registerConverterName(SbkPySide2_QtCoreTypeConverters[SBK_QTCORE_QLIST_QVARIANT_IDX], "QVariantList");
PySide::registerInternalQtConf();
PySide::init(module);
Py_AtExit(QtCoreModuleExit);
// Define a global variable to handle qInstallMessageHandler callback
static PyObject *qtmsghandler = nullptr;
static void msgHandlerCallback(QtMsgType type, const QMessageLogContext &ctx, const QString &msg)
{
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));
QByteArray array = msg.toLatin1().data();
char *data = array.data();
PyTuple_SET_ITEM(arglist, 2, %CONVERTTOPYTHON[char *](data));
Shiboken::AutoDecRef ret(PyObject_CallObject(qtmsghandler, arglist));
}
static void QtCoreModuleExit()
{
PySide::SignalManager::instance().clear();
}
if (%PYARG_1 == Py_None) {
qInstallMessageHandler(0);
%PYARG_0 = qtmsghandler ? qtmsghandler : Py_None;
qtmsghandler = 0;
} else if (!PyCallable_Check(%PYARG_1)) {
PyErr_SetString(PyExc_TypeError, "parameter must be callable");
} else {
%PYARG_0 = qtmsghandler ? qtmsghandler : Py_None;
Py_INCREF(%PYARG_1);
qtmsghandler = %PYARG_1;
qInstallMessageHandler(msgHandlerCallback);
}
if (%PYARG_0 == Py_None)
Py_INCREF(%PYARG_0);
namespace PySide {
template<> inline uint hash(const QLine &v) {
return qHash(qMakePair(qMakePair(v.x1(), v.y1()), qMakePair(v.x2(), v.y2())));
}
};
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));
Returns a read only buffer object pointing to the segment of data that this resource represents. If the resource is compressed the data returns is compressed and qUncompress() must be used to access the data. If the resource is a directory None is returned.
const void *d = %CPPSELF.%FUNCTION_NAME();
if (d) {
%PYARG_0 = Shiboken::Buffer::newObject(d, %CPPSELF.size());
} else {
Py_INCREF(Py_None);
%PYARG_0 = Py_None;
}
uchar *ptr = reinterpret_cast<uchar*>(Shiboken::Buffer::getPointer(%PYARG_1));
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(const_cast<const uchar*>(ptr), %2);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
#ifdef IS_PY3K
#define PySideDateTime_IMPORT PyDateTime_IMPORT
#else
#define PySideDateTime_IMPORT \
(PyDateTimeAPI = (PyDateTime_CAPI*) PyCObject_Import((char*)"datetime", \
(char*)"datetime_CAPI"))
#endif
static bool PyDateTime_ImportAndCheck(PyObject *pyIn) {
if (!PyDateTimeAPI) PySideDateTime_IMPORT;
return $DATETIMETYPE_Check(pyIn);
}
%out = %OUTTYPE();
int day = PyDateTime_GET_DAY(%in);
int month = PyDateTime_GET_MONTH(%in);
int year = PyDateTime_GET_YEAR(%in);
%out = %OUTTYPE(year, month, day);
if (!PyDateTimeAPI)
PySideDateTime_IMPORT;
%PYARG_0 = PyDate_FromDate(%CPPSELF.year(), %CPPSELF.month(), %CPPSELF.day());
int year, month, day;
%BEGIN_ALLOW_THREADS
%CPPSELF.%FUNCTION_NAME(&year, &month, &day);
%END_ALLOW_THREADS
%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));
int yearNumber;
%BEGIN_ALLOW_THREADS
int week = %CPPSELF.%FUNCTION_NAME(&yearNumber);
%END_ALLOW_THREADS
%PYARG_0 = PyTuple_New(2);
PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[int](week));
PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[int](yearNumber));
%out = %OUTTYPE();
int day = PyDateTime_GET_DAY(%in);
int month = PyDateTime_GET_MONTH(%in);
int year = PyDateTime_GET_YEAR(%in);
int hour = PyDateTime_DATE_GET_HOUR(%in);
int min = PyDateTime_DATE_GET_MINUTE(%in);
int sec = PyDateTime_DATE_GET_SECOND(%in);
int usec = PyDateTime_DATE_GET_MICROSECOND(%in);
%out = %OUTTYPE(QDate(year, month, day), QTime(hour, min, sec, usec/1000));
QDate date(%1, %2, %3);
QTime time(%4, %5, %6, %7);
%0 = new %TYPE(date, time, Qt::TimeSpec(%8));
QDate date(%1, %2, %3);
QTime time(%4, %5, %6);
%0 = new %TYPE(date, time);
QDate date = %CPPSELF.date();
QTime time = %CPPSELF.time();
if (!PyDateTimeAPI) PySideDateTime_IMPORT;
%PYARG_0 = PyDateTime_FromDateAndTime(date.year(), date.month(), date.day(), time.hour(), time.minute(), time.second(), time.msec()*1000);
namespace PySide {
template<> inline uint hash(const QPoint &v) {
return qHash(qMakePair(v.x(), v.y()));
}
};
namespace PySide {
template<> inline uint hash(const QRect &v) {
return qHash(qMakePair(qMakePair(v.x(), v.y()), qMakePair(v.width(), v.height())));
}
};
namespace PySide {
template<> inline uint hash(const QSize &v) {
return qHash(qMakePair(v.width(), v.height()));
}
};
%out = %OUTTYPE();
int hour = PyDateTime_TIME_GET_HOUR(%in);
int min = PyDateTime_TIME_GET_MINUTE(%in);
int sec = PyDateTime_TIME_GET_SECOND(%in);
int usec = PyDateTime_TIME_GET_MICROSECOND(%in);
%out = %OUTTYPE(hour, min, sec, usec/1000);
if (!PyDateTimeAPI)
PySideDateTime_IMPORT;
%PYARG_0 = PyTime_FromTime(%CPPSELF.hour(), %CPPSELF.minute(), %CPPSELF.second(), %CPPSELF.msec()*1000);
return %CPPSELF.size();
if (_i < 0 || _i >= %CPPSELF.size()) {
PyErr_SetString(PyExc_IndexError, "index out of bounds");
return 0;
}
bool ret = %CPPSELF.at(_i);
return %CONVERTTOPYTHON[bool](ret);
PyObject *args = Py_BuildValue("(iiO)", _i, 1, _value);
PyObject *result = Sbk_QBitArrayFunc_setBit(self, args);
Py_DECREF(args);
Py_XDECREF(result);
return !result ? -1 : 0;
%CPPSELF.unlock();
%CPPSELF.unlock();
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1, %2, %PYARG_3);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
Creates a model index for the given row and column with the internal pointer ptr.
When using a QSortFilterProxyModel, its indexes have their own internal pointer. It is not advisable to access this internal pointer outside of the model. Use the data() function instead.
This function provides a consistent interface that model subclasses must use to create model indexes.
.. warning:: Because of some Qt/Python itegration rules, the ptr argument do not get the reference incremented during the QModelIndex life time. So it is necessary to keep the object used on ptr argument alive during the whole process. Do not destroy the object if you are not sure about that.
qRegisterMetaType<QVector<int> >("QVector<int>");
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME();
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
// %FUNCTION_NAME() - disable generation of function call.
bool %0 = qobjectConnect(%1, %2, %CPPSELF, %3, %4);
%PYARG_0 = %CONVERTTOPYTHON[bool](%0);
// %FUNCTION_NAME() - disable generation of function call.
bool %0 = qobjectConnect(%1, %2, %3, %4, %5);
%PYARG_0 = %CONVERTTOPYTHON[bool](%0);
// %FUNCTION_NAME() - disable generation of function call.
bool %0 = qobjectConnect(%1, %2, %3, %4, %5);
%PYARG_0 = %CONVERTTOPYTHON[bool](%0);
// %FUNCTION_NAME() - disable generation of function call.
%RETURN_TYPE %0 = qobjectConnectCallback(%1, %2, %PYARG_3, %4);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
// %FUNCTION_NAME() - disable generation of function call.
%RETURN_TYPE %0 = qobjectConnectCallback(%CPPSELF, %1, %PYARG_2, %3);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
// %FUNCTION_NAME() - disable generation of function call.
%RETURN_TYPE %0 = qobjectConnect(%CPPSELF, %1, %2, %3, %4);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
%RETURN_TYPE %0 = PySide::SignalManager::instance().emitSignal(%CPPSELF, %1, %PYARG_2);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
// %FUNCTION_NAME() - disable generation of function call.
%RETURN_TYPE %0 = qobjectDisconnectCallback(%CPPSELF, %1, %2);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
// %FUNCTION_NAME() - disable generation of function call.
%RETURN_TYPE %0 = qobjectDisconnectCallback(%1, %2, %3);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
QObject *child = _findChildHelper(%CPPSELF, %2, (PyTypeObject*)%PYARG_1);
%PYARG_0 = %CONVERTTOPYTHON[QObject*](child);
%PYARG_0 = PyList_New(0);
_findChildrenHelper(%CPPSELF, %2, (PyTypeObject*)%PYARG_1, %PYARG_0);
%PYARG_0 = PyList_New(0);
_findChildrenHelper(%CPPSELF, %2, (PyTypeObject*)%PYARG_1, %PYARG_0);
QString result;
if (QCoreApplication::instance()) {
PyObject *klass = PyObject_GetAttrString(%PYSELF, "__class__");
PyObject *cname = PyObject_GetAttrString(klass, "__name__");
result = QString(QCoreApplication::instance()->translate(Shiboken::String::toCString(cname),
/* %1, %2, QCoreApplication::CodecForTr, %3)); */
%1, %2, %3));
Py_DECREF(klass);
Py_DECREF(cname);
} else {
result = QString(QString::fromLatin1(%1));
}
%PYARG_0 = %CONVERTTOPYTHON[QString](result);
// Avoid return +1 because SignalManager connect to "destroyed()" signal to control object timelife
int ret = %CPPSELF.%FUNCTION_NAME(%1);
if (ret > 0 && ((strcmp(%1, SIGNAL(destroyed())) == 0) || (strcmp(%1, SIGNAL(destroyed(QObject*))) == 0)))
ret -= PySide::SignalManager::instance().countConnectionsWith(%CPPSELF);
%PYARG_0 = %CONVERTTOPYTHON[int](ret);
Replaces every occurrence of the regular expression in *sourceString* with *after*.
Returns a new Python string with the modified contents. For example:
::
s = "Banana"
re = QRegExp("a[mn]")
s = re.replace(s, "ox")
# s == "Boxoxa"
For regular expressions containing capturing parentheses, occurrences of \1, \2, ..., in *after*
are replaced with rx.cap(1), cap(2), ...
::
t = "A <i>bon mot</i>."
re = QRegExp("<i>([^<]*)</i>")
t = re.replace(t, "\\emph{\\1}")
# t == "A \\emph{bon mot}."
%1.replace(*%CPPSELF, %2);
%PYARG_0 = %CONVERTTOPYTHON[QString](%1);
%out = %OUTTYPE();
#ifdef IS_PY3K
%out = %OUTTYPE(PyBytes_AS_STRING(%in), PyBytes_GET_SIZE(%in));
#else
%out = %OUTTYPE(Shiboken::String::toCString(%in), Shiboken::String::len(%in));
#endif
%out = %OUTTYPE(PyByteArray_AsString(%in), PyByteArray_Size(%in));
%out = %OUTTYPE(Shiboken::String::toCString(%in), Shiboken::String::len(%in));
QByteArray ba = QByteArray(PyBytes_AS_STRING(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1)) + *%CPPSELF;
%PYARG_0 = %CONVERTTOPYTHON[QByteArray](ba);
QByteArray ba = QByteArray(PyByteArray_AsString(%PYARG_1), PyByteArray_Size(%PYARG_1)) + *%CPPSELF;
%PYARG_0 = %CONVERTTOPYTHON[QByteArray](ba);
QByteArray ba = *%CPPSELF + QByteArray(PyByteArray_AsString(%PYARG_1), PyByteArray_Size(%PYARG_1));
%PYARG_0 = %CONVERTTOPYTHON[QByteArray](ba);
*%CPPSELF += QByteArray(PyByteArray_AsString(%PYARG_1), PyByteArray_Size(%PYARG_1));
if (PyUnicode_CheckExact(%PYARG_1)) {
Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1));
QByteArray ba = QByteArray(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object()));
bool cppResult = %CPPSELF == ba;
%PYARG_0 = %CONVERTTOPYTHON[bool](cppResult);
}
if (PyUnicode_CheckExact(%PYARG_1)) {
Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1));
QByteArray ba = QByteArray(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object()));
bool cppResult = %CPPSELF != ba;
%PYARG_0 = %CONVERTTOPYTHON[bool](cppResult);
}
if (PyUnicode_CheckExact(%PYARG_1)) {
Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1));
QByteArray ba = QByteArray(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object()));
bool cppResult = %CPPSELF > ba;
%PYARG_0 = %CONVERTTOPYTHON[bool](cppResult);
}
if (PyUnicode_CheckExact(%PYARG_1)) {
Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1));
QByteArray ba = QByteArray(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object()));
bool cppResult = %CPPSELF >= ba;
%PYARG_0 = %CONVERTTOPYTHON[bool](cppResult);
}
if (PyUnicode_CheckExact(%PYARG_1)) {
Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1));
QByteArray ba = QByteArray(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object()));
bool cppResult = %CPPSELF < ba;
%PYARG_0 = %CONVERTTOPYTHON[bool](cppResult);
}
if (PyUnicode_CheckExact(%PYARG_1)) {
Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1));
QByteArray ba = QByteArray(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object()));
bool cppResult = %CPPSELF <= ba;
%PYARG_0 = %CONVERTTOPYTHON[bool](cppResult);
}
PyObject *aux = PyBytes_FromStringAndSize(%CPPSELF.constData(), %CPPSELF.size());
if (aux == NULL) {
return NULL;
}
QByteArray b(PepType(Py_TYPE(%PYSELF))->tp_name);
#ifdef IS_PY3K
%PYARG_0 = PyUnicode_FromFormat("%s(%R)", b.constData(), aux);
#else
aux = PyObject_Repr(aux);
b += "(";
b += QByteArray(PyBytes_AS_STRING(aux), PyBytes_GET_SIZE(aux));
b += ")";
%PYARG_0 = Shiboken::String::fromStringAndSize(b.constData(), b.size());
#endif
Py_DECREF(aux);
if (PyBytes_Check(%PYARG_1)) {
%0 = new QByteArray(PyBytes_AsString(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1));
} else if (Shiboken::String::check(%PYARG_1)) {
%0 = new QByteArray(Shiboken::String::toCString(%PYARG_1), Shiboken::String::len(%PYARG_1));
}
>
%0 = new QByteArray(PyByteArray_AsString(%PYARG_1), PyByteArray_Size(%PYARG_1));
%0 = new QByteArray(PyBytes_AS_STRING(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1));
#if PY_VERSION_HEX < 0x03000000
Shiboken::SbkType<QByteArray>()->tp_as_buffer = &SbkQByteArrayBufferProc;
Shiboken::SbkType<QByteArray>()->tp_flags |= Py_TPFLAGS_HAVE_GETCHARBUFFER;
#endif
%PYARG_0 = PyBytes_FromStringAndSize(%CPPSELF.%FUNCTION_NAME(), %CPPSELF.size());
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(PyBytes_AsString(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1));
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
PyObject *aux = PyBytes_FromStringAndSize(%CPPSELF.constData(), %CPPSELF.size());
if (aux == NULL) {
return NULL;
}
#ifdef IS_PY3K
%PYARG_0 = PyObject_Repr(aux);
Py_DECREF(aux);
#else
%PYARG_0 = aux;
#endif
return %CPPSELF.count();
if (_i < 0 || _i >= %CPPSELF.size()) {
PyErr_SetString(PyExc_IndexError, "index out of bounds");
return 0;
} else {
char res[2];
res[0] = %CPPSELF.at(_i);
res[1] = 0;
return PyBytes_FromStringAndSize(res, 1);
}
%CPPSELF.remove(_i, 1);
PyObject *args = Py_BuildValue("(nO)", _i, _value);
PyObject *result = Sbk_QByteArrayFunc_insert(self, args);
Py_DECREF(args);
Py_XDECREF(result);
return !result ? -1 : 0;
uchar *ptr = reinterpret_cast<uchar*>(Shiboken::Buffer::getPointer(%PYARG_1));
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(ptr);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
%PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.%FUNCTION_NAME(%1, %2, %3), %2, Shiboken::Buffer::ReadWrite);
QByteArray ba;
ba.resize(%2);
%CPPSELF.%FUNCTION_NAME(ba.data(), ba.size());
%PYARG_0 = Shiboken::String::fromCString(ba.constData());
%RETURN_TYPE %out = 0;
if (PyBytes_Check(%PYARG_0)) {
%out = PyBytes_GET_SIZE((PyObject*)%PYARG_0);
memcpy(%1, PyBytes_AS_STRING((PyObject*)%PYARG_0), %out);
} else if (Shiboken::String::check(%PYARG_0)) {
%out = Shiboken::String::len((PyObject*)%PYARG_0);
memcpy(%1, Shiboken::String::toCString((PyObject*)%PYARG_0), %out);
}
QByteArray ba;
ba.resize(%2);
%CPPSELF.%FUNCTION_NAME(ba.data(), ba.size());
%PYARG_0 = Shiboken::String::fromCString(ba.constData());
%RETURN_TYPE %out = 0;
if (PyBytes_Check(%PYARG_0)) {
%out = PyBytes_GET_SIZE((PyObject*)%PYARG_0);
memcpy(%1, PyBytes_AS_STRING((PyObject*)%PYARG_0), %out);
} else if (Shiboken::String::check(%PYARG_0)) {
%out = Shiboken::String::len((PyObject*)%PYARG_0);
memcpy(%1, Shiboken::String::toCString((PyObject*)%PYARG_0), %out);
}
%CPPSELF.%FUNCTION_NAME(Shiboken::String::toCString(%PYARG_1), Shiboken::String::len(%PYARG_1));
%CPPSELF.unlock();
Shiboken::AutoDecRef socket(%PYARG_1);
if (!socket.isNull()) {
// We use qintptr as PyLong, but we check for int
// since it is currently an alias to be Python2 compatible.
// Internally, ints are qlonglongs.
if (%CHECKTYPE[int](socket)) {
int cppSocket = %CONVERTTOCPP[int](socket);
qintptr socket = (qintptr)cppSocket;
%0 = new %TYPE(socket, %2, %3);
} else {
PyErr_SetString(PyExc_TypeError,
"QSocketNotifier: first argument (socket) must be an int.");
}
}
Py_ssize_t size;
uchar *ptr = reinterpret_cast<uchar*>(Shiboken::Buffer::getPointer(%PYARG_1, &size));
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(const_cast<const uchar*>(ptr), size);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
// %FUNCTION_NAME() - disable generation of c++ function call
(void) %2; // remove warning about unused variable
Shiboken::AutoDecRef emptyTuple(PyTuple_New(0));
PyObject *pyTimer = PepType(Shiboken::SbkType<QTimer>())->tp_new(Shiboken::SbkType<QTimer>(), emptyTuple, 0);
PepType(Shiboken::SbkType<QTimer>())->tp_init(pyTimer, emptyTuple, 0);
QTimer* timer = %CONVERTTOCPP[QTimer*](pyTimer);
Shiboken::AutoDecRef result(
PyObject_CallMethod(pyTimer,
const_cast<char*>("connect"),
const_cast<char*>("OsOs"),
pyTimer,
SIGNAL(timeout()),
%PYARG_2,
%3)
);
Shiboken::Object::releaseOwnership((SbkObject*)pyTimer);
Py_XDECREF(pyTimer);
timer->setSingleShot(true);
timer->connect(timer, SIGNAL(timeout()), timer, SLOT(deleteLater()));
timer->start(%1);
// %FUNCTION_NAME() - disable generation of c++ function call
Shiboken::AutoDecRef emptyTuple(PyTuple_New(0));
PyObject *pyTimer = PepType(Shiboken::SbkType<QTimer>())->tp_new(Shiboken::SbkType<QTimer>(), emptyTuple, 0);
PepType(Shiboken::SbkType<QTimer>())->tp_init(pyTimer, emptyTuple, 0);
QTimer* timer = %CONVERTTOCPP[QTimer*](pyTimer);
timer->setSingleShot(true);
if (PyObject_TypeCheck(%2, PySideSignalInstanceTypeF())) {
PySideSignalInstance *signalInstance = reinterpret_cast<PySideSignalInstance*>(%2);
Shiboken::AutoDecRef signalSignature(Shiboken::String::fromFormat("2%s", PySide::Signal::getSignature(signalInstance)));
Shiboken::AutoDecRef result(
PyObject_CallMethod(pyTimer,
const_cast<char*>("connect"),
const_cast<char*>("OsOO"),
pyTimer,
SIGNAL(timeout()),
PySide::Signal::getObject(signalInstance),
signalSignature.object())
);
} else {
Shiboken::AutoDecRef result(
PyObject_CallMethod(pyTimer,
const_cast<char*>("connect"),
const_cast<char*>("OsO"),
pyTimer,
SIGNAL(timeout()),
%PYARG_2)
);
}
timer->connect(timer, SIGNAL(timeout()), timer, SLOT(deleteLater()), Qt::DirectConnection);
Shiboken::Object::releaseOwnership((SbkObject*)pyTimer);
Py_XDECREF(pyTimer);
timer->start(%1);
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));
long result;
#ifdef WIN32
_PROCESS_INFORMATION *procInfo = %CPPSELF.%FUNCTION_NAME();
result = procInfo ? procInfo->dwProcessId : 0;
#else
result = %CPPSELF.%FUNCTION_NAME();
#endif
%PYARG_0 = %CONVERTTOPYTHON[long](result);
.. class:: QCoreApplication(args)
Constructs a Qt kernel application. Kernel applications are applications
without a graphical user interface. These type of applications are used
at the console or as server processes.
The *args* argument is processed by the application, and made available
in a more convenient form by the :meth:`~QCoreApplication.arguments()`
method.
QCoreApplicationConstructor(%PYSELF, args, &%0);
PyObject *empty = PyTuple_New(2);
if (!PyTuple_SetItem(empty, 0, PyList_New(0))) {
QCoreApplicationConstructor(%PYSELF, empty, &%0);
}
QCoreApplication *app = QCoreApplication::instance();
PyObject *pyApp = Py_None;
if (app) {
pyApp = reinterpret_cast<PyObject*>(
Shiboken::BindingManager::instance().retrieveWrapper(app));
if (!pyApp)
pyApp = %CONVERTTOPYTHON[QCoreApplication*](app);
// this will keep app live after python exit (extra ref)
}
// PYSIDE-571: make sure that we return the singleton "None"
if (pyApp == Py_None)
Py_DECREF(MakeSingletonQAppWrapper(0)); // here qApp and instance() diverge
%PYARG_0 = pyApp;
Py_XINCREF(%PYARG_0);
long *%out = new long;
%out = 0;
%RETURN_TYPE %out = false;
if (PySequence_Check(%PYARG_0) && (PySequence_Size(%PYARG_0) == 2)) {
Shiboken::AutoDecRef pyResult(PySequence_GetItem(%PYARG_0, 0));
%out = %CONVERTTOCPP[bool](pyResult);
}
%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));
delete result_out;
.. warning:: QSettings.value can return different types (QVariant types) depending on the platform it's running on, so the safest way to use it is always casting the result to the desired type, e.g.: int(settings.value("myKey"))
%RETURN_TYPE _cpp_result;
(*%CPPSELF) >> _cpp_result;
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](_cpp_result);
(*%CPPSELF) << %1;
QByteArray data;
data.resize(%2);
int result = %CPPSELF.%FUNCTION_NAME(data.data(), data.size());
if (result == -1) {
Py_INCREF(Py_None);
%PYARG_0 = Py_None;
} else {
%PYARG_0 = PyBytes_FromStringAndSize(data.data(), result);
}
int r = %CPPSELF.%FUNCTION_NAME(%1, Shiboken::String::len(%PYARG_1));
%PYARG_0 = %CONVERTTOPYTHON[int](r);
QString &res = *%0;
%PYARG_0 = %CONVERTTOPYTHON[QString](res);
Shiboken::Object::releaseOwnership(%PYARG_0);
for (int counter = 0; counter < %CPPSELF.animationCount(); ++counter ) {
QAbstractAnimation *animation = %CPPSELF.animationAt(counter);
PyObject *obj = %CONVERTTOPYTHON[QAbstractAnimation*](animation);
Shiboken::Object::setParent(NULL, obj);
Py_DECREF(obj);
}
%CPPSELF.clear();
PySideEasingCurveFunctor::init();
QEasingCurve::EasingFunction func = PySideEasingCurveFunctor::createCustomFuntion(%PYSELF, %PYARG_1);
if (func)
%CPPSELF.%FUNCTION_NAME(func);
//%FUNCTION_NAME()
%PYARG_0 = PySideEasingCurveFunctor::callable(%PYSELF);
<code>machine = QStateMachine()
s1 = QState()
s11 = QState(s1)
s12 = QState(s1)
s1h = QHistoryState(s1)
s1h.setDefaultState(s11)
machine.addState(s1)
s2 = QState()
machine.addState(s2)
button = QPushButton()
# Clicking the button will cause the state machine to enter the child state
# that s1 was in the last time s1 was exited, or the history state's default
# state if s1 has never been entered.
s1.addTransition(button.clicked, s1h)</code>
if (PyObject_TypeCheck(%1, PySideSignalInstanceTypeF())) {
PyObject *dataSource = PySide::Signal::getObject((PySideSignalInstance*)%PYARG_1);
Shiboken::AutoDecRef obType(PyObject_Type(dataSource));
QObject* sender = %CONVERTTOCPP[QObject*](dataSource);
if (sender) {
const char*dataSignature = PySide::Signal::getSignature((PySideSignalInstance*)%PYARG_1);
QByteArray signature(dataSignature); // Append SIGNAL flag (2)
%0 = new QSignalTransitionWrapper(sender,"2" + signature,%2);
}
}
QString signalName(%2);
if (PySide::SignalManager::registerMetaMethod(%1, signalName.mid(1).toLatin1().data(), QMetaMethod::Signal)) {
QSignalTransition *%0 = %CPPSELF->addTransition(%1, %2, %3);
%PYARG_0 = %CONVERTTOPYTHON[QSignalTransition*](%0);
} else {
Py_INCREF(Py_None);
%PYARG_0 = Py_None;
}
// Obviously the label used by the following goto is a very awkward solution,
// since it refers to a name very tied to the generator implementation.
// Check bug #362 for more information on this
// http://bugs.openbossa.org/show_bug.cgi?id=362
if (!PyObject_TypeCheck(%1, PySideSignalInstanceTypeF()))
goto Sbk_%TYPEFunc_%FUNCTION_NAME_TypeError;
PySideSignalInstance *signalInstance = reinterpret_cast<PySideSignalInstance*>(%1);
QObject* sender = %CONVERTTOCPP[QObject*](PySide::Signal::getObject(signalInstance));
QSignalTransition *%0 = %CPPSELF->%FUNCTION_NAME(sender, PySide::Signal::getSignature(signalInstance),%2);
%PYARG_0 = %CONVERTTOPYTHON[QSignalTransition*](%0);
%PYARG_0 = PySet_New(0);
foreach(QAbstractState *abs_state, %CPPSELF.configuration()) {
Shiboken::AutoDecRef obj(%CONVERTTOPYTHON[QAbstractState*](abs_state));
Shiboken::Object::setParent(self, obj);
PySet_Add(%PYARG_0, obj);
}
%PYARG_0 = PyList_New(0);
foreach(QAbstractAnimation *abs_anim, %CPPSELF.defaultAnimations()) {
Shiboken::AutoDecRef obj(%CONVERTTOPYTHON[QAbstractAnimation*](abs_anim));
Shiboken::Object::setParent(self, obj);
PyList_Append(%PYARG_0, obj);
}
%PYARG_0 = Shiboken::String::fromFormat("2%s",QMetaObject::normalizedSignature(%1).constData());
%PYARG_0 = Shiboken::String::fromFormat("1%s",QMetaObject::normalizedSignature(%1).constData());
extern bool
qRegisterResourceData(int,
const unsigned char *,
const unsigned char *,
const unsigned char *);
extern bool
qUnregisterResourceData(int,
const unsigned char *,
const unsigned char *,
const unsigned char *);
%RETURN_TYPE %0 = %FUNCTION_NAME(%1, reinterpret_cast<uchar*>(PyBytes_AS_STRING(%PYARG_2)),
reinterpret_cast<uchar*>(PyBytes_AS_STRING(%PYARG_3)),
reinterpret_cast<uchar*>(PyBytes_AS_STRING(%PYARG_4)));
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
%RETURN_TYPE %0 = %FUNCTION_NAME(%1, reinterpret_cast<uchar*>(PyBytes_AS_STRING(%PYARG_2)),
reinterpret_cast<uchar*>(PyBytes_AS_STRING(%PYARG_3)),
reinterpret_cast<uchar*>(PyBytes_AS_STRING(%PYARG_4)));
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);