Merge branch 'main' into manually-reset-event

Author: minrk

.github/workflows/ci.yml

@@ -22,12 +22,29 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
+        qt:
+          - qt5
+          - qt6
         python-version:
           - "3.10"
           - "3.11"
           - "3.12"
           - "3.13"
-          - "pypy-3.10"
+          - "3.14"
+          # 3.14t needs a jupyter-core release
+          # - "3.14t"
+          - "pypy-3.11"
+        exclude:
+          # qt6 not supported on 3.14 yet
+          - python-version: "3.14"
+            qt: qt6
+          - python-version: "3.13"
+            qt: qt5
+          - python-version: "3.12"
+            qt: qt5
+          - python-version: "3.11"
+            qt: qt5
+
     steps:
       - name: Checkout
         uses: actions/checkout@v5
@@ -36,6 +53,11 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
 
+      - name: set qt env
+        run: |
+          echo "QT=${{ matrix.qt }}" >> $GITHUB_ENV
+        shell: bash
+
       - name: Install hatch
         run: |
           python --version
@@ -51,7 +73,7 @@ jobs:
         timeout-minutes: 15
         if: ${{ startsWith( matrix.python-version, 'pypy' ) }}
         run: |
-          hatch run test:nowarn
+          hatch run test:nowarn --ignore=tests/test_debugger.py
 
       - name: Run the tests on Windows
         timeout-minutes: 15

.github/workflows/downstream.yml

@@ -56,7 +56,6 @@ jobs:
           test_command: "pytest -vv -raXxs -W default --durations 10 --color=yes -k 'not (test_input_request or signal_kernel_subprocess)'"
 
   ipyparallel:
-    if: false
     runs-on: ubuntu-latest
     timeout-minutes: 20
     steps:
@@ -90,7 +89,6 @@ jobs:
 
   qtconsole:
     runs-on: ubuntu-latest
-    if: false
     timeout-minutes: 20
     steps:
       - name: Checkout
@@ -119,7 +117,7 @@ jobs:
         shell: bash -l {0}
         run: |
           cd ${GITHUB_WORKSPACE}/../qtconsole
-          xvfb-run --auto-servernum ${pythonLocation}/bin/python -m pytest -x -vv -s --full-trace --color=yes qtconsole
+          xvfb-run --auto-servernum ${pythonLocation}/bin/python -m pytest -x -vv -s --full-trace --color=yes qtconsole -k "not test_scroll"
 
   spyder_kernels:
     runs-on: ubuntu-latest

CHANGELOG.md

@@ -5,7 +5,7 @@
 import re
 
 # Version string must appear intact for hatch versioning
-__version__ = "7.0.0a2"
+__version__ = "7.0.1"
 
 # Build up version_info tuple for backwards compatibility
 pattern = r"(?P<major>\d+).(?P<minor>\d+).(?P<patch>\d+)(?P<rest>.*)"

ipykernel/_version.py

@@ -29,6 +29,7 @@ def __init__(self, session, pub_socket):
 
         self._parent_header: ContextVar[dict[str, Any]] = ContextVar("parent_header")
         self._parent_header.set({})
+        self._parent_header_global = {}
 
     def get_execution_count(self):
         """This method is replaced in kernelapp"""
@@ -57,11 +58,16 @@ def __call__(self, obj):
 
     @property
     def parent_header(self):
-        return self._parent_header.get()
+        try:
+            return self._parent_header.get()
+        except LookupError:
+            return self._parent_header_global
 
     def set_parent(self, parent):
         """Set the parent header."""
-        self._parent_header.set(extract_header(parent))
+        parent_header = extract_header(parent)
+        self._parent_header.set(parent_header)
+        self._parent_header_global = parent_header
 
 
 class ZMQShellDisplayHook(DisplayHook):
@@ -83,11 +89,16 @@ def __init__(self, *args, **kwargs):
 
     @property
     def parent_header(self):
-        return self._parent_header.get()
+        try:
+            return self._parent_header.get()
+        except LookupError:
+            return self._parent_header_global
 
     def set_parent(self, parent):
-        """Set the parent for outbound messages."""
-        self._parent_header.set(extract_header(parent))
+        """Set the parent header."""
+        parent_header = extract_header(parent)
+        self._parent_header.set(parent_header)
+        self._parent_header_global = parent_header
 
     def start_displayhook(self):
         """Start the display hook."""

