WIP: Upgrade to Xeus 4.0

environment-dev.yml

@@ -7,9 +7,9 @@ dependencies:
   - cxx-compiler
   - ninja
   # Host dependencies
+  - xeus>=4.0.2
   - xeus-zmq>=1.3.0,<2.0
-  - nlohmann_json
-  - cppzmq
+  - nlohmann_json=3.11.3
   - xtl>=0.7, <0.8
   - pybind11>=2.6.1,<3.0
   - pybind11_json>=0.2.6,<0.3

include/xeus-python/xdebugger.hpp

@@ -20,9 +20,7 @@
 #include <mutex>
 #include <set>
 
-#include "zmq.hpp"
 #include "nlohmann/json.hpp"
-#include "xeus/xeus_context.hpp"
 #include "pybind11/pybind11.h"
 #include "xeus-zmq/xdebugger_base.hpp"
 #include "xeus_python_config.hpp"
@@ -40,7 +38,7 @@ namespace xpyt
 
         using base_type = xeus::xdebugger_base;
 
-        debugger(zmq::context_t& context,
+        debugger(xeus::xcontext& context,
                  const xeus::xconfiguration& config,
                  const std::string& user_name,
                  const std::string& session_id,
@@ -59,10 +57,8 @@ namespace xpyt
         nl::json variables_request_impl(const nl::json& message) override;
 
         bool start_debugpy();
-        bool start(zmq::socket_t& header_socket,
-                   zmq::socket_t& request_socket) override;
-        void stop(zmq::socket_t& header_socket,
-                  zmq::socket_t& request_socket) override;
+        bool start() override;
+        void stop() override;
         xeus::xdebugger_info get_debugger_info() const override;
         std::string get_cell_temporary_file(const std::string& code) const override;
 

include/xeus-python/xinterpreter.hpp

@@ -22,6 +22,7 @@
 #include "nlohmann/json.hpp"
 
 #include "xeus/xinterpreter.hpp"
+#include "xeus/xrequest_context.hpp"
 
 #include "pybind11/pybind11.h"
 
@@ -51,12 +52,12 @@ namespace xpyt
 
         void configure_impl() override;
 
-        nl::json execute_request_impl(int execution_counter,
-                                      const std::string& code,
-                                      bool silent,
-                                      bool store_history,
-                                      nl::json user_expressions,
-                                      bool allow_stdin) override;
+        void execute_request_impl(xeus::xrequest_context request_context,
+                                  send_reply_callback cb,
+                                  int execution_counter,
+                                  const std::string& code,
+                                  xeus::execute_request_config config,
+                                  nl::json user_expressions) override;
 
         nl::json complete_request_impl(const std::string& code, int cursor_pos) override;
 
@@ -99,7 +100,7 @@ namespace xpyt
 
     private:
 
-        virtual void instanciate_ipython_shell();
+        virtual void instantiate_ipython_shell();
     };
 }
 

include/xeus-python/xinterpreter_raw.hpp

@@ -20,6 +20,7 @@
 #include "nlohmann/json.hpp"
 
 #include "xeus/xinterpreter.hpp"
+#include "xeus/xrequest_context.hpp"
 
 #include "pybind11/pybind11.h"
 
@@ -49,12 +50,12 @@ namespace xpyt
 
         void configure_impl() override;
 
-        nl::json execute_request_impl(int execution_counter,
-                                      const std::string& code,
-                                      bool silent,
-                                      bool store_history,
-                                      nl::json user_expressions,
-                                      bool allow_stdin) override;
+        void execute_request_impl(xeus::xrequest_context request_context,
+                                  send_reply_callback cb,
+                                  int execution_counter,
+                                  const std::string& code,
+                                  xeus::execute_request_config config,
+                                  nl::json user_expressions) override;
 
         nl::json complete_request_impl(const std::string& code, int cursor_pos) override;
 

src/main.cpp

@@ -21,12 +21,12 @@
 #include <unistd.h>
 #endif
 
-#include "xeus/xeus_context.hpp"
 #include "xeus/xkernel.hpp"
 #include "xeus/xkernel_configuration.hpp"
 #include "xeus/xinterpreter.hpp"
 
-#include "xeus-zmq/xserver_shell_main.hpp"
+#include "xeus-zmq/xserver_zmq_split.hpp"
+#include "xeus-zmq/xzmq_context.hpp"
 
 #include "pybind11/embed.h"
 #include "pybind11/pybind11.h"
