Upgrade to xeus 2.0.0

Author: JohanMabille

.appveyor.yml

@@ -27,7 +27,7 @@ install:
   - conda update -q conda
   - conda info -a
   # Host dependencies
-  - conda install xeus=1.0.3 nlohmann_json cppzmq xtl "pybind11>=2.6.1,<3.0" "pybind11_json>=0.2.6,<0.3" gtest=1.8.0 debugpy "xeus-python-shell>=0.1.5,<2" "jupyter_client<=6.2" -c conda-forge
+  - conda install xeus=2.0.0 nlohmann_json cppzmq xtl pybind11=2.6.0 pybind11_json=0.2.8 gtest=1.8.0 debugpy "xeus-python-shell>=0.1.5,<2" "jupyter_client<=6.2" -c conda-forge
   # Build dependencies
   - conda install cmake -c conda-forge
   # Build and install xeus-python

environment-dev.yml

@@ -5,7 +5,7 @@ dependencies:
   # Build dependencies
   - cmake
   # Host dependencies
-  - xeus=1.0.3
+  - xeus=2.0.0
   - nlohmann_json
   - cppzmq
   - xtl>=0.7, <0.8

include/xeus-python/xdebugger.hpp

@@ -17,6 +17,7 @@
 
 #include "zmq.hpp"
 #include "nlohmann/json.hpp"
+#include "xeus/xeus_context.hpp"
 #include "xeus/xdebugger_base.hpp"
 #include "xeus_python_config.hpp"
 
@@ -61,7 +62,7 @@ namespace xpyt
     };
 
     XEUS_PYTHON_API
-    std::unique_ptr<xeus::xdebugger> make_python_debugger(zmq::context_t& context,
+    std::unique_ptr<xeus::xdebugger> make_python_debugger(xeus::xcontext& context,
                                                           const xeus::xconfiguration& config,
                                                           const std::string& user_name,
                                                           const std::string& session_id,

src/main.cpp

@@ -21,9 +21,10 @@
 #include <unistd.h>
 #endif
 
+#include "xeus/xeus_context.hpp"
 #include "xeus/xkernel.hpp"
 #include "xeus/xkernel_configuration.hpp"
-#include "xeus/xserver.hpp"
+#include "xeus/xserver_shell_main.hpp"
 
 #include "pybind11/embed.h"
 #include "pybind11/pybind11.h"
@@ -155,6 +156,10 @@ int main(int argc, char* argv[])
     }
     delete[] argw;
 
+    using context_type = xeus::xcontext_impl<zmq::context_t>;
+    using context_ptr = std::unique_ptr<context_type>;
+    context_ptr context = context_ptr(new context_type());
+
     // Instantiating the xeus xinterpreter
     using interpreter_ptr = std::unique_ptr<xpyt::interpreter>;
     interpreter_ptr interpreter = interpreter_ptr(new xpyt::interpreter());
@@ -180,11 +185,12 @@ int main(int argc, char* argv[])
 
         xeus::xkernel kernel(config,
                              xeus::get_user_name(),
+                             std::move(context),
                              std::move(interpreter),
+                             xeus::make_xserver_shell_main,
                              std::move(hist),
                              xeus::make_console_logger(xeus::xlogger::msg_type,
                                                        xeus::make_file_logger(xeus::xlogger::content, "xeus.log")),
-                             xeus::make_xserver_shell_main,
                              xpyt::make_python_debugger,
                              debugger_config);
 
@@ -199,10 +205,11 @@ int main(int argc, char* argv[])
     else
     {
         xeus::xkernel kernel(xeus::get_user_name(),
+                             std::move(context),
                              std::move(interpreter),
+                             xeus::make_xserver_shell_main,
                              std::move(hist),
                              nullptr,
-                             xeus::make_xserver_shell_main,
                              xpyt::make_python_debugger,
                              debugger_config);
 

src/xcomm.cpp

@@ -42,7 +42,7 @@ namespace xpyt
 
         using python_callback_type = std::function<void(py::object)>;
         using cpp_callback_type = std::function<void(const xeus::xmessage&)>;
-        using zmq_buffers_type = std::vector<zmq::message_t>;
+        using buffers_sequence = xeus::buffer_sequence;
 
         xcomm(const py::args& args, const py::kwargs& kwargs);
         xcomm(xeus::xcomm&& comm);
@@ -83,7 +83,7 @@ namespace xpyt
         m_comm.open(
             kwargs.attr("get")("metadata", py::dict()),
             kwargs.attr("get")("data", py::dict()),
-            pylist_to_zmq_buffers(kwargs.attr("get")("buffers", py::list()))
+            pylist_to_cpp_buffers(kwargs.attr("get")("buffers", py::list()))
         );
     }
 
@@ -111,7 +111,7 @@ namespace xpyt
         m_comm.close(
             kwargs.attr("get")("metadata", py::dict()),
             kwargs.attr("get")("data", py::dict()),
-            pylist_to_zmq_buffers(kwargs.attr("get")("buffers", py::list()))
+            pylist_to_cpp_buffers(kwargs.attr("get")("buffers", py::list()))
         );
     }
 
