Comment utiliser l'aneth pour sérialiser une définition de classe?

Dans la réponse à la Python cornichon: gérer la mise à jour des définitions de classe, l'auteur de la dill package écrit:

"Ok, j'ai ajouté cette fonctionnalité à l'aneth dans la dernière version sur github. Mis en œuvre avec beaucoup moins de ruse que je ne le pensais... juste sérialiser la définition de la classe avec de la saumure, et le tour est joué."

Avoir installé dill et bricolé avec elle, il n'est pas évident pour moi de savoir comment utiliser cette fonctionnalité dans dill. Quelqu'un pourrait-il donner un exemple explicite? Je voudrais cornichons à l'instance de classe et également sérialiser la définition de la classe.

(Je suis nouveau sur le python et j'ai cette fonctionnalité semble très important, car depuis quand le décapage d'un objet, il serait bien d'obtenir une garantie que possible que vous pourriez regarder l'objet (qui peut être le résultat d'une simulation) dans l'avenir, après la définition de la classe peuvent avoir changé, et vous n'avez pas gardé la trace de tous les changements d'une manière aisément accessible.)

OriginalL'auteur user8765 | 2014-09-01

  1. 6

    Je pense que vous êtes à la recherche pour l'une des fonctions suivantes...

    Ici je créer une classe et une instance, puis modifiez la définition de classe.
    Le marinés classe et d'instance sont encore unpicklable parce que dill cornichons
    le code source de la classe par défaut... et gère le fait d'avoir plusieurs classes
    avec le même nom dans l'espace de noms (il le fait tout simplement en gérant le pointeur
    les références à la classe des définitions).

    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
>>> 
>>> class Foo(object):
...   def bar(self, x):
...     return x+self.y       
...   y = 1
... 
>>> f = Foo()
>>> _Foo = dill.dumps(Foo)
>>> _f = dill.dumps(f)
>>> 
>>> class Foo(object):
...   def bar(self, x):
...     return x*self.z  
...   z = -1 
... 
>>> f_ = dill.loads(_f, ignore=True)
>>> f_.y
1
>>> f_.bar(1)
2
>>> Foo_ = dill.loads(_Foo)
>>> g = Foo_()
>>> g.bar(1)
2

    Pickle ferait exploser sur le dessus de. Si vous ne voulez pas dill pour sérialiser la classe explicitement, et pour ce faire, pickle est le cas, vous pouvez demander dill à cornichon en référence avec dill.dumps(Foo, byref=True). Alternativement, vous pouvez décider, de manière dynamique à ignorer la nouvelle définition de la classe en utilisant ignore=False (valeur par défaut).

    Maintenant, dans le cas ci-dessous, nous travaillons avec la nouvelle définition de la classe, et de l'extrait de la source
    à partir de l'objet, puis l'enregistrer dans un fichier. En outre, nous pouvons faire un dump de la source dans un fichier (ici, j'utilise un fichier temporaire) afin de pouvoir les importer plus tard.

    >>> sFoo = dill.source.getsource(Foo)
>>> print sFoo
class Foo(object):
  def bar(self, x):
    return x*self.z
  z = -1

>>> open('myFoo.py', 'w').write(sFoo)    
>>>
>>> f = dill.temp.dump_source(Foo, dir='.')
>>> f.name
'/Users/mmckerns/dev/tmpM1dzYN.py'
>>> from tmpM1dzYN import Foo as _Foo_
>>> h = _Foo_()
>>> h.bar(2)
-2
>>> from myFoo import Foo as _SFoo_
>>> _SFoo_.z
>>> -1
>>>

    J'espère que ça aide.

    Concernant votre premier bloc de code, je le lance et il fait exploser exactement comme pickle: AttributeError: 'Foo' objet n'a pas d'attribut "y". vers la ligne 25. Dommage, parce que ça sonnait comme une instance de la magie, et il serait de rendre le stockage de l'aneth-ed des objets dans une base de données plus facile à gérer. Il y a donc un énorme cas d'utilisation. L'aneth 0.2.7.1, l'aneth paramètres par défaut (byref Faux). J'espère que c'est une erreur de l'opérateur, mais couper et coller solidement à l'intérieur de mon niveau de compétences.
    L'erreur est spécifique à ipython. Gros soupir de soulagement, mais encore perplexe ... va enquêter et/ou ouvrir un ticket
    Bizarre. Je peux répéter le comportement dans ipython, de sorte qu'ils doivent être marinage avec quelque chose d'inattendu. Il semble que c'est un comportement nouveau. Hmm. J'ai vu ton billet, merci.
    Comme détaillé dans votre billet, j'ai mis à jour dill.settings explicitement être en mesure de choisir le comportement que tu voulais. J'ai édité ma réponse ci-dessus pour montrer que.
    Je ne vois pas le lien avec le problème ici, c'est github.com/uqfoundation/dill/issues/243 Merci Mike

    OriginalL'auteur Mike McKerns

  2. 5

    Si cette fonctionnalité ont été si important que cela, il serait dans la langue de base. 🙂
    Alors, non, ce n'est pas critique pour l'utilisation de Python dans toute forme avancée - et si vous avez un projet qui s'appuie sur le fait d'être en mesure de ré-instancier des objets basée dans les anciens modèles - ce qui est possible, vous devez soigneusement réfléchir, et probablement garder les anciens modèles autour de dans code explicite, au lieu d'avoir alors sérialisé.

    Mon conseil est simplement "laisser qu'en dehors" jusqu'à ce que vous pensez que vous avez réellement besoin d'elle, et l'avait comparé à d'autres solutions, comme un solide modèle de politique migratoire.

    Cela dit, j'ai essayé de l'aneth, et il fonctionne comme prévu: il peut sérialiser une classe
    tout comme cornichon peut faire avec de simples objets à l'aide de la "dump" et "décharges" appels, et de reconstruire l'objet de classe avec "load" et "charges".

    Ce qui est probablement vous obtenir confus, c'est que la sérialisation d'un objet (par le biais de cornichons ou de l'aneth), ne comprennent pas ni son code source (c'est à dire le réel de lignes de texte de code Python utilisé pour définir la classe), ni son nom.

    Ainsi, si une classe est nommée "A", lorsqu'il est activé, si vous avez besoin de ce nom après "undilling", vous devez réaffecter ce nom dans le nom global de l'espace. C'est original le nom est conservé dans __name__ attribut. (et pour vos besoins de plusieurs versions d'un même modèle de vivre ensemble, ce qui conduira à beaucoup de conflits).

    Ainsi:

    class A(object):
    ...

import dill

dill.dump(A, open("myfile", "w"))

del A
....
someclass = dill.load(open("myfile"))
print (someclass.__name__)
globals()[someclass.__name__] = someclass
# at this point you have the "A" class back in the global namespace

    OriginalL'auteur jsbueno