def test_tuple():
tup = (lambda x: x, 1)
bufs = serialize_object(tup)
canned = pickle.loads(bufs[0])
nt.assert_is_instance(canned, tuple)
t2, r = deserialize_object(bufs)
nt.assert_equal(t2[0](t2[1]), tup[0](tup[1]))
def test_list():
lis = [lambda x:x, 1]
bufs = serialize_object(lis)
canned = pickle.loads(bufs[0])
nt.assert_is_instance(canned, list)
l2, r = deserialize_object(bufs)
nt.assert_equal(l2[0](l2[1]), lis[0](lis[1]))
def set_value(self, name, value):
"""Set the value of a variable"""
ns = self._get_reference_namespace(name)
value = deserialize_object(value)[0]
if isinstance(value, CannedObject):
value = value.get_object()
ns[name] = value
def test_list():
lis = [lambda x: x, 1]
bufs = serialize_object(lis)
canned = pickle.loads(bufs[0])
nt.assert_is_instance(canned, list)
l2, r = deserialize_object(bufs)
nt.assert_equal(l2[0](l2[1]), lis[0](lis[1]))
def set_value(self, name, value):
"""Set the value of a variable"""
ns = self._get_reference_namespace(name)
value = deserialize_object(value)[0]
if isinstance(value, CannedObject):
value = value.get_object()
ns[name] = value
def test_list():
lis = [lambda x: x, 1]
bufs = serialize_object(lis)
canned = pickle.loads(bufs[0])
assert isinstance(canned, list)
l2, r = deserialize_object(bufs)
assert l2[0](l2[1]) == lis[0](lis[1])
def test_tuple():
tup = (lambda x:x, 1)
bufs = serialize_object(tup)
canned = pickle.loads(bufs[0])
nt.assert_is_instance(canned, tuple)
t2, r = deserialize_object(bufs)
nt.assert_equal(t2[0](t2[1]), tup[0](tup[1]))
def test_tuple():
tup = (lambda x: x, 1)
bufs = serialize_object(tup)
canned = pickle.loads(bufs[0])
assert isinstance(canned, tuple)
t2, r = deserialize_object(bufs)
assert t2[0](t2[1]) == tup[0](tup[1])
def _handle_data_message(self, msg):
"""
Handle raw (serialized) data sent by the kernel
We only handle data asked by Spyder, in case people use
publish_data for other purposes.
"""
# Deserialize data
try:
data = deserialize_object(msg['buffers'])[0]
except Exception as msg:
self._kernel_value = None
self._kernel_reply = repr(msg)
self.sig_got_reply.emit()
return
# Receive values asked for Spyder
value = data.get('__spy_data__', None)
if value is not None:
if isinstance(value, CannedObject):
value = value.get_object()
self._kernel_value = value
self.sig_got_reply.emit()
return
# Receive Pdb state and dispatch it
pdb_state = data.get('__spy_pdb_state__', None)
if pdb_state is not None and isinstance(pdb_state, dict):
self.refresh_from_pdb(pdb_state)
# Run Pdb continue to get to the first breakpoint
# Fixes 2034
pdb_continue = data.get('__spy_pdb_continue__', None)
if pdb_continue:
self.write_to_stdin('continue')
def test_list():
lis = [lambda x:x, 1]
bufs = serialize_object(lis)
canned = pickle.loads(bufs[0])
assert isinstance(canned, list)
l2, r = deserialize_object(bufs)
assert l2[0](l2[1]) == lis[0](lis[1])
def test_tuple():
tup = (lambda x:x, 1)
bufs = serialize_object(tup)
canned = pickle.loads(bufs[0])
assert isinstance(canned, tuple)
t2, r = deserialize_object(bufs)
assert t2[0](t2[1]) == tup[0](tup[1])
def test_namedtuple():
p = point(1,2)
bufs = serialize_object(p)
canned = pickle.loads(bufs[0])
assert isinstance(canned, point)
p2, r = deserialize_object(bufs, globals())
assert p2.x == p.x
assert p2.y == p.y
def test_namedtuple():
p = point(1,2)
bufs = serialize_object(p)
canned = pickle.loads(bufs[0])
nt.assert_is_instance(canned, point)
p2, r = deserialize_object(bufs, globals())
nt.assert_equal(p2.x, p.x)
nt.assert_equal(p2.y, p.y)
def test_roundtrip_memoryview():
b = b'asdf' * 1025
view = memoryview(b)
bufs = serialize_object(view)
nt.assert_equal(len(bufs), 2)
v2, remainder = deserialize_object(bufs)
nt.assert_equal(remainder, [])
nt.assert_equal(v2.tobytes(), b)
def test_roundtrip_memoryview():
b = b'asdf' * 1025
view = memoryview(b)
bufs = serialize_object(view)
assert len(bufs) == 2
v2, remainder = deserialize_object(bufs)
assert remainder == []
assert v2.tobytes() == b
def test_roundtrip_memoryview():
b = b'asdf' * 1025
view = memoryview(b)
bufs = serialize_object(view)
nt.assert_equal(len(bufs), 2)
v2, remainder = deserialize_object(bufs)
nt.assert_equal(remainder, [])
nt.assert_equal(v2.tobytes(), b)
def test_namedtuple():
p = point(1, 2)
bufs = serialize_object(p)
canned = pickle.loads(bufs[0])
assert isinstance(canned, point)
p2, r = deserialize_object(bufs, globals())
assert p2.x == p.x
assert p2.y == p.y
def test_namedtuple():
p = point(1, 2)
bufs = serialize_object(p)
canned = pickle.loads(bufs[0])
nt.assert_is_instance(canned, point)
p2, r = deserialize_object(bufs, globals())
nt.assert_equal(p2.x, p.x)
nt.assert_equal(p2.y, p.y)
def test_roundtrip_memoryview():
b = b'asdf' * 1025
view = memoryview(b)
bufs = serialize_object(view)
assert len(bufs) == 2
v2, remainder = deserialize_object(bufs)
assert remainder == []
assert v2.tobytes() == b
def test_roundtrip_buffered():
for obj in [
dict(a=b"x" * 1025), b"hello" * 500, [b"hello" * 501, 1, 2, 3]
]:
bufs = serialize_object(obj)
nt.assert_equal(len(bufs), 2)
obj2, remainder = deserialize_object(bufs)
nt.assert_equal(remainder, [])
nt.assert_equal(obj, obj2)
def test_roundtrip_buffered():
for obj in [
dict(a=b"x" * 1025), b"hello" * 500, [b"hello" * 501, 1, 2, 3]
]:
bufs = serialize_object(obj)
assert len(bufs) == 2
obj2, remainder = deserialize_object(bufs)
assert remainder == []
assert obj == obj2
def test_class():
@interactive
class C(object):
a=5
bufs = serialize_object(dict(C=C))
canned = pickle.loads(bufs[0])
nt.assert_is_instance(canned['C'], CannedClass)
d, r = deserialize_object(bufs)
C2 = d['C']
nt.assert_equal(C2.a, C.a)
def test_class():
@interactive
class C(object):
a=5
bufs = serialize_object(dict(C=C))
canned = pickle.loads(bufs[0])
assert isinstance(canned['C'], CannedClass)
d, r = deserialize_object(bufs)
C2 = d['C']
assert C2.a == C.a
def test_class_oldstyle():
@interactive
class C:
a = 5
bufs = serialize_object(dict(C=C))
canned = pickle.loads(bufs[0])
nt.assert_is_instance(canned['C'], CannedClass)
d, r = deserialize_object(bufs)
C2 = d['C']
nt.assert_equal(C2.a, C.a)
def test_roundtrip_buffered():
for obj in [
dict(a=b"x"*1025),
b"hello"*500,
[b"hello"*501, 1,2,3]
]:
bufs = serialize_object(obj)
nt.assert_equal(len(bufs), 2)
obj2, remainder = deserialize_object(bufs)
nt.assert_equal(remainder, [])
nt.assert_equal(obj, obj2)
def test_class_oldstyle():
@interactive
class C:
a = 5
bufs = serialize_object(dict(C=C))
canned = pickle.loads(bufs[0])
assert isinstance(canned['C'], CannedClass)
d, r = deserialize_object(bufs)
C2 = d['C']
assert C2.a == C.a
def test_roundtrip_buffered():
for obj in [
dict(a=b"x"*1025),
b"hello"*500,
[b"hello"*501, 1,2,3]
]:
bufs = serialize_object(obj)
assert len(bufs) == 2
obj2, remainder = deserialize_object(bufs)
assert remainder == []
assert obj == obj2
def test_numpy():
import numpy
from numpy.testing.utils import assert_array_equal
for shape in SHAPES:
for dtype in DTYPES:
A = new_array(shape, dtype=dtype)
bufs = serialize_object(A)
bufs = [memoryview(b) for b in bufs]
B, r = deserialize_object(bufs)
assert r == []
assert A.shape == B.shape
assert A.dtype == B.dtype
assert_array_equal(A,B)
def test_numpy():
import numpy
from numpy.testing.utils import assert_array_equal
for shape in SHAPES:
for dtype in DTYPES:
A = new_array(shape, dtype=dtype)
bufs = serialize_object(A)
bufs = [memoryview(b) for b in bufs]
B, r = deserialize_object(bufs)
assert r == []
assert A.shape == B.shape
assert A.dtype == B.dtype
assert_array_equal(A, B)
def test_numpy_in_dict():
import numpy
from numpy.testing.utils import assert_array_equal
for shape in SHAPES:
for dtype in DTYPES:
A = new_array(shape, dtype=dtype)
bufs = serialize_object(dict(a=A,b=1,c=range(20)))
canned = pickle.loads(bufs[0])
assert isinstance(canned['a'], CannedArray)
d, r = deserialize_object(bufs)
B = d['a']
assert r == []
assert A.shape == B.shape
assert A.dtype == B.dtype
assert_array_equal(A,B)
def test_numpy_in_seq():
import numpy
from numpy.testing.utils import assert_array_equal
for shape in SHAPES:
for dtype in DTYPES:
A = new_array(shape, dtype=dtype)
bufs = serialize_object((A,1,2,b'hello'))
canned = pickle.loads(bufs[0])
assert isinstance(canned[0], CannedArray)
tup, r = deserialize_object(bufs)
B = tup[0]
assert r == []
assert A.shape == B.shape
assert A.dtype == B.dtype
assert_array_equal(A,B)
def test_numpy_in_seq():
import numpy
from numpy.testing.utils import assert_array_equal
for shape in SHAPES:
for dtype in DTYPES:
A = new_array(shape, dtype=dtype)
bufs = serialize_object((A, 1, 2, b'hello'))
canned = pickle.loads(bufs[0])
assert isinstance(canned[0], CannedArray)
tup, r = deserialize_object(bufs)
B = tup[0]
assert r == []
assert A.shape == B.shape
assert A.dtype == B.dtype
assert_array_equal(A, B)
def test_numpy_in_dict():
import numpy
from numpy.testing.utils import assert_array_equal
for shape in SHAPES:
for dtype in DTYPES:
A = new_array(shape, dtype=dtype)
bufs = serialize_object(dict(a=A, b=1, c=range(20)))
canned = pickle.loads(bufs[0])
assert isinstance(canned['a'], CannedArray)
d, r = deserialize_object(bufs)
B = d['a']
assert r == []
assert A.shape == B.shape
assert A.dtype == B.dtype
assert_array_equal(A, B)
def test_recarray():
import numpy
from numpy.testing.utils import assert_array_equal
for shape in SHAPES:
for dtype in [
[('f', float), ('s', '|S10')],
[('n', int), ('s', '|S1'), ('u', 'uint32')],
]:
A = new_array(shape, dtype=dtype)
bufs = serialize_object(A)
B, r = deserialize_object(bufs)
assert r == []
assert A.shape == B.shape
assert A.dtype == B.dtype
assert_array_equal(A, B)
def test_recarray():
import numpy
from numpy.testing.utils import assert_array_equal
for shape in SHAPES:
for dtype in [
[('f', float), ('s', '|S10')],
[('n', int), ('s', '|S1'), ('u', 'uint32')],
]:
A = new_array(shape, dtype=dtype)
bufs = serialize_object(A)
B, r = deserialize_object(bufs)
assert r == []
assert A.shape == B.shape
assert A.dtype == B.dtype
assert_array_equal(A,B)
def test_class_inheritance():
@interactive
class C(object):
a = 5
@interactive
class D(C):
b = 10
bufs = serialize_object(dict(D=D))
canned = pickle.loads(bufs[0])
assert isinstance(canned['D'], CannedClass)
d, r = deserialize_object(bufs)
D2 = d['D']
assert D2.a == D.a
assert D2.b == D.b
def test_class_inheritance():
@interactive
class C(object):
a=5
@interactive
class D(C):
b=10
bufs = serialize_object(dict(D=D))
canned = pickle.loads(bufs[0])
assert isinstance(canned['D'], CannedClass)
d, r = deserialize_object(bufs)
D2 = d['D']
assert D2.a == D.a
assert D2.b == D.b
def test_class_inheritance():
@interactive
class C(object):
a = 5
@interactive
class D(C):
b = 10
bufs = serialize_object(dict(D=D))
canned = pickle.loads(bufs[0])
nt.assert_is_instance(canned['D'], CannedClass)
d, r = deserialize_object(bufs)
D2 = d['D']
nt.assert_equal(D2.a, D.a)
nt.assert_equal(D2.b, D.b)
def test_class_inheritance():
@interactive
class C(object):
a=5
@interactive
class D(C):
b=10
bufs = serialize_object(dict(D=D))
canned = pickle.loads(bufs[0])
nt.assert_is_instance(canned['D'], CannedClass)
d, r = deserialize_object(bufs)
D2 = d['D']
nt.assert_equal(D2.a, D.a)
nt.assert_equal(D2.b, D.b)
def _handle_data_message(self, msg):
"""
Handle raw (serialized) data sent by the kernel
We only handle data asked by TRex, in case people use
publish_data for other purposes.
"""
# Deserialize data
try:
data = deserialize_object(msg['buffers'])[0]
except Exception as msg:
self._kernel_value = None
self._kernel_reply = repr(msg)
self.sig_got_reply.emit()
return
# We only handle data asked by TRex
value = data.get('__spy_data__', None)
if value is not None:
if isinstance(value, CannedObject):
value = value.get_object()
self._kernel_value = value
self.sig_got_reply.emit()
def _handle_data_message(self, msg):
"""
Handle raw (serialized) data sent by the kernel
We only handle data asked by Spyder, in case people use
publish_data for other purposes.
"""
# Deserialize data
try:
data = deserialize_object(msg['buffers'])[0]
except Exception as msg:
self._kernel_value = None
self._kernel_reply = repr(msg)
self.sig_got_reply.emit()
return
# We only handle data asked by Spyder
value = data.get('__spy_data__', None)
if value is not None:
if isinstance(value, CannedObject):
value = value.get_object()
self._kernel_value = value
self.sig_got_reply.emit()
def roundtrip(obj):
"""roundtrip an object through serialization"""
bufs = serialize_object(obj)
obj2, remainder = deserialize_object(bufs)
assert remainder == []
return obj2
def roundtrip(obj):
"""roundtrip an object through serialization"""
bufs = serialize_object(obj)
obj2, remainder = deserialize_object(bufs)
nt.assert_equals(remainder, [])
return obj2
def roundtrip(obj):
"""roundtrip an object through serialization"""
bufs = serialize_object(obj)
obj2, remainder = deserialize_object(bufs)
assert remainder == []
return obj2
def roundtrip(obj):
"""roundtrip an object through serialization"""
bufs = serialize_object(obj)
obj2, remainder = deserialize_object(bufs)
nt.assert_equals(remainder, [])
return obj2