@@ -120,7 +120,7 @@ namespace xpyt
         m_comm.send(
             kwargs.attr("get")("metadata", py::dict()),
             kwargs.attr("get")("data", py::dict()),
-            pylist_to_zmq_buffers(kwargs.attr("get")("buffers", py::list()))
+            pylist_to_cpp_buffers(kwargs.attr("get")("buffers", py::list()))
         );
     }
 

src/xdebugger.cpp

@@ -348,12 +348,13 @@ namespace xpyt
         return get_cell_tmp_file(code);
     }
 
-    std::unique_ptr<xeus::xdebugger> make_python_debugger(zmq::context_t& context,
+    std::unique_ptr<xeus::xdebugger> make_python_debugger(xeus::xcontext& context,
                                                           const xeus::xconfiguration& config,
                                                           const std::string& user_name,
                                                           const std::string& session_id,
                                                           const nl::json& debugger_config)
     {
-        return std::unique_ptr<xeus::xdebugger>(new debugger(context, config, user_name, session_id, debugger_config));
+        return std::unique_ptr<xeus::xdebugger>(new debugger(context.get_wrapped_context<zmq::context_t>(),
+                                                             config, user_name, session_id, debugger_config));
     }
 }

src/xinternal_utils.cpp

@@ -37,28 +37,28 @@ namespace xpyt
         return py::module_::create_extension_module(module_name.c_str(), nullptr, new py::module_::module_def);
     }
 
-    zmq::message_t pybytes_to_zmq_message(py::bytes bytes)
+    xeus::binary_buffer pybytes_to_cpp_message(py::bytes bytes)
     {
         char* buffer;
         Py_ssize_t length;
         PyBytes_AsStringAndSize(bytes.ptr(), &buffer, &length);
-        return zmq::message_t(buffer, static_cast<std::size_t>(length));
+        return xeus::binary_buffer(buffer, buffer + static_cast<std::size_t>(length));
     }
 
-    py::list zmq_buffers_to_pylist(const std::vector<zmq::message_t>& buffers)
+    py::list cpp_buffers_to_pylist(const xeus::buffer_sequence& buffers)
     {
         py::list bufferlist;
-        for (const zmq::message_t& buffer : buffers)
+        for (const xeus::binary_buffer& buffer : buffers)
         {
-            const char* buf = buffer.data<const char>();
+            const char* buf = buffer.data();
             bufferlist.attr("append")(py::memoryview(py::bytes(buf)));
         }
         return bufferlist;
     }
 
-    std::vector<zmq::message_t> pylist_to_zmq_buffers(const py::object& bufferlist)
+    xeus::buffer_sequence pylist_to_cpp_buffers(const py::object& bufferlist)
     {
-        std::vector<zmq::message_t> buffers;
+        xeus::buffer_sequence buffers;
 
         // Cannot iterate over NoneType, returning immediately with an empty vector
         if (bufferlist.is_none())
@@ -71,11 +71,11 @@ namespace xpyt
             if (py::isinstance<py::memoryview>(buffer))
             {
                 py::bytes bytes = buffer.attr("tobytes")();
-                buffers.push_back(pybytes_to_zmq_message(bytes));
+                buffers.push_back(pybytes_to_cpp_message(bytes));
             }
             else
             {
-                buffers.push_back(pybytes_to_zmq_message(buffer.cast<py::bytes>()));
+                buffers.push_back(pybytes_to_cpp_message(buffer.cast<py::bytes>()));
             }
         }
         return buffers;
@@ -88,7 +88,7 @@ namespace xpyt
         py_msg["parent_header"] = msg.parent_header().get<py::object>();
         py_msg["metadata"] = msg.metadata().get<py::object>();
         py_msg["content"] = msg.content().get<py::object>();
-        py_msg["buffers"] = zmq_buffers_to_pylist(msg.buffers());
+        py_msg["buffers"] = cpp_buffers_to_pylist(msg.buffers());
 
         return py_msg;
     }

