Pickle un QPolygon en python 3.6+ et PyQt5

Vous pouvez utiliser QDataStream pour sérialiser / désérialiser les objets Qt:

from PyQt5 import QtCore
from PyQt5.QtGui import QPolygon
from PyQt5.QtCore import QPoint, QFile, QIODevice, QDataStream, QVariant

file_name = "test.dat"

output_file = QFile(file_name)
output_file.open(QIODevice.WriteOnly)
stream_out = QDataStream(output_file)
output_poly = QPolygon((QPoint(1, 6), QPoint(2, 6)))
output_str = QVariant('foo')  # Use QVariant for QString
stream_out << output_poly << output_str
output_file.close()

input_file = QFile(file_name)
input_file.open(QIODevice.ReadOnly)
stream_in = QDataStream(input_file)
input_poly = QPolygon()
input_str = QVariant()
stream_in >> input_poly >> input_str
input_file.close()

print(str(output_str.value()))
print(str(input_str.value()))

Un peu de recherche dans la documentation vous indique comment implémenter le décapage personnalisé pour les classes personnalisées via __reduce__ méthode . Fondamentalement, vous retournez un tuple comprenant le constructeur du nouvel objet à créer lors du décapage ainsi qu'un tuple d'arguments qui sera passé au constructeur. Si vous le souhaitez, vous pouvez ensuite passer un objet state (voir __getstate__ et __setstate__ ) et certains itérateurs pour ajouter des données de position et des données de valeur-clé. en sous-classant QPolygon , nous pouvons ajouter la capacité de décapage en tant que telle: (cela pourrait probablement être nettoyé / restructuré, mais c'est la première implémentation à laquelle j'ai travaillé)

from PyQt5.QtGui import QPolygon
from PyQt5.QtCore import QPoint
import pickle

class Picklable_QPolygon(QPolygon):

    def __reduce__(self):
        # constructor, (initargs), state object passed to __setstate__
        return type(self), (), self.__getstate__()

    #I'm not sure where this gets called other than manually in __reduce__
    #  but it seemed like the semantically correct way to do it...
    def __getstate__(self):
        state = [0]
        for point in self:
            state.append(point.x())
            state.append(point.y())
        return state

    #putPoints seems to omit the `nPoints` arg compared to c++ version.
    #  this may be a version dependent thing for PyQt. Definitely test that
    #  what you're getting out is the same as what you put in..
    def __setstate__(self, state):
        self.putPoints(*state)

poly = Picklable_QPolygon((QPoint(1, 1), QPoint(2, 2)))
s = pickle.dumps(poly)

elem = pickle.loads(s)

Inspiré par les réponses précédentes, j'ai créé une fonction qui prend une sorte de Qt qui prend en charge QDataSteam et retourne une classe qui hérite de cette classe et est picklable, dans l'exemple suivant, je montre avec QPoygon et QPainterPath:

if __name__ == '__main__':
    Picklable_QPolygon = create_qt_picklable(QtGui.QPolygon)

    file_name = "test_pickle.chip"
    poly = Picklable_QPolygon((QtCore.QPoint(1, 1), QtCore.QPoint(2, 2))) 
    with open(file_name, 'wb') as f:
        pickle.dump(poly, f, protocol=2)  # , fix_imports=True)

    elem = None
    with open(file_name, 'rb') as f:
        elem = pickle.load(f, encoding='bytes')  # , fix_imports=True)

    assert(poly == elem)

Cela doit être un bogue dans pyqt5, car la documentation indique que le pickling QPolygon est pris en charge. Veuillez donc publier un rapport de bogue sur la liste de diffusion pyqt en utilisant votre exemple.

Dans en attendant, l'alternative de loin la plus simple est d'utiliser QSettings : p >

<PyQt5.QtGui.QPolygon object at 0x7f871f1f8828>
PyQt5.QtCore.QPoint(1, 1) PyQt5.QtCore.QPoint(2, 2)

Résultat:

from PyQt5.QtGui import QPolygon
from PyQt5.QtCore import QSettings, QPoint

file_name = "test_pickle.chip"

poly = QPolygon((QPoint(1, 1), QPoint(2, 2)))

# write object
s = QSettings(file_name, QSettings.IniFormat)
s.setValue('poly', poly)

del s, poly

# read object
s = QSettings(file_name, QSettings.IniFormat)
poly = s.value('poly')

print(poly)
print(poly.point(0), poly.point(1))

Ceci peut être utilisé avec tout type de support PyQt pour le pickling, plus tout ce que PyQt peut convertir vers / depuis un QVariant . PyQt prend également en charge un argument type pour QSettings.value () qui peut être utilisé pour indiquer explicitement le type requis. Et comme QSettings est conçu pour stocker les données de configuration d'application, n'importe quel nombre d'objets peut être stocké dans le même fichier (un peu comme celui de python module shelve ).