s/unserialize/deserialize

IPython/html/base/zmqhandlers.py

@@ -58,8 +58,8 b' def serialize_binary_message(msg):'
     return b''.join(buffers)
 
 
-def unserialize_binary_message(bmsg):
-    """unserialize a message from a binary blog
+def deserialize_binary_message(bmsg):
+    """deserialize a message from a binary blog
 
     Header:
 
@@ -133,13 +133,13 b' class ZMQStreamHandler(websocket.WebSocketHandler):'
     def _reserialize_reply(self, msg_list):
         """Reserialize a reply message using JSON.
 
-        This takes the msg list from the ZMQ socket, unserializes it using
+        This takes the msg list from the ZMQ socket, deserializes it using
         self.session and then serializes the result using JSON. This method
         should be used by self._on_zmq_reply to build messages that can
         be sent back to the browser.
         """
         idents, msg_list = self.session.feed_identities(msg_list)
-        msg = self.session.unserialize(msg_list)
+        msg = self.session.deserialize(msg_list)
         try:
             msg['header'].pop('date')
         except KeyError:

IPython/html/services/kernels/handlers.py

@@ -110,7 +110,7 b' class ZMQChannelHandler(AuthenticatedZMQStreamHandler):'
         """
         idents,msg = self.session.feed_identities(msg)
         try:
-            msg = self.session.unserialize(msg)
+            msg = self.session.deserialize(msg)
         except:
             self.log.error("Bad kernel_info reply", exc_info=True)
             self._request_kernel_info()

IPython/html/static/services/kernels/js/kernel.js

@@ -846,8 +846,9 b' define(['
         }
     };
 
-    Kernel.prototype._unserialize_binary_message = function(blob, callback) {
-        // unserialize the binary message format
+
+    Kernel.prototype._deserialize_binary_message = function(blob, callback) {
+        // deserialize the binary message format
         // callback will be called with a message whose buffers attribute
         // will be an array of DataViews.
         var reader = new FileReader();
@@ -880,14 +881,14 b' define(['
     };
 
 
-    Kernel.prototype._unserialize_msg = function (e, callback) {
-        // unserialze a message and pass the unpacked message object to callback
+    Kernel.prototype._deserialize_msg = function (e, callback) {
+        // deserialze a message and pass the unpacked message object to callback
         if (typeof e.data === "string") {
             // text JSON message
             callback($.parseJSON(e.data));
         } else {
             // binary message
-            this._unserialize_binary_message(e.data, callback);
+            this._deserialize_binary_message(e.data, callback);
         }
     };
 
@@ -895,7 +896,7 b' define(['
      * @function _handle_shell_reply
      */
     Kernel.prototype._handle_shell_reply = function (e) {
-        this._unserialize_msg(e, $.proxy(this._finish_shell_reply, this));
+        this._deserialize_msg(e, $.proxy(this._finish_shell_reply, this));
     };
 
     Kernel.prototype._finish_shell_reply = function (reply) {
@@ -1026,7 +1027,7 b' define(['
      * @function _handle_iopub_message
      */
     Kernel.prototype._handle_iopub_message = function (e) {
-        this._unserialize_msg(e, $.proxy(this._finish_iopub_message, this));
+        this._deserialize_msg(e, $.proxy(this._finish_iopub_message, this));
     };
 
 
@@ -1041,7 +1042,7 b' define(['
      * @function _handle_input_request
      */
     Kernel.prototype._handle_input_request = function (e) {
-        this._unserialize_msg(e, $.proxy(this._finish_input_request, this));
+        this._deserialize_msg(e, $.proxy(this._finish_input_request, this));
     };
 
 

IPython/kernel/channels.py

@@ -176,7 +176,7 b' class ZMQSocketChannel(Thread):'
         Unpacks message, and calls handlers with it.
         """
         ident,smsg = self.session.feed_identities(msg)
-        msg = self.session.unserialize(smsg)
+        msg = self.session.deserialize(smsg)
         self.call_handlers(msg)
 
 

