def test_slots_data_member_change(): origin_file = """ class A(object): __slots__ = ["m_member1", "m_member2"] def __init__(self): self.m_member1 = None self.m_member2 = None """ new_file = """ class A(object): __slots__ = ["m_member1", "m_member3"] def __init__(self): self.m_member1 = None self.m_member3 = None """ file_name = "scripts/slots_data_member_change.py" ReplaceScripts(file_name, origin_file) import scripts.slots_data_member_change ReplaceScripts(file_name, new_file) with pytest.raises(Exception) as excinfo: xreload.xreload(scripts.slots_data_member_change.__name__) assert "data member" in str(excinfo.value)
def test_before_slot_class(): origin_file = """ class A(object): __slots__ = ["m_member", "Foo"] def __init__(self, member): self.m_member = member def Foo(self): pass """ new_file = """ class A(object): def __init__(self, member): self.m_member = member def Foo(self): pass """ file_name = "scripts/before_slot_class.py" ReplaceScripts(file_name, origin_file) import scripts.before_slot_class ReplaceScripts(file_name, new_file) with pytest.raises(Exception) as excinfo: xreload.xreload(scripts.before_slot_class.__name__) assert excinfo.match(r"__slots__.*before.*after modified")
def upgrade(): '''Performs code upgrade, beware the bugs!''' print "reloading" import xreload reload(xreload) import bot_module xreload.xreload(bot_module) return
def test_slots_update_class(): origin_file = """ class A(object): __slots__ = ["m_member", "Foo", "DeleteMethod", "Static"] def __init__(self): self.m_member = 1 def Foo(self): return 'before' def DeleteMethod(self): pass @staticmethod def Static(): pass """ new_file = """ class A(object): __slots__ = ["m_member", "Foo", "Bar"] def __init__(self): self.m_member = 2 def Foo(self): return 'after' @classmethod def Bar(cls): pass """ file_name = "scripts/slots_update_class.py" ReplaceScripts(file_name, origin_file) import scripts.slots_update_class module = scripts.slots_update_class assert hasattr(module.A, 'DeleteMethod') assert isinstance(module.A.DeleteMethod, types.MethodType) assert hasattr(module.A, 'Foo') assert hasattr(module.A, 'm_member') ReplaceScripts(file_name, new_file) xreload.xreload(module.__name__) assert hasattr(module.A, 'Foo') assert isinstance(module.A.Foo, types.MethodType) a = module.A() assert a.m_member == 2 assert a.Foo() == 'after' assert hasattr(module.A, 'Bar') assert isinstance(module.A.__dict__['Bar'], classmethod) assert not hasattr(module.A, 'DeleteMethod') assert hasattr(module.A, 'm_member') assert not hasattr(module.A, 'Static')
def test_global_values(): origin_file = \ """ g_user_table = {} def LoadUsers(): global g_user_table g_user_table[1234] = 'Alice' g_user_table[5678] = 'Bob' manager = None def GetManagerInstance(): global manager if not manager: manager = "God" return manager CONSTANT_VALUE = "I don't know" """ new_file = \ """ g_user_table = {} def LoadUsers(): global g_user_table g_user_table[1234] = 'Alice' g_user_table[5678] = 'Bob' manager = None def GetManagerInstance(): global manager if not manager: manager = "God" return manager CONSTANT_VALUE = 31415926 # compare to its origin value which is a different type, string """ file_name = "scripts/global_values.py" ReplaceScripts(file_name, origin_file) import scripts.global_values module = scripts.global_values module.LoadUsers() module.GetManagerInstance() assert module.g_user_table != {} assert module.manager is not None assert module.CONSTANT_VALUE == "I don't know" ReplaceScripts(file_name, new_file) xreload.xreload(module.__name__) assert module.g_user_table != {} assert module.manager is not None assert module.CONSTANT_VALUE == 31415926
def pressbutton(self, button, event): self.xml.update() if event == "Reload code": import yai, xmltree for module in [yai, xmltree, texttree]: xreload(module) elif event == "Set": obj = self.xml.selection[0] obj[self.editor.prop] = self.editor.get_text() self.xml.update()
def upgrade(): """Performs code upgrade, beware the bugs!""" print "reloading" import xreload reload(xreload) import bot_module xreload.xreload(bot_module) return
def test_pyc(): import os import py_compile import scripts.new_style_class path = "scripts/new_style_class.py" py_compile.compile(path) os.remove(path) assert not os.path.exists(path) pyc_path = path + 'c' assert os.path.exists(pyc_path) xreload.xreload("scripts.new_style_class") op = scripts.new_style_class.Operate(1, 1)
def reload_code(): global MOD_TIMES reloaded = [] for path, time, module in check_mod_times(): module = xreload.xreload(module) MOD_TIMES[path] = (time, module) reloaded.append(path) return reloaded
def eimport(modname, dir, use_xreload=False): """Import module MODNAME from directory DIR at the head of the search path. NB doesn't load from DIR if MODNAME shadows a system module.""" from __main__ import __dict__ if _emacs_py_debug: print "Loading module %r from directory %r" % (modname, dir) old_path = sys.path sys.path = [dir] # XXX for now + sys.path try: if True: # try: already_loaded = False try: # easiest way to peel back the package structure # print len(__dict__.keys()) mod = eval(modname, __dict__) already_loaded = True except: print "ACK!" already_loaded = False if already_loaded: if use_xreload or _emacs_py_xreload: if _emacs_py_debug: print "xreload-ing %s" % mod xreload.xreload(mod, path=[dir]) else: if _emacs_py_debug: print "reload-ing %s" % mod reload(mod) else: if _emacs_py_debug: print "__import__(%r)" % modname from __main__ import __dict__ __dict__[modname] = __import__(modname) # except: # traceback.print_exc() # raise finally: sys.path = old_path
def eimport (modname, dir, use_xreload=False): """Import module MODNAME from directory DIR at the head of the search path. NB doesn't load from DIR if MODNAME shadows a system module.""" from __main__ import __dict__ if _emacs_py_debug: print "Loading module %r from directory %r" % (modname, dir) old_path = sys.path sys.path = [dir] # XXX for now + sys.path try: if True: # try: already_loaded = False try: # easiest way to peel back the package structure # print len(__dict__.keys()) mod = eval(modname, __dict__) already_loaded = True except: print "ACK!" already_loaded = False if already_loaded: if use_xreload or _emacs_py_xreload: if _emacs_py_debug: print "xreload-ing %s" % mod xreload.xreload (mod, path=[dir]) else: if _emacs_py_debug: print "reload-ing %s" % mod reload (mod) else: if _emacs_py_debug: print "__import__(%r)" % modname from __main__ import __dict__ __dict__[modname] = __import__ (modname) # except: # traceback.print_exc() # raise finally: sys.path = old_path
def test_function(): origin_file = \ """ def Foo(): return 13579 """ new_file = \ """ def Foo(): return 97531 """ file_name = "scripts/functions.py" ReplaceScripts(file_name, origin_file) import scripts.functions module = scripts.functions assert module.Foo() == 13579 ReplaceScripts(file_name, new_file) xreload.xreload(module.__name__) assert module.Foo() == 97531
Cfoo = C.foo Cbar = C.bar Cstomp = C.stomp b = C() bfoo = b.foo b.foo() bfoo() Cfoo(b) Cbar() Cstomp() #modify mod and reload count = 0 while count < 1: count += 1 make_mod(repl="0", subst=str(count)) xreload(x) C = x.C Cfoo = C.foo Cbar = C.bar Cstomp = C.stomp b = C() bfoo = b.foo b.foo() bfoo() Cfoo(b) Cbar() Cstomp()
def reload_code(self): import inspect import xreload mod = inspect.getmodule(self) x = xreload.xreload(mod) print("Reloading from code", mod, x)
def reload_script(): return xreload(sys.modules[__name__], new_annotations={'RELOADING': True})
def test_new_style_class(): origin_file = \ """ class Operate(object): def __init__(self, x, y): self.m_x = x self.m_y = y def add(self): return self.m_x + self.m_y + 1 @classmethod def minus(cls, x, y): return x - y @staticmethod def multiply(x, y): return x * y def to_bo_delete_method(self): pass """ new_file = \ """ class Operate(object): def __init__(self, x, y): self.m_x = x self.m_y = y def add(self): return self.m_x + self.m_y @classmethod def minus(cls, x, y): return y - x @staticmethod def multiply(x, y): return x * y * 2 def divide(self): return self.m_x / self.m_y """ file_name = "scripts/new_style_class.py" ReplaceScripts(file_name, origin_file) import scripts.new_style_class module = scripts.new_style_class x = 17 y = 3 op = module.Operate(x, y) assert op.add() == 21 assert module.Operate.minus(x, y) == 14 assert module.Operate.multiply(x, y) == 51 assert hasattr(module.Operate, "to_bo_delete_method") Operate_instance_add = op.add Operate_minus = module.Operate.minus Operate_multiply = module.Operate.multiply ReplaceScripts(file_name, new_file) xreload.xreload(module.__name__) new_op = module.Operate(x, y) assert Operate_instance_add == op.add assert op.add() == 20 assert Operate_minus(x, y) == -14 assert Operate_multiply(x, y) == 102 assert op.divide() == 5 assert not hasattr(module.Operate, "to_bo_delete_method")
Cbar = C.bar Cstomp = C.stomp b = C() bfoo = b.foo b.foo() bfoo() Cfoo(b) Cbar() Cstomp() #modify mod and reload count = 0 while count < 1: count += 1 make_mod(repl="0", subst=str(count)) xreload(x) C = x.C Cfoo = C.foo Cbar = C.bar Cstomp = C.stomp b = C() bfoo = b.foo b.foo() bfoo() Cfoo(b) Cbar() Cstomp()
def test_derived_class(): origin_file = """ class A(object): def __init__(self): pass class B(A): def __init__(self): super(B, self).__init__() """ new_file = """ class A(object): def __init__(self): pass class B(A): def __init__(self): super(B, self).__init__() class C(B): def __init__(self): super(C, self).__init__() def Foo(): a = A() b = B() c = C() """ other_file = """ class E(object): def __init__(self): super(E, self).__init__() """ other_new_file = """ import base_derived_classes class E(object): def __init__(self): super(E, self).__init__() class D(base_derived_classes.B, E): def __init__(self): super(D, self).__init__() def Foo(): b = base_derived_classes.B() d = D() """ file_name = "scripts/base_derived_classes.py" ReplaceScripts(file_name, origin_file) import scripts.base_derived_classes other_name = "scripts/other.py" ReplaceScripts(other_name, other_file) import scripts.other module = scripts.base_derived_classes ReplaceScripts(file_name, new_file) ReplaceScripts(other_name, other_new_file) xreload.xreload(module.__name__) xreload.xreload(scripts.other.__name__) module.Foo() scripts.other.Foo()