En Python, ¿cómo se cambia un objeto instanciado después de una recarga?

Question

Digamos que tiene un objeto que fue instanciado de una clase dentro de un módulo. Ahora, recarga ese módulo. Lo siguiente que le gustaría hacer es hacer que la recarga afecte a esa clase.

mymodule.py 
--- 
class ClassChange(): 
    def run(self): 
     print 'one' 

myexperiment.py 
--- 
import mymodule 
from mymodule import ClassChange # why is this necessary? 
myObject = ClassChange() 
myObject.run() 
>>> one 
### later, i changed this file, so that it says print 'two' 

reload(mymodule) 
# trick to change myObject needed here 
myObject.run() 
>>> two 

¿Tiene que hacer un nuevo objeto ClassChange, copiar myObject en eso, y eliminar el viejo myObject? ¿O hay una manera más simple?

Editar: El método run() parece un método de estilo de clase estático, pero eso fue solo por brevedad. Me gustaría que el método run() opere con datos dentro del objeto, por lo que una función de módulo estático no funcionaría ...

Answer 1

Tienes que hacer un objeto nuevo. No hay forma de actualizar mágicamente los objetos existentes.

Lea el reload builtin documentation - está muy claro. Aquí está el último párrafo:

Si un módulo de instancia instancias de una clase, volver a cargar el módulo que define la clase no afecta a las definiciones de métodos de los casos - que siguen utilizando la definición de clase de edad. Lo mismo es cierto para las clases derivadas.

Existen otras advertencias en la documentación, por lo que realmente debería leerlas, y considerar alternativas. Tal vez quiera comenzar una nueva pregunta con por qué desea usar reload y solicitar otras formas de lograr lo mismo.

Answer 2

El siguiente código hace lo que quiere, pero favor no lo use (al menos no hasta que esté muy seguro de que está haciendo lo correcto), he publicado sólo para fines de explicación.

mymodule.py:

class ClassChange(): 
    @classmethod 
    def run(cls,instance): 
     print 'one',id(instance) 

myexperiment.py:

import mymodule 

myObject = mymodule.ClassChange() 
mymodule.ClassChange.run(myObject) 

# change mymodule.py here 

reload(mymodule) 
mymodule.ClassChange.run(myObject) 

Cuando en el código que instanciate myObject, se obtiene una instancia de ClassChange. Esta instancia tiene un método de instancia llamado run. El objeto mantiene este método de instancia (por el motivo explicado por nosklo) incluso al volver a cargar, porque la recarga solo recarga la clase ClassChange.

En mi código anterior, run es un método de clase . Los métodos de clase siempre están vinculados ay funcionan en la clase, no en la instancia (razón por la cual su primer argumento generalmente se llama cls, no self). Wenn ClassChange se vuelve a cargar, este es el método de clase.

Puede ver que también paso la instancia como argumento para trabajar con la instancia correcta (misma) de ClassChange. Puede ver eso porque la misma identificación de objeto se imprime en ambos casos.

Answer 3

No estoy seguro de si esta es la mejor manera de hacerlo, o se acopla con lo que quiere hacer ... pero esto puede funcionar para usted. Si desea cambiar el comportamiento de un método, para todos los objetos de un cierto tipo ... simplemente use una variable de función. Por ejemplo:

def default_behavior(the_object): 
    print "one" 

def some_other_behavior(the_object): 
    print "two" 

class Foo(object): 
    # Class variable: a function that has the behavior 
    # (Takes an instance of a Foo as argument) 
    behavior = default_behavior 

    def __init__(self): 
    print "Foo initialized" 

    def method_that_changes_behavior(self): 
    Foo.behavior(self) 

if __name__ == "__main__": 
    foo = Foo() 
    foo.method_that_changes_behavior() # prints "one" 
    Foo.behavior = some_other_behavior 
    foo.method_that_changes_behavior() # prints "two" 

    # OUTPUT 
    # Foo initialized 
    # one 
    # two 

ahora puede tener una clase que se encarga de cargar de nuevo módulos, y después de la recarga, el establecimiento de Foo.behavior a algo nuevo. Probé este código. Funciona bien :-).

¿Esto funciona para usted?

Answer 4

Para actualizar todas las instancias de una clase, es necesario realizar un seguimiento de esas instancias, normalmente mediante referencias débiles (el valor débil es la más práctica y general) por lo que la funcionalidad "mantener el seguimiento" no detendrá las instancias innecesarias de irse, por supuesto!

Normalmente, desea mantener un contenedor de este tipo en el objeto de la clase, pero, en este caso, dado que va a volver a cargar el módulo, obtener el objeto de la clase anterior no es trivial; es más sencillo trabajar a nivel de módulo.

