Unpickling python-Objekte mit einem geänderten Modul-Pfad

Ich versuche zu integrieren, ein Projekt Project A gebaut, von einem Kollegen in ein anderes python-Projekt. Nun ist diese Kollegin nicht verwendet relative Importe in seinem code, sondern stattdessen getan

from packageA.moduleA import ClassA
from packageA.moduleA import ClassB

und folglich gebeizt die Klassen mit cPickle. Für die Sauberkeit möchte ich ausblenden, das Paket, dass seine (Project A) gebaut in meinem Projekt. Dies allerdings ändert sich der Pfad des definierten Klassen in packageA. Kein problem, ich werde einfach neu definieren Sie den import mit

from ..packageA.moduleA import ClassA
from ..packageA.moduleA import ClassB

aber jetzt die un einlegen der Klassen schlägt mit der folgenden Meldung

    with open(fname) as infile: self.clzA = cPickle.load(infile)
ImportError: No module named packageA.moduleA

Warum also nicht cPickle anscheinend sehen das Modul defs. Muss ich hinzufügen, um die Wurzel des packageA system Weg? Ist dies der korrekte Weg das problem zu lösen?

Den cPickled Datei sieht so etwas wie

ccopy_reg
_reconstructor
p1
(cpackageA.moduleA
ClassA
p2
c__builtin__
object
p3
NtRp4

Dem alten Projekt-Hierarchie ist von der Art,

packageA/
    __init__.py
    moduleA.py
    moduleB.py
packageB/
    __init__.py
    moduleC.py
    moduleD.py

Möchte ich alle, die in einem WrapperPackage

MyPackage/
.. __init__.py
.. myModuleX.py
.. myModuleY.py
WrapperPackage/
.. __init__.py
.. packageA/
   .. __init__.py
   .. moduleA.py
   .. moduleB.py
.. packageB/
   .. __init__.py
   .. moduleC.py
   .. moduleD.py

Ich stieß auf dieses problem schriftlich ein Plugin für KRunner. Der script-engine verwendet, die durch Plasma verwendet einen Pfad Haken zum erstellen einer fake-Paket, wo mein code war. Leider konnte ich keinen Weg, dies zu lösen. Das einzige, was ich tun konnte, war, manuell zu entfernen, Ihren Weg zu Haken, deaktivieren Sie das sys caches und importieren alles. Aber wenn Sie einige eingelegte Daten, dann müssen Sie unpickle es mit dem gleichen class Namen(das heißt, Sie müssen halten die from packageA.moduleA import ClassA). Beachten Sie, dass einmal unpickled Sie können re-Gurke Sie mit dem richtigen Namen.

InformationsquelleAutor Matti Lyra | 2012-11-15

20

Müssen Sie erstellen Sie einen alias für die pickle import arbeiten; die folgenden __init__.py - Datei des WrapperPackage Paket:
```
from .packageA import * # Ensures that all the modules have been loaded in their new locations *first*.
from . import packageA  # imports WrapperPackage/packageA
import sys
sys.modules['packageA'] = packageA  # creates a packageA entry in sys.modules
```
Kann es sein, dass Sie brauchen, um zusätzliche Einträge wenn:
```
sys.modules['packageA.moduleA'] = moduleA
# etc.
```
Nun cPickle finden packageA.moduleA und packageA.moduleB wieder an Ihre alten Standorte.

Möchten Sie vielleicht, um wieder schreiben die pickle-Datei danach das neue Modul-Position wird verwendet, damals. Die zusätzliche Aliase oben erstellt, sollte sicherstellen, dass die in Frage kommenden Modulen haben den neuen Standort name für cPickle zu Holen, wenn das schreiben der Klassen wieder.
- Muss ich dazu in WrapperPackege.__init__.py?
- Sie können dies tun, überall, aber die WrapperPackage/__init__.py Datei ist wahrscheinlich der beste Ort.
- Nach PEP328 import .something ist ungültig, es muss from .something import module? import .something wirft einen SyntaxError? python.org/dev/peps/pep-0328/#guido-s-decision
- Du hast vollkommen Recht. Ich vermeide relative Importe insgesamt, so dass ich fummelte der syntax. Korrigiert.
- genial, das scheint zu funktionieren, obwohl ich kann immer noch nicht die neu eingelegte Datei zu zeigen, den Pfad geändert, es ist immer noch packageA.moduleA aber ich kann es laden ohne Probleme.
- Haben Sie neu die Gurke durch das einbringen der geladenen Daten wieder?
- ja, obj = pickle.load(fh) -> pickle.dump(obj,fh2)
- Ah, ich vermute, Sie müssen laden Sie die alias-Module, die ersten, so dass Sie 'Leben' in den neuen Standorten erste.
InformationsquelleAutor Martijn Pieters

Zusätzlich zu @MartinPieters Antwort der andere Weg dies zu tun ist, um zu definieren, die find_global Methode der cPickle.Unpickler Klasse, oder erweitern Sie die pickle.Unpickler Klasse.

def map_path(mod_name, kls_name):
    if mod_name.startswith('packageA'): # catch all old module names
        mod = __import__('WrapperPackage.%s'%mod_name, fromlist=[mod_name])
        return getattr(mod, kls_name)
    else:
        mod = __import__(mod_name)
        return getattr(mod, kls_name)

import cPickle as pickle
with open('dump.pickle','r') as fh:
    unpickler = pickle.Unpickler(fh)
    unpickler.find_global = map_path
    obj = unpickler.load() # object will now contain the new class path reference

with open('dump-new.pickle','w') as fh:
    pickle.dump(obj, fh) # ClassA will now have a new path in 'dump-new'

Eine detailliertere Erläuterung des Prozesses für beide pickle und cPickle finden hier.

Die Webseite offline ist, aber archive.org hat es hier, und es ist sehr lesenswert.
Dieser link archive.org beta, nicht beta hier

InformationsquelleAutor Matti Lyra

2

Eine mögliche Lösung ist, direkt Bearbeiten Sie die pickle-Datei (wenn Sie Zugriff haben). Ich lief in das gleiche problem von einem geänderten Modul Weg, und ich hatte die Dateien gespeichert haben, wie Gurke.HIGHEST_PROTOCOL so sollte es sein binary in der Theorie, aber das Modul Weg war, sitzen an der Spitze der pickle-Datei im Klartext. So habe ich nur ein suchen und ersetzen auf alle Instanzen des alten Modul-Pfad, mit dem neuen und voila, Sie korrekt geladen.

Ich bin sicher, diese Lösung ist nicht für jedermann, vor allem, wenn Sie haben eine sehr komplexe eingelegte Objekt, aber es ist eine quick-and-dirty-Daten fix, arbeitete für mich!

InformationsquelleAutor Russ

Dies ist meine grundlegende Muster für flexible unpickling - über eine eindeutige und schnelle transition-Karte - wie es in der Regel nur ein paar der bekannten Klassen neben den primitiven Daten-Typen, die relevant sind für das marinieren. Dies schützt auch unpickling gegen fehlerhafte oder bösartig konstruierte Daten, die nach allem kann die Ausführung von beliebigem python-code (!) auf einen einfachen pickle.load() (mit oder ohne Fehler-anfällig sys.Module hantieren).

Python 2 & 3:

from __future__ import print_function
try:    import cPickle as pickle, copy_reg as copyreg
except: import pickle, copyreg

class OldZ:
    a = 1
class Z(object):
    a = 2
class Dangerous:
    pass   

_unpickle_map_safe = {
    # all possible and allowed (!) classes & upgrade paths    
    (__name__, 'Z')         : Z,    
    (__name__, 'OldZ')      : Z,
    ('old.package', 'OldZ') : Z,
    ('__main__', 'Z')       : Z,
    ('__main__', 'OldZ')    : Z,
    # basically required
    ('copy_reg', '_reconstructor') : copyreg._reconstructor,    
    ('__builtin__', 'object')      : copyreg._reconstructor,    
    }

def unpickle_find_class(modname, clsname):
    print("DEBUG unpickling: %(modname)s . %(clsname)s" % locals())
    try: return _unpickle_map_safe[(modname, clsname)]
    except KeyError:
        raise pickle.UnpicklingError(
            "%(modname)s . %(clsname)s not allowed" % locals())
if pickle.__name__ == 'cPickle':  # PY2
    def SafeUnpickler(f):
        u = pickle.Unpickler(f)
        u.find_global = unpickle_find_class
        return u
else:  # PY3 & Python2-pickle.py
    class SafeUnpickler(pickle.Unpickler):  
        find_class = staticmethod(unpickle_find_class)

def test(fn='./z.pkl'):
    z = OldZ()
    z.b = 'teststring' + sys.version
    pickle.dump(z, open(fn, 'wb'), 2)
    pickle.dump(Dangerous(), open(fn + 'D', 'wb'), 2)
    # load again
    o = SafeUnpickler(open(fn, 'rb')).load()
    print(pickle, "loaded:", o, o.a, o.b)
    assert o.__class__ is Z
    try: raise SafeUnpickler(open(fn + 'D', 'rb')).load() and AssertionError
    except pickle.UnpicklingError: print('OK: Dangerous not allowed')

if __name__ == '__main__':
    test()

InformationsquelleAutor kxr

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.