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_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_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 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 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 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 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 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_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_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.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 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 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 __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 __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)
