Add more testing and deprecate the Gtk event loops (#1036)

Author: blink1073

ipykernel/comm/comm.py

@@ -14,7 +14,7 @@
 
 # this is the class that will be created if we do comm.create_comm
 class BaseComm(comm.base_comm.BaseComm):
-    kernel: Optional[Kernel]
+    kernel: Optional[Kernel] = None
 
     def publish_msg(self, msg_type, data=None, metadata=None, buffers=None, **keys):
         """Helper for sending a comm message on IOPub"""

ipykernel/gui/gtk3embed.py

@@ -12,6 +12,9 @@
 # -----------------------------------------------------------------------------
 # stdlib
 import sys
+import warnings
+
+warnings.warn("The Gtk3 event loop for ipykernel is deprecated", category=DeprecationWarning)
 
 # Third-party
 import gi

ipykernel/gui/gtkembed.py

@@ -12,6 +12,9 @@
 # -----------------------------------------------------------------------------
 # stdlib
 import sys
+import warnings
+
+warnings.warn("The Gtk3 event loop for ipykernel is deprecated", category=DeprecationWarning)
 
 # Third-party
 import gobject

ipykernel/inprocess/tests/test_kernel.py

@@ -1,14 +1,11 @@
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-import asyncio
 import sys
-import unittest
 from contextlib import contextmanager
 from io import StringIO
 
 import pytest
-import tornado
 from IPython.utils.io import capture_output
 from jupyter_client.session import Session
 
@@ -20,44 +17,6 @@
 orig_msg = Session.msg
 
 
-def _init_asyncio_patch():
-    """set default asyncio policy to be compatible with tornado
-
-    Tornado 6 (at least) is not compatible with the default
-    asyncio implementation on Windows
-
-    Pick the older SelectorEventLoopPolicy on Windows
-    if the known-incompatible default policy is in use.
-
-    do this as early as possible to make it a low priority and overrideable
-
-    ref: https://github.com/tornadoweb/tornado/issues/2608
-
-    FIXME: if/when tornado supports the defaults in asyncio,
-           remove and bump tornado requirement for py38
-    """
-    if (
-        sys.platform.startswith("win")
-        and sys.version_info >= (3, 8)
-        and tornado.version_info < (6, 1)
-    ):
-        import asyncio
-
-        try:
-            from asyncio import (
-                WindowsProactorEventLoopPolicy,
-                WindowsSelectorEventLoopPolicy,
-            )
-        except ImportError:
-            pass
-            # not affected
-        else:
-            if type(asyncio.get_event_loop_policy()) is WindowsProactorEventLoopPolicy:
-                # WindowsProactorEventLoopPolicy is not compatible with tornado 6
-                # fallback to the pre-3.8 default of Selector
-                asyncio.set_event_loop_policy(WindowsSelectorEventLoopPolicy())
-
-
 def _inject_cell_id(_self, *args, **kwargs):
     """
     This patch jupyter_client.session:Session.msg to add a cell_id to the return message metadata
@@ -78,79 +37,85 @@ def patch_cell_id():
         Session.msg = orig_msg
 
 
-class InProcessKernelTestCase(unittest.TestCase):
-    def setUp(self):
-        _init_asyncio_patch()
-        self.km = InProcessKernelManager()
-        self.km.start_kernel()
-        self.kc = self.km.client()
-        self.kc.start_channels()
-        self.kc.wait_for_ready()
-
-    def test_with_cell_id(self):
-
-        with patch_cell_id():
-            self.kc.execute("1+1")
-
-    def test_pylab(self):
-        """Does %pylab work in the in-process kernel?"""
-        _ = pytest.importorskip("matplotlib", reason="This test requires matplotlib")
-        kc = self.kc
-        kc.execute("%pylab")
-        out, err = assemble_output(kc.get_iopub_msg)
-        self.assertIn("matplotlib", out)
-
-    def test_raw_input(self):
-        """Does the in-process kernel handle raw_input correctly?"""
-        io = StringIO("foobar\n")
-        sys_stdin = sys.stdin
-        sys.stdin = io
-        try:
-            self.kc.execute("x = input()")
-        finally:
-            sys.stdin = sys_stdin
-        assert self.km.kernel.shell.user_ns.get("x") == "foobar"
-
-    @pytest.mark.skipif("__pypy__" in sys.builtin_module_names, reason="fails on pypy")
-    def test_stdout(self):
-        """Does the in-process kernel correctly capture IO?"""
-        kernel = InProcessKernel()
-
-        with capture_output() as io:
-            kernel.shell.run_cell('print("foo")')
-        assert io.stdout == "foo\n"
-
-        kc = BlockingInProcessKernelClient(kernel=kernel, session=kernel.session)
-        kernel.frontends.append(kc)
-        kc.execute('print("bar")')
-        out, err = assemble_output(kc.get_iopub_msg)
-        assert out == "bar\n"
-
-    @pytest.mark.skip(reason="Currently don't capture during test as pytest does its own capturing")
-    def test_capfd(self):
-        """Does correctly capture fd"""
-        kernel = InProcessKernel()
-
-        with capture_output() as io:
-            kernel.shell.run_cell('print("foo")')
-        assert io.stdout == "foo\n"
-
-        kc = BlockingInProcessKernelClient(kernel=kernel, session=kernel.session)
-        kernel.frontends.append(kc)
-        kc.execute("import os")
-        kc.execute('os.system("echo capfd")')
-        out, err = assemble_output(kc.iopub_channel)
-        assert out == "capfd\n"
-
-    def test_getpass_stream(self):
-        "Tests that kernel getpass accept the stream parameter"
-        kernel = InProcessKernel()
-        kernel._allow_stdin = True
-        kernel._input_request = lambda *args, **kwargs: None
-
-        kernel.getpass(stream="non empty")
-
-    def test_do_execute(self):
-        kernel = InProcessKernel()
-        asyncio.run(kernel.do_execute("a=1", True))
-        assert kernel.shell.user_ns["a"] == 1
+@pytest.fixture()
+def kc():
+    km = InProcessKernelManager()
+    km.start_kernel()
+    kc = km.client()
+    kc.start_channels()
+    kc.wait_for_ready()
+    yield kc
+
+
+def test_with_cell_id(kc):
+
+    with patch_cell_id():
+        kc.execute("1+1")
+
+
+def test_pylab(kc):
+    """Does %pylab work in the in-process kernel?"""
+    _ = pytest.importorskip("matplotlib", reason="This test requires matplotlib")
+    kc.execute("%pylab")
+    out, err = assemble_output(kc.get_iopub_msg)
+    assert "matplotlib" in out
+
+
+def test_raw_input(kc):
+    """Does the in-process kernel handle raw_input correctly?"""
+    io = StringIO("foobar\n")
+    sys_stdin = sys.stdin
+    sys.stdin = io
+    try:
+        kc.execute("x = input()")
+    finally:
+        sys.stdin = sys_stdin
+    assert kc.kernel.shell.user_ns.get("x") == "foobar"
+
+
+@pytest.mark.skipif("__pypy__" in sys.builtin_module_names, reason="fails on pypy")
+def test_stdout(kc):
+    """Does the in-process kernel correctly capture IO?"""
+    kernel = InProcessKernel()
+
+    with capture_output() as io:
+        kernel.shell.run_cell('print("foo")')
+    assert io.stdout == "foo\n"
+
+    kc = BlockingInProcessKernelClient(kernel=kernel, session=kernel.session)
+    kernel.frontends.append(kc)
+    kc.execute('print("bar")')
+    out, err = assemble_output(kc.get_iopub_msg)
+    assert out == "bar\n"
+
+
+@pytest.mark.skip(reason="Currently don't capture during test as pytest does its own capturing")
+def test_capfd(kc):
+    """Does correctly capture fd"""
+    kernel = InProcessKernel()
+
+    with capture_output() as io:
+        kernel.shell.run_cell('print("foo")')
+    assert io.stdout == "foo\n"
+
+    kc = BlockingInProcessKernelClient(kernel=kernel, session=kernel.session)
+    kernel.frontends.append(kc)
+    kc.execute("import os")
+    kc.execute('os.system("echo capfd")')
+    out, err = assemble_output(kc.iopub_channel)
+    assert out == "capfd\n"
+
+
+def test_getpass_stream(kc):
+    "Tests that kernel getpass accept the stream parameter"
+    kernel = InProcessKernel()
+    kernel._allow_stdin = True
+    kernel._input_request = lambda *args, **kwargs: None
+
+    kernel.getpass(stream="non empty")
+
+
+async def test_do_execute(kc):
+    kernel = InProcessKernel()
+    await kernel.do_execute("a=1", True)
+    assert kernel.shell.user_ns["a"] == 1

ipykernel/kernelapp.py

@@ -168,7 +168,9 @@ def abs_connection_file(self):
     trio_loop = Bool(False, help="Set main event loop.").tag(config=True)
     quiet = Bool(True, help="Only send stdout/stderr to output stream").tag(config=True)
     outstream_class = DottedObjectName(
-        "ipykernel.iostream.OutStream", help="The importstring for the OutStream factory"
+        "ipykernel.iostream.OutStream",
+        help="The importstring for the OutStream factory",
+        allow_none=True,
     ).tag(config=True)
     displayhook_class = DottedObjectName(
         "ipykernel.displayhook.ZMQDisplayHook", help="The importstring for the DisplayHook factory"
@@ -717,7 +719,7 @@ def start(self):
 launch_new_instance = IPKernelApp.launch_instance
 
 
-def main():
+def main():  # pragma: no cover
     """Run an IPKernel as an application"""
     app = IPKernelApp.instance()
     app.initialize()

ipykernel/tests/test_comm.py

@@ -0,0 +1,7 @@
+from ipykernel.comm import Comm
+
+
+async def test_comm(kernel):
+    c = Comm()
+    c.kernel = kernel
+    c.publish_msg("foo")

ipykernel/tests/test_embed_kernel.py

@@ -1,11 +1,12 @@
-"""test IPython.embed_kernel()"""
+"""test embed_kernel"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import json
 import os
 import sys
+import threading
 import time
 from contextlib import contextmanager
 from subprocess import PIPE, Popen
@@ -15,6 +16,8 @@
 from jupyter_client import BlockingKernelClient
 from jupyter_core import paths
 
+from ipykernel.embed import IPKernelApp, embed_kernel
+
 SETUP_TIMEOUT = 60
 TIMEOUT = 15
 
@@ -193,3 +196,20 @@ def test_embed_kernel_reentrant():
             client.execute("get_ipython().exit_now = True")
             msg = client.get_shell_msg(timeout=TIMEOUT)
             time.sleep(0.2)
+
+
+def test_embed_kernel_func():
+    from types import ModuleType
+
+    module = ModuleType("test")
+
+    def trigger_stop():
+        time.sleep(1)
+        app = IPKernelApp.instance()
+        app.io_loop.add_callback(app.io_loop.stop)
+        IPKernelApp.clear_instance()
+
+    thread = threading.Thread(target=trigger_stop)
+    thread.start()
+
+    embed_kernel(module, outstream_class=None)

ipykernel/tests/test_eventloop.py

@@ -5,11 +5,12 @@
 import sys
 import threading
 import time
+from unittest.mock import MagicMock
 
 import pytest
 import tornado
 
-from ipykernel.eventloops import enable_gui, loop_asyncio, loop_tk
+from ipykernel.eventloops import enable_gui, loop_asyncio, loop_cocoa, loop_tk
 
 from .utils import execute, flush_channels, start_new_kernel
 
@@ -88,3 +89,9 @@ def do_thing():
 @windows_skip
 def test_enable_gui(kernel):
     enable_gui("tk", kernel)
+
+
+@pytest.mark.skipif(sys.platform != "darwin", reason="MacOS-only")
+def test_cocoa_loop(kernel):
+    kernel.shell = MagicMock()
+    loop_cocoa(kernel)

ipykernel/tests/test_kernel.py

@@ -534,6 +534,10 @@ def _start_children():
     platform.python_implementation() == "PyPy",
     reason="does not work on PyPy",
 )
+@pytest.mark.skipif(
+    sys.platform.lower() == "linux",
+    reason="Stalls on linux",
+)
 def test_shutdown_subprocesses():
     """Kernel exits after polite shutdown_request"""
     with new_kernel() as kc: