QStandardItem.setText(QString) has unexpected type 'QVariant'?

Question

I have learn an example at here(written by neuronet).I try to use this method in QTableView ,but when I change the text ,it would incur such an error

TypeError: QStandardItem.setText(QString): argument 1 has unexpected type 'QVariant'.

Once I push the 'undo' button ,the error would be

TypeError: 'instancemethod' object is not connected

Here is my code,thanks for help.

# coding:utf-8
# coding:utf-8
from PyQt4 import QtGui, QtCore
import sys
class CommandTextEdit(QtGui.QUndoCommand):
    def __init__(self, table, item, oldText, newText, description):
        QtGui.QUndoCommand.__init__(self, description)
        self.item = item
        self.table = table
        self.oldText = oldText
        self.newText = newText

    def redo(self):
        self.item.model().itemDataChanged.disconnect(self.table.itemDataChangedSlot)
        self.item.setText(self.newText)
        self.item.model().itemDataChanged.connect(self.table.itemDataChangedSlot)

    def undo(self):
        self.item.model().itemDataChanged.disconnect(self.table.itemDataChangedSlot)
        self.item.setText(self.oldText)
        self.item.model().itemDataChanged.connect(self.table.itemDataChangedSlot)

class StandardItemModel(QtGui.QStandardItemModel):
    itemDataChanged = QtCore.pyqtSignal(object, object, object, object)

class StandardItem(QtGui.QStandardItem):
    def setData(self, newValue, role=QtCore.Qt.UserRole + 1):
        if role == QtCore.Qt.EditRole:
            oldValue = self.data(role)
            QtGui.QStandardItem.setData(self, newValue, role)
            model = self.model()
            #only emit signal if newvalue is different from old
            if model is not None and oldValue != newValue:
                model.itemDataChanged.emit(self, oldValue, newValue, role)
            return True
        QtGui.QStandardItem.setData(self, newValue, role)
class undoTable(QtGui.QWidget):
    def __init__(self, parent = None):
        QtGui.QWidget.__init__(self, parent = None)
        self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
        self.view = QtGui.QTableView()
        self.model = self.createModel()
        self.view.setModel(self.model)
        self.undoStack = QtGui.QUndoStack(self)
        undoView = QtGui.QUndoView(self.undoStack)
        buttonLayout = self.buttonSetup()
        mainLayout = QtGui.QHBoxLayout(self)
        mainLayout.addWidget(undoView)
        mainLayout.addWidget(self.view)
        mainLayout.addLayout(buttonLayout)
        self.setLayout(mainLayout)
        self.makeConnections()
    def createModel(self):
        model = StandardItemModel(4,4)
        for row in range(4):
            for column in range(4):
                item=StandardItem("(%s,%s)" % (row,column))
                model.setItem(row,column,item)
        return model

    def buttonSetup(self):
        self.undoButton = QtGui.QPushButton("Undo")
        self.redoButton = QtGui.QPushButton("Redo")
        self.quitButton = QtGui.QPushButton("Quit")
        buttonLayout = QtGui.QVBoxLayout()
        buttonLayout.addStretch()
        buttonLayout.addWidget(self.undoButton)
        buttonLayout.addWidget(self.redoButton)
        buttonLayout.addStretch()
        buttonLayout.addWidget(self.quitButton)
        return buttonLayout
    def itemDataChangedSlot(self, item, oldValue, newValue, role):
        if role == QtCore.Qt.EditRole:
            command = CommandTextEdit(self, item, oldValue, newValue,
                "Text changed from '{0}' to '{1}'".format(oldValue, newValue))
            self.undoStack.push(command)
            return True
    def makeConnections(self):
        self.model.itemDataChanged.connect(self.itemDataChangedSlot)
        self.quitButton.clicked.connect(self.close)
        self.undoButton.clicked.connect(self.undoStack.undo)
        self.redoButton.clicked.connect(self.undoStack.redo)

def main():
    app = QtGui.QApplication(sys.argv)
    newtable = undoTable()
    newtable.show()
    sys.exit(app.exec_())

if __name__ == "__main__":
    main()

Answer 1

From the PyQt documentation:

Qt uses the QVariant class as a wrapper for any C++ data type. PyQt4 allows any Python object to be wrapped as a QVariant and passed around Qt’s meta-object system like any other type.

PyQt4 will try to convert the Python object to a C++ equivalent if it can so that the QVariant can be passed to other C++ code that doesn’t know what a Python object is.

Version 2 of PyQt4’s QVariant API will automatically convert a QVariant back to a Python object of the correct type.

Version 1 of the QVariant API provides the QVariant.toPyObject() method to convert the QVariant back to a Python object of the correct type.

Both versions will raise a Python exception if the conversion cannot be done.

I'm guessing you're on Python 2.x, and that PyQt uses by default the version 1 of the QVariant API. It means QVariant is not automatically convert to another type (here a QString), so you get a TypeError.

So, three solutions:

• Use Python 3.x, by default you will have the version 2 of QVariant

• Change the version of QVariant with sip before importing PyQt

  import sip
  sip.setapi('QVariant',2)
  from PyQt4 import QtGui, QtCore
  

• Use the QVariant.toPyObject() to convert to the right type

  self.item.setText(self.newText.toString())
  

---

Once it was corrected, I found another error in your code:

TypeError: invalid result type from StandardItem.setData()

It's because you do return True in setData(), which is supposed to return void (so in Python, supposed to return nothing)