src/xinternal_utils.hpp

@@ -25,8 +25,8 @@ namespace xpyt
 {
     py::module create_module(const std::string& module_name);
 
-    py::list zmq_buffers_to_pylist(const std::vector<zmq::message_t>& buffers);
-    std::vector<zmq::message_t> pylist_to_zmq_buffers(const py::object& bufferlist);
+    py::list cpp_buffers_to_pylist(const xeus::buffer_sequence& buffers);
+    xeus::buffer_sequence pylist_to_cpp_buffers(const py::object& bufferlist);
 
     py::object cppmessage_to_pymessage(const xeus::xmessage& msg);
 

src/xpython_extension.cpp

@@ -13,9 +13,10 @@
 #include <string>
 #include <utility>
 
+#include "xeus/xeus_context.hpp"
 #include "xeus/xkernel.hpp"
 #include "xeus/xkernel_configuration.hpp"
-#include "xeus/xserver.hpp"
+#include "xeus/xserver_shell_main.hpp"
 
 #include "pybind11/pybind11.h"
 
@@ -26,6 +27,10 @@ namespace py = pybind11;
 
 void launch(const std::string& connection_filename)
 {
+    using context_type = xeus::xcontext_impl<zmq::context_t>;
+    using context_ptr = std::unique_ptr<context_type>;
+    context_ptr context = context_ptr(new context_type());
+
     // Instantiating the xeus xinterpreter
     using interpreter_ptr = std::unique_ptr<xpyt::interpreter>;
     interpreter_ptr interpreter = interpreter_ptr(new xpyt::interpreter());
@@ -46,11 +51,12 @@ void launch(const std::string& connection_filename)
 
         xeus::xkernel kernel(config,
                              xeus::get_user_name(),
+                             std::move(context),
                              std::move(interpreter),
+                             xeus::make_xserver_shell_main,
                              std::move(hist),
                              xeus::make_console_logger(xeus::xlogger::msg_type,
                                                        xeus::make_file_logger(xeus::xlogger::content, "xeus.log")),
-                             xeus::make_xserver_shell_main,
                              xpyt::make_python_debugger);
 
         std::clog <<
@@ -64,10 +70,11 @@ void launch(const std::string& connection_filename)
     else
     {
         xeus::xkernel kernel(xeus::get_user_name(),
+                             std::move(context),
                              std::move(interpreter),
+                             xeus::make_xserver_shell_main,
                              std::move(hist),
                              nullptr,
-                             xeus::make_xserver_shell_main,
                              xpyt::make_python_debugger);
 
         const auto& config = kernel.get_config();

test/xeus_client.cpp

@@ -19,6 +19,7 @@
 #include "xeus/xguid.hpp"
 #include "xeus/xmessage.hpp"
 #include "xeus/xmiddleware.hpp"
+#include "xeus/xzmq_serializer.hpp"
 
 using namespace std::chrono_literals;
 
@@ -107,8 +108,7 @@ nl::json xeus_client_base::receive_on_iopub()
 {
     zmq::multipart_t wire_msg;
     wire_msg.recv(m_iopub);
-    xeus::xpub_message msg;
-    msg.deserialize(wire_msg, *p_iopub_authentication);
+    xeus::xpub_message msg = xeus::xzmq_serializer::deserialize_iopub(wire_msg, *p_iopub_authentication);
 
     nl::json res =  aggregate(msg.header(),
                               msg.parent_header(),
@@ -130,14 +130,13 @@ void xeus_client_base::send_message(nl::json header,
                                     zmq::socket_t& socket,
                                     const xeus::xauthentication& auth)
 {
-    zmq::multipart_t wire_msg;
     xeus::xmessage msg(xeus::xmessage::guid_list(),
                        std::move(header),
                        std::move(parent_header),
                        std::move(metadata),
                        std::move(content),
                        xeus::buffer_sequence());
-    std::move(msg).serialize(wire_msg, auth);
+    zmq::multipart_t wire_msg = xeus::xzmq_serializer::serialize(std::move(msg), auth);
     wire_msg.send(socket);
 }
 
@@ -146,8 +145,7 @@ nl::json xeus_client_base::receive_message(zmq::socket_t& socket,
 {
     zmq::multipart_t wire_msg;
     wire_msg.recv(socket);
-    xeus::xmessage msg;
-    msg.deserialize(wire_msg, auth);
+    xeus::xmessage msg = xeus::xzmq_serializer::deserialize(wire_msg, auth);
 
     return aggregate(msg.header(),
                      msg.parent_header(),