IPython/kernel/zmq/kernelbase.py

@@ -130,7 +130,7 b' class Kernel(SingletonConfigurable):'
         """dispatch control requests"""
         idents,msg = self.session.feed_identities(msg, copy=False)
         try:
-            msg = self.session.unserialize(msg, content=True, copy=False)
+            msg = self.session.deserialize(msg, content=True, copy=False)
         except:
             self.log.error("Invalid Control Message", exc_info=True)
             return
@@ -165,7 +165,7 b' class Kernel(SingletonConfigurable):'
         
         idents,msg = self.session.feed_identities(msg, copy=False)
         try:
-            msg = self.session.unserialize(msg, content=True, copy=False)
+            msg = self.session.deserialize(msg, content=True, copy=False)
         except:
             self.log.error("Invalid Message", exc_info=True)
             return

IPython/kernel/zmq/serialize.py

@@ -89,7 +89,7 b' def serialize_object(obj, buffer_threshold=MAX_BYTES, item_threshold=MAX_ITEMS):'
     buffers.insert(0, pickle.dumps(cobj, PICKLE_PROTOCOL))
     return buffers
 
-def unserialize_object(buffers, g=None):
+def deserialize_object(buffers, g=None):
     """reconstruct an object serialized by serialize_object from data buffers.
     
     Parameters
@@ -170,14 +170,14 b' def unpack_apply_message(bufs, g=None, copy=True):'
     
     args = []
     for i in range(info['nargs']):
-        arg, arg_bufs = unserialize_object(arg_bufs, g)
+        arg, arg_bufs = deserialize_object(arg_bufs, g)
         args.append(arg)
     args = tuple(args)
     assert not arg_bufs, "Shouldn't be any arg bufs left over"
     
     kwargs = {}
     for key in info['kw_keys']:
-        kwarg, kwarg_bufs = unserialize_object(kwarg_bufs, g)
+        kwarg, kwarg_bufs = deserialize_object(kwarg_bufs, g)
         kwargs[key] = kwarg
     assert not kwarg_bufs, "Shouldn't be any kwarg bufs left over"
     

IPython/kernel/zmq/session.py

@@ -18,6 +18,7 b' import os'
 import pprint
 import random
 import uuid
+import warnings
 from datetime import datetime
 
 try:
@@ -492,7 +493,7 b' class Session(Configurable):'
         """Return the nested message dict.
 
         This format is different from what is sent over the wire. The
-        serialize/unserialize methods converts this nested message dict to the wire
+        serialize/deserialize methods converts this nested message dict to the wire
         format, which is a list of message parts.
         """
         msg = {}
@@ -525,7 +526,7 b' class Session(Configurable):'
     def serialize(self, msg, ident=None):
         """Serialize the message components to bytes.
 
-        This is roughly the inverse of unserialize. The serialize/unserialize
+        This is roughly the inverse of deserialize. The serialize/deserialize
         methods work with full message lists, whereas pack/unpack work with
         the individual message parts in the message list.
 
@@ -590,7 +591,7 b' class Session(Configurable):'
         [ident1,ident2,...,DELIM,HMAC,p_header,p_parent,p_content,
          buffer1,buffer2,...]
 
-        The serialize/unserialize methods convert the nested message dict into this
+        The serialize/deserialize methods convert the nested message dict into this
         format.
 
         Parameters
@@ -722,7 +723,7 b' class Session(Configurable):'
         # invalid large messages can cause very expensive string comparisons
         idents, msg_list = self.feed_identities(msg_list, copy)
         try:
-            return idents, self.unserialize(msg_list, content=content, copy=copy)
+            return idents, self.deserialize(msg_list, content=content, copy=copy)
         except Exception as e:
             # TODO: handle it
             raise e