ipykernel/displayhook.py

@@ -40,8 +40,9 @@ def register_integration(*toolkitnames):
     You can provide alternative names for the same toolkit.
 
     The decorated function should take a single argument, the IPython kernel
-    instance, arrange for the event loop to call ``kernel.do_one_iteration()``
-    at least every ``kernel._poll_interval`` seconds, and start the event loop.
+    instance, arrange for the event loop to yield the asyncio loop when a
+    message is received by the main shell zmq stream or at least every
+    ``kernel._poll_interval`` seconds, and start the event loop.
 
     :mod:`ipykernel.eventloops` provides and registers such functions
     for a few common event loops.
@@ -68,6 +69,15 @@ def exit_decorator(exit_func):
     return decorator
 
 
+def get_shell_stream(kernel):
+    # Return the zmq stream that receives messages for the main shell.
+    if kernel._supports_kernel_subshells:
+        manager = kernel.shell_channel_thread.manager
+        socket_pair = manager.get_shell_channel_to_subshell_pair(None)
+        return socket_pair.to_stream
+    return kernel.shell_stream
+
+
 def _notify_stream_qt(kernel):
     import operator
     from functools import lru_cache
@@ -87,17 +97,20 @@ def exit_loop():
         kernel._qt_notifier.setEnabled(False)
         kernel.app.qt_event_loop.quit()
 
-    def process_stream_events():
+    def process_stream_events_wrap(shell_stream, *args, **kwargs):
         """fall back to main loop when there's a socket event"""
         # call flush to ensure that the stream doesn't lose events
         # due to our consuming of the edge-triggered FD
         # flush returns the number of events consumed.
         # if there were any, wake it up
-        if kernel.shell_stream.flush(limit=1):
+        if shell_stream.flush(limit=1):
             exit_loop()
 
+    shell_stream = get_shell_stream(kernel)
+    process_stream_events = partial(process_stream_events_wrap, shell_stream)
+
     if not hasattr(kernel, "_qt_notifier"):
-        fd = kernel.shell_stream.getsockopt(zmq.FD)
+        fd = shell_stream.getsockopt(zmq.FD)
         kernel._qt_notifier = QtCore.QSocketNotifier(
             fd, enum_helper("QtCore.QSocketNotifier.Type").Read, kernel.app.qt_event_loop
         )
@@ -177,9 +190,11 @@ def loop_wx(kernel):
     # Wx uses milliseconds
     poll_interval = int(1000 * kernel._poll_interval)
 
-    def wake():
+    shell_stream = get_shell_stream(kernel)
+
+    def wake(shell_stream):
         """wake from wx"""
-        if kernel.shell_stream.flush(limit=1):
+        if shell_stream.flush(limit=1):
             kernel.app.ExitMainLoop()
             return
 
@@ -201,7 +216,7 @@ def on_timer(self, event):
     # wx.Timer to defer back to the tornado event loop.
     class IPWxApp(wx.App):  # type:ignore[misc]
         def OnInit(self):
-            self.frame = TimerFrame(wake)
+            self.frame = TimerFrame(partial(wake, shell_stream))
             self.frame.Show(False)
             return True
 
@@ -248,14 +263,14 @@ def __init__(self, app):
 
         def exit_loop():
             """fall back to main loop"""
-            app.tk.deletefilehandler(kernel.shell_stream.getsockopt(zmq.FD))
+            app.tk.deletefilehandler(shell_stream.getsockopt(zmq.FD))
             app.quit()
             app.destroy()
             del kernel.app_wrapper
 
-        def process_stream_events(*a, **kw):
+        def process_stream_events_wrap(shell_stream, *a, **kw):
             """fall back to main loop when there's a socket event"""
-            if kernel.shell_stream.flush(limit=1):
+            if shell_stream.flush(limit=1):
                 exit_loop()
 
         # allow for scheduling exits from the loop in case a timeout needs to
@@ -268,9 +283,10 @@ def _schedule_exit(delay):
 
         # For Tkinter, we create a Tk object and call its withdraw method.
         kernel.app_wrapper = BasicAppWrapper(app)
