Archiviare oggetto usando Pickle Python e caricarlo in uno spazio dei nomi diverso

Question

Vorrei passare lo stato oggetto tra due programmi Python (uno è il mio codice in esecuzione standalone, uno è una vista Pyramid) e diversi spazi dei nomi. Le domande un po 'correlate sono here o here, ma non riesco a seguirle abbastanza per il mio scenario.

mio codice definisce una classe globale (cioè __main__ namespace) di struttura piuttosto complexish:

# An instance of this is a colorful mess of nested lists and sets and dicts. 
class MyClass : 
    def __init__(self) : 
     data = set() 
     more = dict() 
     ... 

    def do_sth(self) : 
     ... 

A un certo punto pickle un'istanza di questa classe:

c = MyClass() 
# Fill c with data. 

# Pickle and write the MyClass instance within the __main__ namespace. 
with open("my_c.pik", "wb") as f : 
    pickle.dump(c, f, -1) 

A hexdump -C my_c.pik mostra che la prima coppia di byte contiene __main__.MyClass da cui presumo che la classe sia effettivamente definita nel namespace globale e che questo sia in qualche modo un requisito per leggere il pickle. Ora vorrei caricare questo salamoia MyClass esempio all'interno di una piramide vista, che presumo è uno spazio dei nomi diverso:

# In Pyramid (different namespace) read the pickled MyClass instance. 
with open("my_c.pik", "rb") as f : 
    c = pickle.load(f) 

Ma che genera il seguente errore:

File ".../views.py", line 60, in view_handler_bla 
    c = pickle.load(f) 
AttributeError: 'module' object has no attribute 'MyClass' 

Sembra me che la definizione MyClass manca in qualsiasi spazio dei nomi che viene eseguito dal codice di visualizzazione? Speravo (presumevo) che il decapaggio fosse un processo un po 'opaco che mi permettesse di leggere un blob di dati nel luogo che ho scelto. (Maggiori informazioni sui nomi delle classi e gli spazi dei nomi di Python sono here.)

Come posso gestirlo correttamente? (Idealmente senza dover importare cose attraverso ...) Posso in qualche modo trovare lo spazio dei nomi corrente e iniettare MyClass (come sembra suggerire la risposta this)?

Poor Soluzione

Mi sembra che se mi astengo dal definire e utilizzare MyClass e invece ricadere a semplici tipi di dati built-in, questo non sarebbe un problema. Infatti, ho potuto "serializzare" l'oggetto MyClass in una sequenza di chiamate che Pickle i singoli elementi dell'istanza MyClass:

# 'Manual' serialization of c works, because all elements are built-in types. 
pickle.dump(c.data, f, -1) 
pickle.dump(c.more, f, -1) 
... 

Questo sarebbe annullare l'obiettivo di incarto dati in classi però.

Nota

decapaggio si occupa solo dello stato di una classe, non di eventuali funzioni definite nell'ambito della classe (es do_sth() nell'esempio precedente). Ciò significa che il caricamento di un'istanza MyClass in uno spazio dei nomi diverso senza la definizione di classe appropriata carica solo i dati dell'istanza; chiamare una funzione mancante come do_sth() causerà un AttributeError.

Answer 1

Soluzione 1

Sulla pickle.load, il modulo __main__ deve avere una funzione o una classe denominata MyClass.Questo non ha bisogno di essere la classe originale con il codice sorgente originale. Puoi inserire altri metodi. Dovrebbe funzionare.

class MyClass(object): 
    pass 

with open("my_c.pik", "rb") as f : 
    c = pickle.load(f) 

Soluzione 2

Utilizza la copyreg module che viene utilizzato per registrare costruttori e funzioni salamoia decapare oggetti specifici. Questo è l'esempio di modulo di un numero complesso:

def pickle_complex(c): 
    return complex, (c.real, c.imag) 

copyreg.pickle(complex, pickle_complex, complex) 

Soluzione 3

Override la persistent_id method del Pickler e Unpickler. pickler.persistent_id(obj) restituirà un identificatore che può essere risolto da unpickler.persistent_id(id) all'oggetto.

Answer 2

Utilizzare dill invece di pickle, perché dill per default sottaceti serializzando la definizione di classe e non per riferimento.

>>> import dill 
>>> class MyClass: 
... def __init__(self): 
...  self.data = set() 
...  self.more = dict() 
... def do_stuff(self): 
...  return sorted(self.more) 
... 
>>> c = MyClass() 
>>> c.data.add(1) 
>>> c.data.add(2) 
>>> c.data.add(3) 
>>> c.data 
set([1, 2, 3]) 
>>> c.more['1'] = 1 
>>> c.more['2'] = 2 
>>> c.more['3'] = lambda x:x 
>>> def more_stuff(self, x): 
... return x+1 
... 
>>> c.more_stuff = more_stuff 
>>> 
>>> with open('my_c.pik', "wb") as f: 
... dill.dump(c, f) 
... 
>>> 

Arrestare la sessione, e riavviare in una nuova sessione ...

Python 2.7.8 (default, Jul 13 2014, 02:29:54) 
[GCC 4.2.1 Compatible Apple Clang 4.1 ((tags/Apple/clang-421.11.66))] on darwin 
Type "help", "copyright", "credits" or "license" for more information. 
>>> import dill 
>>> with open('my_c.pik', "rb") as f: 
... c = dill.load(f) 
... 
>>> c.data 
set([1, 2, 3]) 
>>> c.more 
{'1': 1, '3': <function <lambda> at 0x10473ec80>, '2': 2} 
>>> c.do_stuff() 
['1', '2', '3'] 
>>> c.more_stuff(5) 
6 

Get dill qui: https://github.com/uqfoundation/dill