@@ -747,7 +748,7 b' class Session(Configurable):'
             idents will always be a list of bytes, each of which is a ZMQ
             identity. msg_list will be a list of bytes or zmq.Messages of the
             form [HMAC,p_header,p_parent,p_content,buffer1,buffer2,...] and
-            should be unpackable/unserializable via self.unserialize at this
+            should be unpackable/unserializable via self.deserialize at this
             point.
         """
         if copy:
@@ -788,10 +789,10 b' class Session(Configurable):'
         to_cull = random.sample(self.digest_history, n_to_cull)
         self.digest_history.difference_update(to_cull)
     
-    def unserialize(self, msg_list, content=True, copy=True):
+    def deserialize(self, msg_list, content=True, copy=True):
         """Unserialize a msg_list to a nested message dict.
 
-        This is roughly the inverse of serialize. The serialize/unserialize
+        This is roughly the inverse of serialize. The serialize/deserialize
         methods work with full message lists, whereas pack/unpack work with
         the individual message parts in the message list.
 
@@ -842,10 +843,16 b' class Session(Configurable):'
             message['content'] = msg_list[4]
 
         message['buffers'] = msg_list[5:]
-        # print("received: %s: %s\n    %s" % (message['msg_type'], message['header'], message['content']))
         # adapt to the current version
         return adapt(message)
-        # print("adapted: %s: %s\n     %s" % (adapted['msg_type'], adapted['header'], adapted['content']))
+    
+    def unserialize(self, *args, **kwargs):
+        warnings.warn(
+            "Session.unserialize is deprecated. Use Session.deserialize.",
+            DeprecationWarning,
+        )
+        return self.deserialize(*args, **kwargs)
+
 
 def test_msg2obj():
     am = dict(x=1)

IPython/kernel/zmq/tests/test_serialize.py

@@ -9,7 +9,7 b' from collections import namedtuple'
 import nose.tools as nt
 
 # from unittest import TestCaes
-from IPython.kernel.zmq.serialize import serialize_object, unserialize_object
+from IPython.kernel.zmq.serialize import serialize_object, deserialize_object
 from IPython.testing import decorators as dec
 from IPython.utils.pickleutil import CannedArray, CannedClass
 from IPython.utils.py3compat import iteritems
@@ -22,7 +22,7 b' from IPython.parallel import interactive'
 def roundtrip(obj):
     """roundtrip an object through serialization"""
     bufs = serialize_object(obj)
-    obj2, remainder = unserialize_object(bufs)
+    obj2, remainder = deserialize_object(bufs)
     nt.assert_equals(remainder, [])
     return obj2
 
@@ -70,7 +70,7 b' def test_roundtrip_buffered():'
     ]:
         bufs = serialize_object(obj)
         nt.assert_equal(len(bufs), 2)
-        obj2, remainder = unserialize_object(bufs)
+        obj2, remainder = deserialize_object(bufs)
         nt.assert_equal(remainder, [])
         nt.assert_equal(obj, obj2)
 
@@ -82,7 +82,7 b' def test_numpy():'
         for dtype in DTYPES:
             A = new_array(shape, dtype=dtype)
             bufs = serialize_object(A)
-            B, r = unserialize_object(bufs)
+            B, r = deserialize_object(bufs)
             nt.assert_equal(r, [])
             nt.assert_equal(A.shape, B.shape)
             nt.assert_equal(A.dtype, B.dtype)
@@ -100,7 +100,7 b' def test_recarray():'
             A = new_array(shape, dtype=dtype)
             
             bufs = serialize_object(A)
-            B, r = unserialize_object(bufs)
+            B, r = deserialize_object(bufs)
             nt.assert_equal(r, [])
             nt.assert_equal(A.shape, B.shape)
             nt.assert_equal(A.dtype, B.dtype)
@@ -116,7 +116,7 b' def test_numpy_in_seq():'
             bufs = serialize_object((A,1,2,b'hello'))
             canned = pickle.loads(bufs[0])
             nt.assert_is_instance(canned[0], CannedArray)
