Podlewanie podklasy o parametrach sparametryzowanych dynamicznie

Question

Mam system, który zwykle przechowuje typy kiszonych klas.

Chcę móc zapisywać dynamicznie sparametryzowane klasy w ten sam sposób, ale nie mogę, ponieważ otrzymuję błąd PicklingError podczas próby pobrania klasy, która nie została znaleziona globalnie (nie zdefiniowano w prostym kodzie).

Mój problem można modelować jak w poniższym przykładzie kodu:

class Base(object): 
def m(self): 
    return self.__class__.PARAM 

def make_parameterized(param_value): 
class AutoSubClass(Base): 
    PARAM = param_value 
return AutoSubClass 

cls = make_parameterized(input("param value?")) 

Kiedy próbuję marynowane klasę, pojawia się następujący błąd:

# pickle.PicklingError: Can't pickle <class '__main__.AutoSubClass'>: it's not found as __main__.AutoSubClass 
import pickle 
print pickle.dumps(cls) 

szukam jakiegoś sposobu zadeklaruj Base jako ParameterizableBaseClass, który powinien zdefiniować potrzebne parametry (PARAM w powyższym przykładzie). Podklasa z parametrami dynamicznymi (cls) powinna być następnie dostępna do wybrania przez zapisanie typu "ParameterizableBaseClass" i różnych wartości parametrów (dynamiczny param_value powyżej).

Jestem pewien, że w wielu przypadkach można tego całkowicie uniknąć ... I mogę tego uniknąć również w moim kodzie, jeśli naprawdę (naprawdę) muszę. W pewnym momencie grałem z __metaclass__, copyreg, a nawet __builtin__.issubclass (nie pytam), ale nie mogłem go złamać.

Czuję, że nie byłbym wierny duchowi Pythona, gdybym nie pytał: w jaki sposób można to osiągnąć w stosunkowo czysty sposób?

Answer 1

Tak, to jest możliwe -

Ilekroć chcesz zwyczaj zalewy i Unpickle zachowań dla swoich obiektów, po prostu trzeba ustawić „__getstate__” i „__setstate__” metod na samej klasie.

W tym przypadku jest nieco trudniej: Potrzebna jest, jak zauważyliście, istnienie klasy w globalnym obszarze nazw, która jest klasą aktualnie trawionego obiektu: musi to być ta sama klasa, z Takie samo imię. Ok - umowa jest taka, że ​​klasa gthis istniejąca w przestrzeni globalnej może zostać utworzona w czasie pikle.

W czasie Unpickle klasa, o tej samej nazwie, musi istnieć - ale nie musi to być ten sam obiekt - po prostu zachowuj się tak jak ona - a jako __setstate__ jest wywoływana w procesie Unpickling, może odtworzyć sparametryzować klasę obiektu orignal i ustawić własną klasę na taką, ustawiając atrybut atrybutu obiektu na __class__.

Ustawienie atrybutu obiektu może być niepożądane, ale OO działa w Pythonie i jest oficjalnie udokumentowane, działa nawet w różnych implementacjach. (Testowałem ten fragment zarówno w Pythonie 2.6 i pypy)

class Base(object): 
    def m(self): 
     return self.__class__.PARAM 
    def __getstate__(self): 
     global AutoSub 
     AutoSub = self.__class__ 
     return (self.__dict__,self.__class__.PARAM) 
    def __setstate__(self, state): 
     self.__class__ = make_parameterized(state[1]) 
     self.__dict__.update(state[0]) 

def make_parameterized(param_value): 
    class AutoSub(Base): 
     PARAM = param_value 
    return AutoSub 

class AutoSub(Base): 
    pass 


if __name__ == "__main__": 

    from pickle import dumps, loads 

    a = make_parameterized("a")() 
    b = make_parameterized("b")() 

    print a.PARAM, b.PARAM, type(a) is type(b) 
    a_p = dumps(a) 
    b_p = dumps(b) 

    del a, b 
    a = loads(a_p) 
    b = loads(b_p) 

    print a.PARAM, b.PARAM, type(a) is type(b) 

Answer 2

Klasy, które nie zostały utworzone na najwyższym poziomie modułu, nie można oszklić, as shown in the Python documentation.

Ponadto, nawet dla instancji klasy modułu najwyższego poziomu atrybuty klasy nie są przechowywane. Tak więc w twoim przykładzie PARAM i tak nie będzie przechowywany. (Wyjaśnienie w sekcji dokumentacji Pythona również powyżej)

Answer 3

Sądzę, że jest już za późno, ale pikle to moduł, którego wolałbym uniknąć w przypadku wszystkiego złożonego, ponieważ ma problemy takie jak ten i wiele innych.

Anyways, ponieważ zalewa chce klasę w globalnym może mieć go:

import cPickle 

class Base(object): 
    def m(self): 
     return self.__class__.PARAM 

    @classmethod 
    def make_parameterized(cls,param): 
     clsname = "AutoSubClass.%s" % param 
     # create a class, assign it as a global under the same name 
     typ = globals()[clsname] = type(clsname, (cls,), dict(PARAM=param)) 
     return typ 

cls = Base.make_parameterized('asd') 

import pickle 
s = pickle.dumps(cls) 

cls = pickle.loads(s) 
print cls, cls.PARAM 
# <class '__main__.AutoSubClass.asd'> asd 

Ale tak, jesteś prawdopodobnie overcomplicating rzeczy.

Answer 4

wiem, że to jest bardzo stare pytanie, ale myślę, że warto dzielić lepszym środkiem trawienie parametryzowane zajęcia niż ten, który jest aktualnie przyjęte rozwiązanie (dzięki czemu sparametryzowana klasa jest globalna).

Używając metody __reduce__, możemy dostarczyć wywołanie, które zwróci niezainicjowaną instancję naszej pożądanej klasy.

class Base(object): 
    def m(self): 
     return self.__class__.PARAM 

    def __reduce__(self): 
     return (_InitializeParameterized(), (self.PARAM,), self.__dict__) 


def make_parameterized(param_value): 
    class AutoSub(Base): 
     PARAM = param_value 
    return AutoSub 


class _InitializeParameterized(object): 
    """ 
    When called with the param value as the only argument, returns an 
    un-initialized instance of the parameterized class. Subsequent __setstate__ 
    will be called by pickle. 
    """ 
    def __call__(self, param_value): 
     # make a simple object which has no complex __init__ (this one will do) 
     obj = _InitializeParameterized() 
     obj.__class__ = make_parameterized(param_value) 
     return obj 

if __name__ == "__main__": 

    from pickle import dumps, loads 

    a = make_parameterized("a")() 
    b = make_parameterized("b")() 

    print a.PARAM, b.PARAM, type(a) is type(b) 
    a_p = dumps(a) 
    b_p = dumps(b) 

    del a, b 
    a = loads(a_p) 
    b = loads(b_p) 

    print a.PARAM, b.PARAM, type(a) is type(b) 

Warto przeczytaniu __reduce__ docs kilka razy, aby zobaczyć dokładnie to, co się tu dzieje.

Mam nadzieję, że ktoś uzna to za przydatne.