Por lo tanto, digamos que un "módulo actualizable" tiene que definir, en su inicio, un valor dict débil (y un auxiliar "llave junto a utilizar" int) con, por ejemplo, nombres convencionales:

import weakref 
class _List(list): pass # a weakly-referenceable sequence 
_objs = weakref.WeakValueDictionary() 
_nextkey = 0 
def _register(obj): 
    _objs[_nextkey] = List((obj, type(obj).__name__)) 
    _nextkey += 1 

Cada clase del módulo debe tener, por lo general en __init__, una llamada _register(self) para registrar nuevas instancias.

Ahora la "función de recarga" puede obtener la lista de todas las instancias de todas las clases en este módulo obteniendo una copia de _objs antes de volver a cargar el módulo.

Si todo lo que se necesita es cambiar el código, entonces la vida es razonablemente fácil:

def reload_all(amodule): 
    objs = getattr(amodule, '_objs', None) 
    reload(amodule) 
    if not objs: return # not an upgraable-module, or no objects 
    newobjs = getattr(amodule, '_objs', None) 
    for obj, classname in objs.values(): 
     newclass = getattr(amodule, classname) 
     obj.__class__ = newclass 
     if newobjs: newobjs._register(obj) 

Por desgracia, uno normalmente no quieren dar la nueva clase la oportunidad de actualizar un objeto de la clase de edad a sí mismo más finamente, por ejemplo por un método de clase adecuado. Eso no es demasiado duro, ya sea:

def reload_all(amodule): 
    objs = getattr(amodule, '_objs', None) 
    reload(amodule) 
    if not objs: return # not an upgraable-module, or no objects 
    newobjs = getattr(amodule, '_objs', None) 
    for obj, classname in objs: 
     newclass = getattr(amodule, classname) 
     upgrade = getattr(newclass, '_upgrade', None) 
     if upgrade: 
      upgrade(obj) 
     else: 
      obj.__class__ = newclass 
     if newobjs: newobjs._register(obj) 

Por ejemplo, dicen que la nueva versión de la clase Zap ha cambiado el nombre de un atributo de foo a bar. Este podría ser el código del nuevo Zap:

class Zap(object): 
    def __init__(self): 
     _register(self) 
     self.bar = 23 

    @classmethod 
    def _upgrade(cls, obj): 
     obj.bar = obj.foo 
     del obj.foo 
     obj.__class__ = cls 

esto no es todo - hay mucho más que decir sobre el tema - Pero, es la esencia, y la respuesta es mucho el tiempo suficiente ya (y yo, agotado lo suficiente ;-).

Answer 5

Hay trucos para hacer lo que quiera posible.

Alguien ya ha mencionado que puede tener una clase que mantiene una lista de sus instancias, y luego cambiar la clase de cada instancia a la nueva al volver a cargar.

Sin embargo, eso no es eficiente. Un mejor método es cambiar la clase anterior para que sea igual a la nueva clase.

Eche un vistazo a un artículo antiguo que escribí que es probablemente lo mejor que puede hacer para una recarga que modificará los objetos viejos.

http://www.codexon.com/posts/a-better-python-reload

Answer 6

Mi aproximación a esto es la siguiente:

1. Mire a través de todos los módulos importados y volver a cargar sólo aquellos con un nuevo archivo .py (en comparación con el archivo existente .pyc)
2. Para cada método de función y clase que se recarga, configure old_function .__ code__ = new_function .__ code__.
3. Para cada clase reloaded, use gc.get_referrers para listar instancias de la clase y establecer su atributo __class__ en la nueva versión.

Las ventajas de este enfoque son:

• Por lo general, no hay necesidad de recargar los módulos en un orden particular
• Por lo general, sólo tiene que volver a cargar los módulos con código cambiado y no más
• no hacer necesita modificar las clases para realizar un seguimiento de sus instancias

Puede leer sobre la técnica (y sus limitaciones) aquí: http://luke-campagnola.blogspot.com/2010/12/easy-automated-reloading-in-python.html

Y se puede descargar el código aquí: http://luke.campagnola.me/code/downloads/reload.py

Answer 7

Tienes que conseguir que la nueva clase del módulo fresco y asignarlo a la instancia.

Si pudiera desencadenar esta operación en cualquier momento que utiliza una instancia con este mixin:

import sys 

class ObjDebug(object): 
    def __getattribute__(self,k): 
    ga=object.__getattribute__ 
    sa=object.__setattr__ 
    cls=ga(self,'__class__') 
    modname=cls.__module__ 
    mod=__import__(modname) 
    del sys.modules[modname] 
    reload(mod) 
    sa(self,'__class__',getattr(mod,cls.__name__)) 
    return ga(self,k)