-        app.tk.createfilehandler(
-            kernel.shell_stream.getsockopt(zmq.FD), READABLE, process_stream_events
-        )
+        shell_stream = get_shell_stream(kernel)
+        process_stream_events = partial(process_stream_events_wrap, shell_stream)
+
+        app.tk.createfilehandler(shell_stream.getsockopt(zmq.FD), READABLE, process_stream_events)
         # schedule initial call after start
         app.after(0, process_stream_events)
 
@@ -283,15 +299,19 @@ def _schedule_exit(delay):
 
         nest_asyncio.apply()
 
-        doi = kernel.do_one_iteration
         # Tk uses milliseconds
         poll_interval = int(1000 * kernel._poll_interval)
 
+        shell_stream = get_shell_stream(kernel)
+
         class TimedAppWrapper:
-            def __init__(self, app, func):
+            def __init__(self, app, shell_stream):
                 self.app = app
+                self.shell_stream = shell_stream
                 self.app.withdraw()
-                self.func = func
+
+            async def func(self):
+                self.shell_stream.flush(limit=1)
 
             def on_timer(self):
                 loop = asyncio.get_event_loop()
@@ -305,16 +325,18 @@ def start(self):
                 self.on_timer()  # Call it once to get things going.
                 self.app.mainloop()
 
-        kernel.app_wrapper = TimedAppWrapper(app, doi)
+        kernel.app_wrapper = TimedAppWrapper(app, shell_stream)
         kernel.app_wrapper.start()
 
 
 @loop_tk.exit
 def loop_tk_exit(kernel):
     """Exit the tk loop."""
     try:
+        kernel.app_wrapper.app.quit()
         kernel.app_wrapper.app.destroy()
         del kernel.app_wrapper
+        kernel.eventloop = None
     except (RuntimeError, AttributeError):
         pass
 
@@ -359,6 +381,7 @@ def loop_cocoa(kernel):
     from ._eventloop_macos import mainloop, stop
 
     real_excepthook = sys.excepthook
+    shell_stream = get_shell_stream(kernel)
 
     def handle_int(etype, value, tb):
         """don't let KeyboardInterrupts look like crashes"""
@@ -377,7 +400,7 @@ def handle_int(etype, value, tb):
                 # don't let interrupts during mainloop invoke crash_handler:
                 sys.excepthook = handle_int
                 mainloop(kernel._poll_interval)
-                if kernel.shell_stream.flush(limit=1):
+                if shell_stream.flush(limit=1):
                     # events to process, return control to kernel
                     return
             except BaseException:
@@ -415,13 +438,14 @@ def loop_asyncio(kernel):
     loop._should_close = False  # type:ignore[attr-defined]
 
     # pause eventloop when there's an event on a zmq socket
-    def process_stream_events(stream):
+    def process_stream_events(shell_stream):
         """fall back to main loop when there's a socket event"""
-        if stream.flush(limit=1):
+        if shell_stream.flush(limit=1):
             loop.stop()
 
-    notifier = partial(process_stream_events, kernel.shell_stream)
-    loop.add_reader(kernel.shell_stream.getsockopt(zmq.FD), notifier)
+    shell_stream = get_shell_stream(kernel)
+    notifier = partial(process_stream_events, shell_stream)
+    loop.add_reader(shell_stream.getsockopt(zmq.FD), notifier)
     loop.call_soon(notifier)
 
     while True:

ipykernel/eventloops.py

@@ -456,8 +456,6 @@ def __init__(
             "parent_header"
         )
         self._parent_header.set({})
-        self._thread_to_parent = {}
-        self._thread_to_parent_header = {}
         self._parent_header_global = {}
         self._master_pid = os.getpid()
         self._flush_pending = False
@@ -512,21 +510,11 @@ def __init__(
     @property
     def parent_header(self):
         try:
-            # asyncio-specific
+            # asyncio or thread-specific
             return self._parent_header.get()
         except LookupError:
-            try:
-                # thread-specific
-                identity = threading.current_thread().ident
-                # retrieve the outermost (oldest ancestor,
-                # discounting the kernel thread) thread identity
-                while identity in self._thread_to_parent:
-                    identity = self._thread_to_parent[identity]
-                # use the header of the oldest ancestor
-                return self._thread_to_parent_header[identity]
-            except KeyError:
-                # global (fallback)
-                return self._parent_header_global
+            # global (fallback)
+            return self._parent_header_global
 
     @parent_header.setter
     def parent_header(self, value):