def test_get_version(self): """Test the get_version function.""" c = Classic() v = version_registry.get_version(c) res = [(("Classic", __name__), 0)] self.assertEqual(v, res) state = state_pickler.get_state(c) self.assertEqual(state.__metadata__["version"], res) n = New() v = version_registry.get_version(n) res = [(("New", __name__), 0)] self.assertEqual(v, res) state = state_pickler.get_state(n) self.assertEqual(state.__metadata__["version"], res) t = TraitClass() v = version_registry.get_version(t) res = [ (("CHasTraits", "traits.ctraits"), -1), (("HasTraits", "traits.has_traits"), -1), (("TraitClass", __name__), 0), ] self.assertEqual(v, res) state = state_pickler.get_state(t) self.assertEqual(state.__metadata__["version"], res)
def test_get_version(self): """Test the get_version function.""" if sys.version_info[0] > 2: extra = [(('object', 'builtins'), -1)] else: extra = [] c = Classic() v = version_registry.get_version(c) res = extra + [(('Classic', __name__), 0)] self.assertEqual(v, res) state = state_pickler.get_state(c) self.assertEqual(state.__metadata__['version'], res) n = New() v = version_registry.get_version(n) res = extra + [(('New', __name__), 0)] self.assertEqual(v, res) state = state_pickler.get_state(n) self.assertEqual(state.__metadata__['version'], res) t = TraitClass() v = version_registry.get_version(t) res = extra + [(('CHasTraits', 'traits.ctraits'), -1), (('HasTraits', 'traits.has_traits'), -1), (('TraitClass', __name__), 0)] self.assertEqual(v, res) state = state_pickler.get_state(t) self.assertEqual(state.__metadata__['version'], res)
def test_get_version(self): """Test the get_version function.""" extra = [(("object", "builtins"), -1)] c = Classic() v = version_registry.get_version(c) res = extra + [(("Classic", __name__), 0)] self.assertEqual(v, res) state = state_pickler.get_state(c) self.assertEqual(state.__metadata__["version"], res) n = New() v = version_registry.get_version(n) res = extra + [(("New", __name__), 0)] self.assertEqual(v, res) state = state_pickler.get_state(n) self.assertEqual(state.__metadata__["version"], res) t = TraitClass() v = version_registry.get_version(t) res = extra + [ (("CHasTraits", "traits.ctraits"), -1), (("HasTraits", "traits.has_traits"), -1), (("TraitClass", __name__), 0), ] self.assertEqual(v, res) state = state_pickler.get_state(t) self.assertEqual(state.__metadata__["version"], res)
def test_update(self): """Test if update method calls the handlers in order.""" registry = version_registry.registry # First an elementary test. c = Classic() state = state_pickler.get_state(c) h = Handler() registry.register('Classic', __name__, h.upgrade) c1 = state_pickler.create_instance(state) state_pickler.set_state(c1, state) self.assertEqual(h.calls, [('upgrade', state, 0)]) # Remove the handler. registry.unregister('Classic', __name__) # Now check to see if this works for inheritance trees. t = Test() state = state_pickler.get_state(t) h = Handler() registry.register('Classic', __name__, h.upgrade) registry.register('New', __name__, h.upgrade) registry.register('Test', __name__, h.upgrade1) t1 = state_pickler.create_instance(state) state_pickler.set_state(t1, state) # This should call New handler, then the Test and then # Classic. self.assertEqual(h.calls, [('upgrade', state, 0), ('upgrade1', state, 1), ('upgrade', state.a, 0)])
def test_has_instance(self): """Test to check has_instance correctness.""" a = A() r = state_pickler.get_state(a) self.assertEqual(r.__metadata__['has_instance'], True) l = [1, a] r = state_pickler.get_state(l) self.assertEqual(r.has_instance, True) self.assertEqual(r[1].__metadata__['has_instance'], True) d = {'a': l, 'b': 1} r = state_pickler.get_state(d) self.assertEqual(r.has_instance, True) self.assertEqual(r['a'].has_instance, True) self.assertEqual(r['a'][1].__metadata__['has_instance'], True) class B: def __init__(self): self.a = [1, A()] b = B() r = state_pickler.get_state(b) self.assertEqual(r.__metadata__['has_instance'], True) self.assertEqual(r.a.has_instance, True) self.assertEqual(r.a[1].__metadata__['has_instance'], True)
def save_visualization(self, file_or_fname): """Given a file or a file name, this saves the current visualization to the file. """ # Save the state of VTK's global warning display. o = vtk.vtkObject w = o.GetGlobalWarningDisplay() o.SetGlobalWarningDisplay(0) # Turn it off. try: #FIXME: This is for streamline seed point widget position which #does not get serialized correctly if is_old_pipeline(): state_pickler.dump(self, file_or_fname) else: state = state_pickler.get_state(self) st = state.scenes[0].children[0].children[0].children[4] l_pos = st.seed.widget.position st.seed.widget.position = [pos.item() for pos in l_pos] saved_state = state_pickler.dumps(state) file_or_fname.write(saved_state) except (IndexError, AttributeError): state_pickler.dump(self, file_or_fname) finally: # Reset the warning state. o.SetGlobalWarningDisplay(w)
def __deepcopy__(self, memo): """Method used by copy.deepcopy(). This also uses the state_pickler to work correctly. """ # Create a new instance. new = self.__class__() # If we have a saved state, use it for the new instance. If # not, get our state and save that. saved_state = self._saved_state if len(saved_state) == 0: state = state_pickler.get_state(self) #FIXME: This is for streamline seed point widget position which #does not get serialized correctly if not is_old_pipeline(): try: st = state.children[0].children[4] l_pos = st.seed.widget.position st.seed.widget.position = [pos.item() for pos in l_pos] except (IndexError, AttributeError): pass saved_state = pickle.dumps(state) new._saved_state = saved_state # In the unlikely case that a new instance is running, load # the saved state. if new.running: new._load_saved_state() return new
def test_state_setter(self): """Test some of the features of the set_state method.""" t = TestClassic() self.set_object(t) # Get the saved state. res = state_pickler.get_state(t) # Now create a new instance and test the setter. t1 = state_pickler.create_instance(res) keys = ['c', 'b', 'f', 'i', 'tuple', 'list', 'l', 'numeric', 'n', 's', 'u', 'pure_list', 'inst', 'ref', 'dict'] ignore = list(keys) ignore.remove('b') first = ['b'] last = [] state_pickler.set_state(t1, res, ignore=ignore, first=first, last=last) # Only 'b' should have been set. self.assertEqual(t1.b, True) # Rest are unchanged. self.assertEqual(t1.i, 7) self.assertEqual(t1.s, 'String') self.assertEqual(t1.u, u'Unicode') self.assertEqual(t1.inst.a, 'a') self.assertEqual(t1.list[0], 1) self.assertEqual(t1.tuple[-1].a, 'a') self.assertEqual(t1.dict['a'], 1) # Check if last works. last = ignore ignore = [] first = [] state_pickler.set_state(t1, res, ignore=ignore, first=first, last=last) # Check everything. self.verify_unpickled(t1, res)
def test_state_is_saveable(self): """Test if the state can be saved like the object itself.""" t = TestClassic() self.set_object(t) state = state_pickler.get_state(t) # Now get the state of the state itself. state1 = state_pickler.get_state(state) self.verify_state(state1, state) # Same thing for the traited class. t = TestTraits() self.set_object(t) state = state_pickler.get_state(t) # Now get the state of the state itself. state1 = state_pickler.get_state(state) self.verify_state(state1, state)
def __deepcopy__(self, memo): """Method used by copy.deepcopy(). This also uses the state_pickler to work correctly. """ # Create a new instance. new = self.__class__() # If we have a saved state, use it for the new instance. If # not, get our state and save that. saved_state = self._saved_state if len(saved_state) == 0: state = state_pickler.get_state(self) # FIXME: This is for streamline seed point widget position which # does not get serialized correctly if not is_old_pipeline(): try: st = state.children[0].children[4] l_pos = st.seed.widget.position st.seed.widget.position = [pos.item() for pos in l_pos] except (IndexError, AttributeError): pass saved_state = cPickle.dumps(state) new._saved_state = saved_state # In the unlikely case that a new instance is running, load # the saved state. if new.running: new._load_saved_state() return new
def do(self): script = self.script ############################################################ # Create a new scene and set up the visualization. scene = self.new_scene() # Read a VTK (old style) data file. source = VTKFileReader() source.initialize(get_example_data('heart.vtk')) script.add_source(source) script.add_module(Surface()) # In order to test the restoration of visualization properly # we should modify the camera view(130., 44., 65., [14., 14., 14.]) ############################################################ # Test if saving a visualization and restoring it works. # Save visualization. f = BytesIO() f.name = abspath('test.mv2') # We simulate a file. script.save_visualization(f) f.seek(0) # So we can read this saved data. # This is the old camera state old_camera_state = get_state(scene.scene.camera) # Remove existing scene. engine = script.engine engine.close_scene(scene) # Load visualization script.load_visualization(f) scene = engine.current_scene # Now do the check. new_camera_state = get_state(scene.scene.camera) for attr, new_value in new_camera_state.items(): if attr.startswith("_"): continue new_value = array(new_value) old_value = array(old_camera_state[attr]) assert (new_value == old_value).all()
def test_unpickle_classic(self): """Test if classic classes can be unpickled.""" t = TestClassic() self.set_object(t) # Get the pickled state. res = state_pickler.get_state(t) # Check each attribute. self.verify_unpickled(t, res)
def test_get_state_on_tuple_with_numeric_references(self): num = numpy.zeros(10, float) data = (num, num) # If this just completes without error, we are good. state = state_pickler.get_state(data) # The two should be the same object. self.assertTrue(state[0] is state[1]) numpy.testing.assert_allclose(state[0], num)
def test_get_pure_state(self): """Test if get_pure_state is called first.""" class B: def __init__(self): self.a = 'dict' def __get_pure_state__(self): return {'a':'get_pure_state'} def __getstate__(self): return {'a':'getstate'} b = B() s = state_pickler.get_state(b) self.assertEqual(s.a, 'get_pure_state') del B.__get_pure_state__ s = state_pickler.get_state(b) self.assertEqual(s.a, 'getstate') del B.__getstate__ s = state_pickler.get_state(b) self.assertEqual(s.a, 'dict')
def test_get_pure_state(self): """Test if get_pure_state is called first.""" class B: def __init__(self): self.a = "dict" def __get_pure_state__(self): return {"a": "get_pure_state"} def __getstate__(self): return {"a": "getstate"} b = B() s = state_pickler.get_state(b) self.assertEqual(s.a, "get_pure_state") del B.__get_pure_state__ s = state_pickler.get_state(b) self.assertEqual(s.a, "getstate") del B.__getstate__ s = state_pickler.get_state(b) self.assertEqual(s.a, "dict")
def test_state_setter_classic(self): """Test if classic classes' state can be set.""" t = TestClassic() self.set_object(t) # Get the pickled state. res = state_pickler.get_state(t) # Now create a new instance and set its state. t1 = state_pickler.create_instance(res) state_pickler.set_state(t1, res) # Check each attribute. self.verify_unpickled(t1, res)
def test_get_pure_state(self): """Test if get_pure_state is called first.""" class B: def __init__(self): self.a = 'dict' def __get_pure_state__(self): return {'a': 'get_pure_state'} def __getstate__(self): return {'a': 'getstate'} b = B() s = state_pickler.get_state(b) self.assertEqual(s.a, 'get_pure_state') del B.__get_pure_state__ s = state_pickler.get_state(b) self.assertEqual(s.a, 'getstate') del B.__getstate__ s = state_pickler.get_state(b) self.assertEqual(s.a, 'dict')
def test_reference_cycle(self): """Test if reference cycles are handled when setting the state.""" class A: pass class B: pass a = A() b = B() a.a = b b.b = a state = state_pickler.get_state(a) z = A() z.a = B() z.a.b = z state_pickler.set_state(z, state)
def test_get_version(self): """Test the get_version function.""" c = Classic() v = version_registry.get_version(c) res = [(('Classic', '__main__'), 0)] self.assertEqual(v, res) state = state_pickler.get_state(c) self.assertEqual(state.__metadata__['version'], res) n = New() v = version_registry.get_version(n) res = [(('New', '__main__'), 0)] self.assertEqual(v, res) state = state_pickler.get_state(n) self.assertEqual(state.__metadata__['version'], res) t = TraitClass() v = version_registry.get_version(t) res = [(('HasTraits', 'traits.has_traits'), -1), (('TraitClass', '__main__'), 0)] self.assertEqual(v, res) state = state_pickler.get_state(t) self.assertEqual(state.__metadata__['version'], res)
def test_state_setter(self): """Test some of the features of the set_state method.""" t = TestClassic() self.set_object(t) # Get the saved state. res = state_pickler.get_state(t) # Now create a new instance and test the setter. t1 = state_pickler.create_instance(res) keys = [ "c", "b", "f", "i", "tuple", "list", "longi", "numeric", "n", "s", "u", "pure_list", "inst", "ref", "dict", ] ignore = list(keys) ignore.remove("b") first = ["b"] last = [] state_pickler.set_state(t1, res, ignore=ignore, first=first, last=last) # Only 'b' should have been set. self.assertTrue(t1.b) # Rest are unchanged. self.assertEqual(t1.i, 7) self.assertEqual(t1.s, "String") self.assertEqual(t1.u, "Unicode") self.assertEqual(t1.inst.a, "a") self.assertEqual(t1.list[0], 1) self.assertEqual(t1.tuple[-1].a, "a") self.assertEqual(t1.dict["a"], 1) # Check if last works. last = ignore ignore = [] first = [] state_pickler.set_state(t1, res, ignore=ignore, first=first, last=last) # Check everything. self.verify_unpickled(t1, res)
def test_has_instance(self): """Test to check has_instance correctness.""" a = A() r = state_pickler.get_state(a) self.assertTrue(r.__metadata__["has_instance"]) lst = [1, a] r = state_pickler.get_state(lst) self.assertTrue(r.has_instance) self.assertTrue(r[1].__metadata__["has_instance"]) d = {"a": lst, "b": 1} r = state_pickler.get_state(d) self.assertTrue(r.has_instance) self.assertTrue(r["a"].has_instance) self.assertTrue(r["a"][1].__metadata__["has_instance"]) class B: def __init__(self): self.a = [1, A()] b = B() r = state_pickler.get_state(b) self.assertTrue(r.__metadata__["has_instance"]) self.assertTrue(r.a.has_instance) self.assertTrue(r.a[1].__metadata__["has_instance"])
def __deepcopy__(self, memo): """Method used by copy.deepcopy(). This also uses the state_pickler to work correctly. """ # Create a new instance. new = self.__class__() # If we have a saved state, use it for the new instance. If # not, get our state and save that. saved_state = self._saved_state if len(saved_state) == 0: state = state_pickler.get_state(self) saved_state = cPickle.dumps(state) new._saved_state = saved_state # In the unlikely case that a new instance is running, load # the saved state. if new.running: new._load_saved_state() return new
def test_state_setter(self): """Test some of the features of the set_state method.""" t = TestClassic() self.set_object(t) # Get the saved state. res = state_pickler.get_state(t) # Now create a new instance and test the setter. t1 = state_pickler.create_instance(res) keys = [ 'c', 'b', 'f', 'i', 'tuple', 'list', 'l', 'numeric', 'n', 's', 'u', 'pure_list', 'inst', 'ref', 'dict' ] ignore = list(keys) ignore.remove('b') first = ['b'] last = [] state_pickler.set_state(t1, res, ignore=ignore, first=first, last=last) # Only 'b' should have been set. self.assertEqual(t1.b, True) # Rest are unchanged. self.assertEqual(t1.i, 7) self.assertEqual(t1.s, 'String') self.assertEqual(t1.u, u'Unicode') self.assertEqual(t1.inst.a, 'a') self.assertEqual(t1.list[0], 1) self.assertEqual(t1.tuple[-1].a, 'a') self.assertEqual(t1.dict['a'], 1) # Check if last works. last = ignore ignore = [] first = [] state_pickler.set_state(t1, res, ignore=ignore, first=first, last=last) # Check everything. self.verify_unpickled(t1, res)