def test_update_constant_with_custom_code2(self): SAMPLE_CODE1 = """ class B(object): CONSTANT = 1 def foo(self): return self.CONSTANT """ SAMPLE_CODE2 = """ class B(object): CONSTANT = 2 def __xreload_old_new__(cls, name, old, new): if name == 'CONSTANT': cls.CONSTANT = new __xreload_old_new__ = classmethod(__xreload_old_new__) def foo(self): return self.CONSTANT """ self.make_mod(sample=SAMPLE_CODE1) import x # @UnresolvedImport foo = x.B().foo self.assertEqual(foo(), 1) self.make_mod(sample=SAMPLE_CODE2) pydevd_reload.xreload(x) self.assertEqual(foo(), 2) #Actually updated it now!
def test_update_with_slots(self): SAMPLE_CODE1 = """ class B(object): __slots__ = ['bar'] """ SAMPLE_CODE2 = """ class B(object): __slots__ = ['bar', 'foo'] def m1(self): self.bar = 10 return 1 """ self.make_mod(sample=SAMPLE_CODE1) import x # @UnresolvedImport B = x.B self.make_mod(sample=SAMPLE_CODE2) pydevd_reload.xreload(x) b = B() self.assertEqual(1, b.m1()) self.assertEqual(10, b.bar) self.assertRaises(Exception, setattr, b, 'foo', 20) #__slots__ can't be updated
def test_reload_custom_code_after_changes(self): SAMPLE_CODE1 = """ CONSTANT = 1 class B(object): def foo(self): return CONSTANT """ SAMPLE_CODE2 = """ CONSTANT = 1 def __xreload_after_reload_update__(namespace): namespace['CONSTANT'] = 2 class B(object): def foo(self): return CONSTANT """ self.make_mod(sample=SAMPLE_CODE1) import x # @UnresolvedImport foo = x.B().foo self.assertEqual(foo(), 1) self.make_mod(sample=SAMPLE_CODE2) pydevd_reload.xreload(x) self.assertEqual(foo(), 2) #Actually updated it now!
def test_reload_custom_code_after_changes_in_class(self): SAMPLE_CODE1 = """ class B(object): CONSTANT = 1 def foo(self): return self.CONSTANT """ SAMPLE_CODE2 = """ class B(object): CONSTANT = 1 @classmethod def __xreload_after_reload_update__(cls): cls.CONSTANT = 2 def foo(self): return self.CONSTANT """ self.make_mod(sample=SAMPLE_CODE1) import x # @UnresolvedImport foo = x.B().foo self.assertEqual(foo(), 1) self.make_mod(sample=SAMPLE_CODE2) pydevd_reload.xreload(x) self.assertEqual(foo(), 2) #Actually updated it now!
def test_parent_function(self): SAMPLE_CODE1 = """ class B(object): def foo(self): return 0 class C(B): def call(self): return self.foo() """ # Creating a new class and using it from old class SAMPLE_CODE2 = """ class B(object): def foo(self): return 0 def bar(self): return 'bar' class C(B): def call(self): return self.bar() """ self.make_mod(sample=SAMPLE_CODE1) import x # @UnresolvedImport call = x.C().call self.assertEqual(call(), 0) self.make_mod(sample=SAMPLE_CODE2) pydevd_reload.xreload(x) self.assertEqual(call(), 'bar')
def test_update_constant_with_custom_code(self): SAMPLE_CODE1 = """ CONSTANT = 1 class B(object): def foo(self): return CONSTANT """ SAMPLE_CODE2 = """ CONSTANT = 2 def __xreload_old_new__(namespace, name, old, new): if name == 'CONSTANT': namespace[name] = new class B(object): def foo(self): return CONSTANT """ self.make_mod(sample=SAMPLE_CODE1) import x # @UnresolvedImport foo = x.B().foo self.assertEqual(foo(), 1) self.make_mod(sample=SAMPLE_CODE2) pydevd_reload.xreload(x) self.assertEqual(foo(), 2) #Actually updated it now!
def test_pydevd_reload2(self): self.make_mod() import x # @UnresolvedImport c = x.C() cfoo = c.foo self.assertEqual(0, c.foo()) self.assertEqual(0, cfoo()) self.make_mod(repl="0", subst='1') pydevd_reload.xreload(x) self.assertEqual(1, c.foo()) self.assertEqual(1, cfoo())
def internal_reload_code(dbg, seq, module_name): module_name = module_name if module_name not in sys.modules: if '.' in module_name: new_module_name = module_name.split('.')[-1] if new_module_name in sys.modules: module_name = new_module_name reloaded_ok = False if module_name not in sys.modules: sys.stderr.write('pydev debugger: Unable to find module to reload: "' + module_name + '".\n') # Too much info... # sys.stderr.write('pydev debugger: This usually means you are trying to reload the __main__ module (which cannot be reloaded).\n') else: sys.stderr.write('pydev debugger: Start reloading module: "' + module_name + '" ... \n') from _pydevd_bundle import pydevd_reload if pydevd_reload.xreload(sys.modules[module_name]): sys.stderr.write('pydev debugger: reload finished\n') reloaded_ok = True else: sys.stderr.write( 'pydev debugger: reload finished without applying any change\n' ) cmd = dbg.cmd_factory.make_reloaded_code_message(seq, reloaded_ok) dbg.writer.add_command(cmd)
def internal_reload_code(dbg, seq, module_name): module_name = module_name if module_name not in sys.modules: if '.' in module_name: new_module_name = module_name.split('.')[-1] if new_module_name in sys.modules: module_name = new_module_name reloaded_ok = False if module_name not in sys.modules: sys.stderr.write('pydev debugger: Unable to find module to reload: "' + module_name + '".\n') # Too much info... # sys.stderr.write('pydev debugger: This usually means you are trying to reload the __main__ module (which cannot be reloaded).\n') else: sys.stderr.write('pydev debugger: Start reloading module: "' + module_name + '" ... \n') from _pydevd_bundle import pydevd_reload if pydevd_reload.xreload(sys.modules[module_name]): sys.stderr.write('pydev debugger: reload finished\n') reloaded_ok = True else: sys.stderr.write('pydev debugger: reload finished without applying any change\n') cmd = dbg.cmd_factory.make_reloaded_code_message(seq, reloaded_ok) dbg.writer.add_command(cmd)
def test_pydevd_reload(self): self.make_mod() import x # @UnresolvedImport C = x.C COut = C Cfoo = C.foo Cbar = C.bar Cstomp = C.stomp def check2(expected): C = x.C Cfoo = C.foo Cbar = C.bar Cstomp = C.stomp b = C() bfoo = b.foo self.assertEqual(expected, b.foo()) self.assertEqual(expected, bfoo()) self.assertEqual(expected, Cfoo(b)) def check(expected): b = COut() bfoo = b.foo self.assertEqual(expected, b.foo()) self.assertEqual(expected, bfoo()) self.assertEqual(expected, Cfoo(b)) self.assertEqual((expected, expected), Cbar()) self.assertEqual((expected, expected, expected), Cstomp()) check2(expected) check(0) # modify mod and reload count = 0 while count < 1: count += 1 self.make_mod(repl="0", subst=str(count)) pydevd_reload.xreload(x) check(count)
def test_update_constant(self): SAMPLE_CODE1 = """ CONSTANT = 1 class B(object): def foo(self): return CONSTANT """ SAMPLE_CODE2 = """ CONSTANT = 2 class B(object): def foo(self): return CONSTANT """ self.make_mod(sample=SAMPLE_CODE1) import x # @UnresolvedImport foo = x.B().foo self.assertEqual(foo(), 1) self.make_mod(sample=SAMPLE_CODE2) pydevd_reload.xreload(x) self.assertEqual(foo(), 1) #Just making it explicit we don't reload constants.
def test_create_class2(self): SAMPLE_CODE1 = """ class C(object): def foo(self): return 0 """ # Creating a new class and using it from old class SAMPLE_CODE2 = """ class B(object): pass class C(object): def foo(self): return B """ self.make_mod(sample=SAMPLE_CODE1) import x # @UnresolvedImport foo = x.C().foo self.assertEqual(foo(), 0) self.make_mod(sample=SAMPLE_CODE2) pydevd_reload.xreload(x) self.assertEqual(foo().__name__, 'B')