-            tup, r = unserialize_object(bufs)
+            tup, r = deserialize_object(bufs)
             B = tup[0]
             nt.assert_equal(r, [])
             nt.assert_equal(A.shape, B.shape)
@@ -133,7 +133,7 b' def test_numpy_in_dict():'
             bufs = serialize_object(dict(a=A,b=1,c=range(20)))
             canned = pickle.loads(bufs[0])
             nt.assert_is_instance(canned['a'], CannedArray)
-            d, r = unserialize_object(bufs)
+            d, r = deserialize_object(bufs)
             B = d['a']
             nt.assert_equal(r, [])
             nt.assert_equal(A.shape, B.shape)
@@ -147,7 +147,7 b' def test_class():'
     bufs = serialize_object(dict(C=C))
     canned = pickle.loads(bufs[0])
     nt.assert_is_instance(canned['C'], CannedClass)
-    d, r = unserialize_object(bufs)
+    d, r = deserialize_object(bufs)
     C2 = d['C']
     nt.assert_equal(C2.a, C.a)
 
@@ -159,7 +159,7 b' def test_class_oldstyle():'
     bufs = serialize_object(dict(C=C))
     canned = pickle.loads(bufs[0])
     nt.assert_is_instance(canned['C'], CannedClass)
-    d, r = unserialize_object(bufs)
+    d, r = deserialize_object(bufs)
     C2 = d['C']
     nt.assert_equal(C2.a, C.a)
 
@@ -168,7 +168,7 b' def test_tuple():'
     bufs = serialize_object(tup)
     canned = pickle.loads(bufs[0])
     nt.assert_is_instance(canned, tuple)
-    t2, r = unserialize_object(bufs)
+    t2, r = deserialize_object(bufs)
     nt.assert_equal(t2[0](t2[1]), tup[0](tup[1]))
 
 point = namedtuple('point', 'x y')
@@ -178,7 +178,7 b' def test_namedtuple():'
     bufs = serialize_object(p)
     canned = pickle.loads(bufs[0])
     nt.assert_is_instance(canned, point)
-    p2, r = unserialize_object(bufs, globals())
+    p2, r = deserialize_object(bufs, globals())
     nt.assert_equal(p2.x, p.x)
     nt.assert_equal(p2.y, p.y)
 
@@ -187,7 +187,7 b' def test_list():'
     bufs = serialize_object(lis)
     canned = pickle.loads(bufs[0])
     nt.assert_is_instance(canned, list)
-    l2, r = unserialize_object(bufs)
+    l2, r = deserialize_object(bufs)
     nt.assert_equal(l2[0](l2[1]), lis[0](lis[1]))
 
 def test_class_inheritance():
@@ -202,7 +202,7 b' def test_class_inheritance():'
     bufs = serialize_object(dict(D=D))
     canned = pickle.loads(bufs[0])
     nt.assert_is_instance(canned['D'], CannedClass)
-    d, r = unserialize_object(bufs)
+    d, r = deserialize_object(bufs)
     D2 = d['D']
     nt.assert_equal(D2.a, D.a)
     nt.assert_equal(D2.b, D.b)

IPython/kernel/zmq/tests/test_session.py

@@ -60,7 +60,7 b' class TestSession(SessionTestCase):'
         msg = self.session.msg('execute', content=dict(a=10, b=1.1))
         msg_list = self.session.serialize(msg, ident=b'foo')
         ident, msg_list = self.session.feed_identities(msg_list)
-        new_msg = self.session.unserialize(msg_list)
+        new_msg = self.session.deserialize(msg_list)
         self.assertEqual(ident[0], b'foo')
         self.assertEqual(new_msg['msg_id'],msg['msg_id'])
         self.assertEqual(new_msg['msg_type'],msg['msg_type'])
@@ -82,7 +82,7 b' class TestSession(SessionTestCase):'
         self.session.send(A, msg, ident=b'foo', buffers=[b'bar'])
         
         ident, msg_list = self.session.feed_identities(B.recv_multipart())