@@ -99,9 +99,7 @@ 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());
+    std::unique_ptr<xeus::xcontext> context = xeus::make_zmq_context();
 
     // Instantiating the xeus xinterpreter
     bool raw_mode = xpyt::extract_option("-r", "--raw", argc, argv);

src/xcomm.cpp

@@ -37,10 +37,13 @@ namespace xpyt
      * xcomm implementation *
      ************************/
 
-    xcomm::xcomm(const py::object& target_name, const py::object& data, const py::object& metadata, const py::object& buffers, const py::kwargs& kwargs)
+    xcomm::xcomm(const py::object& target_name,
+                 const py::object& data,
+                 const py::object& metadata,
+                 const py::object& buffers,
+                 const py::kwargs& kwargs)
         : m_comm(target(target_name), id(kwargs))
     {
-        m_comm.open(metadata, data, pylist_to_cpp_buffers(buffers));
     }
 
     xcomm::xcomm(xeus::xcomm&& comm)
@@ -62,14 +65,28 @@ namespace xpyt
         return true;
     }
 
-    void xcomm::close(const py::object& data, const py::object& metadata, const py::object& buffers)
+    void xcomm::open(const py::object& parent_header,
+                     const py::object& data,
+                     const py::object& metadata,
+                     const py::object& buffers)
     {
-        m_comm.close(metadata, data, pylist_to_cpp_buffers(buffers));
+        m_comm.open(parent_header, metadata, data, pylist_to_cpp_buffers(buffers));
     }
 
-    void xcomm::send(const py::object& data, const py::object& metadata, const py::object& buffers)
+    void xcomm::close(const py::object& parent_header,
+                      const py::object& data,
+                      const py::object& metadata,
+                      const py::object& buffers)
     {
-        m_comm.send(metadata, data, pylist_to_cpp_buffers(buffers));
+        m_comm.close(parent_header, metadata, data, pylist_to_cpp_buffers(buffers));
+    }
+
+    void xcomm::send(const py::object& parent_header,
+                     const py::object& data,
+                     const py::object& metadata,
+                     const py::object& buffers)
+    {
+        m_comm.send(parent_header, metadata, data, pylist_to_cpp_buffers(buffers));
     }
 
     void xcomm::on_msg(const python_callback_type& callback)
@@ -133,8 +150,18 @@ namespace xpyt
                 py::init<const py::object&, const py::object&, const py::object&, const py::object&, py::kwargs>(),
                 "target_name"_a="", "data"_a=py::dict(), "metadata"_a=py::dict(), "buffers"_a=py::list()
             )
-            .def("close", &xcomm::close, "data"_a=py::dict(), "metadata"_a=py::dict(), "buffers"_a=py::list())
-            .def("send", &xcomm::send, "data"_a=py::dict(), "metadata"_a=py::dict(), "buffers"_a=py::list())
+            .def("open", &xcomm::open, "parent_header"_a=py::dict(),
+                                       "data"_a=py::dict(),
+                                       "metadata"_a=py::dict(),
+                                       "buffers"_a=py::list())
+            .def("close", &xcomm::close, "parent_header"_a=py::dict(),
+                                         "data"_a=py::dict(),
+                                         "metadata"_a=py::dict(),
+                                         "buffers"_a=py::list())
+            .def("send", &xcomm::send, "parent_header"_a=py::dict(),
+                                       "data"_a=py::dict(),
+                                       "metadata"_a=py::dict(),
+                                       "buffers"_a=py::list())
             .def("on_msg", &xcomm::on_msg)
             .def("on_close", &xcomm::on_close)
             .def_property_readonly("comm_id", &xcomm::comm_id)

src/xcomm.hpp

@@ -23,18 +23,35 @@ namespace xpyt
 
         using python_callback_type = std::function<void(py::object)>;
         using cpp_callback_type = std::function<void(const xeus::xmessage&)>;
-        using buffers_sequence = xeus::buffer_sequence;
 
-        xcomm(const py::object& target_name, const py::object& data, const py::object& metadata, const py::object& buffers, const py::kwargs& kwargs);
+        xcomm(const py::object& target_name,
+              const py::object& data,
+              const py::object& metadata,
+              const py::object& buffers,
+              const py::kwargs& kwargs);
+
         xcomm(xeus::xcomm&& comm);
         xcomm(xcomm&& comm) = default;
         virtual ~xcomm();
 
         std::string comm_id() const;
         bool kernel() const;
 