-        new_msg = self.session.unserialize(msg_list)
+        new_msg = self.session.deserialize(msg_list)
         self.assertEqual(ident[0], b'foo')
         self.assertEqual(new_msg['msg_id'],msg['msg_id'])
         self.assertEqual(new_msg['msg_type'],msg['msg_type'])
@@ -100,7 +100,7 b' class TestSession(SessionTestCase):'
         self.session.send(A, None, content=content, parent=parent,
             header=header, metadata=metadata, ident=b'foo', buffers=[b'bar'])
         ident, msg_list = self.session.feed_identities(B.recv_multipart())
-        new_msg = self.session.unserialize(msg_list)
+        new_msg = self.session.deserialize(msg_list)
         self.assertEqual(ident[0], b'foo')
         self.assertEqual(new_msg['msg_id'],msg['msg_id'])
         self.assertEqual(new_msg['msg_type'],msg['msg_type'])
@@ -263,7 +263,7 b' class TestSession(SessionTestCase):'
         p = session.msg('msg')
         msg = session.msg('msg', content=content, metadata=metadata, parent=p['header'])
         smsg = session.serialize(msg)
-        msg2 = session.unserialize(session.feed_identities(smsg)[1])
+        msg2 = session.deserialize(session.feed_identities(smsg)[1])
         assert isinstance(msg2['header']['date'], datetime)
         self.assertEqual(msg['header'], msg2['header'])
         self.assertEqual(msg['parent_header'], msg2['parent_header'])
@@ -305,7 +305,7 b' class TestSession(SessionTestCase):'
         self.session.send_raw(A, msg_list, ident=b'foo')
         
         ident, new_msg_list = self.session.feed_identities(B.recv_multipart())
-        new_msg = self.session.unserialize(new_msg_list)
+        new_msg = self.session.deserialize(new_msg_list)
         self.assertEqual(ident[0], b'foo')
         self.assertEqual(new_msg['msg_type'],msg['msg_type'])
         self.assertEqual(new_msg['header'],msg['header'])

IPython/parallel/client/client.py

@@ -782,7 +782,7 b' class Client(HasTraits):'
 
         # construct result:
         if content['status'] == 'ok':
-            self.results[msg_id] = serialize.unserialize_object(msg['buffers'])[0]
+            self.results[msg_id] = serialize.deserialize_object(msg['buffers'])[0]
         elif content['status'] == 'aborted':
             self.results[msg_id] = error.TaskAborted(msg_id)
         elif content['status'] == 'resubmitted':
@@ -884,7 +884,7 b' class Client(HasTraits):'
             elif msg_type == 'execute_result':
                 md['execute_result'] = content
             elif msg_type == 'data_message':
-                data, remainder = serialize.unserialize_object(msg['buffers'])
+                data, remainder = serialize.deserialize_object(msg['buffers'])
                 md['data'].update(data)
             elif msg_type == 'status':
                 # idle message comes after all outputs
@@ -1593,7 +1593,7 b' class Client(HasTraits):'
                 
                 if rcontent['status'] == 'ok':
                     if header['msg_type'] == 'apply_reply':
-                        res,buffers = serialize.unserialize_object(buffers)
+                        res,buffers = serialize.deserialize_object(buffers)
                     elif header['msg_type'] == 'execute_reply':
                         res = ExecuteReply(msg_id, rcontent, md)
                     else:

IPython/parallel/controller/hub.py

@@ -523,7 +523,7 b' class Hub(SessionFactory):'
             return
         client_id = idents[0]
         try:
-            msg = self.session.unserialize(msg, content=True)
+            msg = self.session.deserialize(msg, content=True)
         except Exception:
             content = error.wrap_exception()
             self.log.error("Bad Query Message: %r", msg, exc_info=True)
@@ -588,7 +588,7 b' class Hub(SessionFactory):'
             return
         queue_id, client_id = idents[:2]
         try:
-            msg = self.session.unserialize(msg)
+            msg = self.session.deserialize(msg)
         except Exception:
             self.log.error("queue::client %r sent invalid message to %r: %r", client_id, queue_id, msg, exc_info=True)
             return
@@ -636,7 +636,7 b' class Hub(SessionFactory):'
 
         client_id, queue_id = idents[:2]
         try:
-            msg = self.session.unserialize(msg)
+            msg = self.session.deserialize(msg)
         except Exception:
             self.log.error("queue::engine %r sent invalid message to %r: %r",
                     queue_id, client_id, msg, exc_info=True)
@@ -690,7 +690,7 b' class Hub(SessionFactory):'
         client_id = idents[0]
 
         try:
-            msg = self.session.unserialize(msg)
+            msg = self.session.deserialize(msg)
         except Exception:
             self.log.error("task::client %r sent invalid task message: %r",
                     client_id, msg, exc_info=True)
@@ -740,7 +740,7 b' class Hub(SessionFactory):'
         """save the result of a completed task."""
         client_id = idents[0]
         try:
-            msg = self.session.unserialize(msg)
+            msg = self.session.deserialize(msg)
         except Exception:
             self.log.error("task::invalid task result message send to %r: %r",
                     client_id, msg, exc_info=True)
@@ -794,7 +794,7 b' class Hub(SessionFactory):'
 
     def save_task_destination(self, idents, msg):
         try:
-            msg = self.session.unserialize(msg, content=True)
+            msg = self.session.deserialize(msg, content=True)
         except Exception:
             self.log.error("task::invalid task tracking message", exc_info=True)
             return
@@ -831,7 +831,7 b' class Hub(SessionFactory):'
         """save an iopub message into the db"""
         # print (topics)
         try:
-            msg = self.session.unserialize(msg, content=True)
+            msg = self.session.deserialize(msg, content=True)
         except Exception:
             self.log.error("iopub::invalid IOPub message", exc_info=True)
             return

IPython/parallel/controller/scheduler.py

@@ -251,7 +251,7 b' class TaskScheduler(SessionFactory):'
             self.log.warn("task::Invalid Message: %r",msg)
             return
         try:
-            msg = self.session.unserialize(msg)
+            msg = self.session.deserialize(msg)
         except ValueError:
             self.log.warn("task::Unauthorized message from: %r"%idents)
             return
@@ -270,7 +270,7 b' class TaskScheduler(SessionFactory):'
             self.log.warn("task::Invalid Message: %r",msg)
             return
         try:
-            msg = self.session.unserialize(msg)
+            msg = self.session.deserialize(msg)
         except ValueError:
             self.log.warn("task::Unauthorized message from: %r"%idents)
             return
@@ -375,7 +375,7 b' class TaskScheduler(SessionFactory):'
         self.notifier_stream.flush()
         try:
             idents, msg = self.session.feed_identities(raw_msg, copy=False)
-            msg = self.session.unserialize(msg, content=False, copy=False)
+            msg = self.session.deserialize(msg, content=False, copy=False)
         except Exception:
             self.log.error("task::Invaid task msg: %r"%raw_msg, exc_info=True)
             return
@@ -621,7 +621,7 b' class TaskScheduler(SessionFactory):'
         """dispatch method for result replies"""
         try:
             idents,msg = self.session.feed_identities(raw_msg, copy=False)
-            msg = self.session.unserialize(msg, content=False, copy=False)
+            msg = self.session.deserialize(msg, content=False, copy=False)
             engine = idents[0]
             try:
                 idx = self.targets.index(engine)

IPython/parallel/engine/engine.py

@@ -159,7 +159,7 b' class EngineFactory(RegistrationFactory):'
         loop = self.loop
         identity = self.bident
         idents,msg = self.session.feed_identities(msg)
-        msg = self.session.unserialize(msg)
+        msg = self.session.deserialize(msg)
         content = msg['content']
         info = self.connection_info