-        void close(const py::object& data, const py::object& metadata, const py::object& buffers);
-        void send(const py::object& data, const py::object& metadata, const py::object& buffers);
+        void open(const py::object& parent_header,
+                  const py::object& data,
+                  const py::object& metadata,
+                  const py::object& buffers);
+
+        void close(const py::object& parent_header,
+                   const py::object& data,
+                   const py::object& metadata,
+                   const py::object& buffers);
+
+        void send(const py::object& parent_header,
+                  const py::object& data,
+                  const py::object& metadata,
+                  const py::object& buffers);
+
         void on_msg(const python_callback_type& callback);
         void on_close(const python_callback_type& callback);
 

src/xdebugger.cpp

@@ -42,7 +42,7 @@ using namespace std::placeholders;
 
 namespace xpyt
 {
-    debugger::debugger(zmq::context_t& context,
+    debugger::debugger(xeus::xcontext& context,
                        const xeus::xconfiguration& config,
                        const std::string& user_name,
                        const std::string& session_id,
@@ -305,7 +305,7 @@ namespace xpyt
         return status == "ok";
     }
 
-    bool debugger::start(zmq::socket_t& header_socket, zmq::socket_t& request_socket)
+    bool debugger::start()
     {
         std::string temp_dir = xeus::get_temp_directory_path();
         std::string log_dir = temp_dir + "/" + "xpython_debug_logs_" + std::to_string(xeus::get_current_pid());
@@ -322,8 +322,7 @@ namespace xpyt
         std::string controller_header_end_point = xeus::get_controller_end_point("debugger_header");
         std::string publisher_end_point = xeus::get_publisher_end_point();
 
-        request_socket.bind(controller_end_point);
-        header_socket.bind(controller_header_end_point);
+        bind_sockets(controller_end_point, controller_header_end_point);
 
         std::string debugpy_end_point = "tcp://" + m_debugpy_host + ':' + m_debugpy_port;
         std::thread client(&xdap_tcp_client::start_debugger,
@@ -334,22 +333,19 @@ namespace xpyt
                            controller_header_end_point);
         client.detach();
 
-        request_socket.send(zmq::message_t("REQ", 3), zmq::send_flags::none);
-        zmq::message_t ack;
-        (void)request_socket.recv(ack);
+        send_recv_request("REQ");
 
-        std::string tmp_folder =  get_tmp_prefix();
+        std::string tmp_folder = get_tmp_prefix();
         xeus::create_directory(tmp_folder);
 
         return true;
     }
 
-    void debugger::stop(zmq::socket_t& header_socket, zmq::socket_t& request_socket)
+    void debugger::stop()
     {
         std::string controller_end_point = xeus::get_controller_end_point("debugger");
         std::string controller_header_end_point = xeus::get_controller_end_point("debugger_header");
-        request_socket.unbind(controller_end_point);
-        header_socket.unbind(controller_header_end_point);
+        unbind_sockets(controller_end_point, controller_header_end_point);
     }
 
     xeus::xdebugger_info debugger::get_debugger_info() const
@@ -373,7 +369,6 @@ namespace xpyt
                                                           const std::string& session_id,
                                                           const nl::json& debugger_config)
     {
-        return std::unique_ptr<xeus::xdebugger>(new debugger(context.get_wrapped_context<zmq::context_t>(),
-                                                             config, user_name, session_id, debugger_config));
+        return std::unique_ptr<xeus::xdebugger>(new debugger(context, config, user_name, session_id, debugger_config));
     }
 }

src/xdebugpy_client.cpp

@@ -8,7 +8,6 @@
 * The full license is in the file LICENSE, distributed with this software. *
 ****************************************************************************/
 
-#include "zmq_addon.hpp"
 #include "nlohmann/json.hpp"
 #include "xeus/xmessage.hpp"
 #include "xdebugpy_client.hpp"
@@ -20,7 +19,7 @@ namespace nl = nlohmann;
 
 namespace xpyt
 {
-    xdebugpy_client::xdebugpy_client(zmq::context_t& context,
+    xdebugpy_client::xdebugpy_client(xeus::xcontext& context,
                                      const xeus::xconfiguration& config,
                                      int socket_linger,
                                      const xdap_tcp_configuration& dap_config,

src/xdebugpy_client.hpp

@@ -25,7 +25,7 @@ namespace xpyt
         using base_type = xdap_tcp_client;
         using event_callback = base_type::event_callback;
 
-        xdebugpy_client(zmq::context_t& context,
+        xdebugpy_client(xeus::xcontext& context,
                         const xeus::xconfiguration& config,
                         int socket_linger,
                         const xdap_tcp_configuration& dap_config,