Merge pull request #1188 from JuliaLang/hooks

Allow registering hooks at any time

Author: JamesWrigley

docs/src/_changelog.md

@@ -7,7 +7,11 @@ CurrentModule = IJulia
 This documents notable changes in IJulia.jl. The format is based on [Keep a
 Changelog](https://keepachangelog.com).
 
-## Unreleased
+## [v1.30.6] - 2025-10-06
+
+### Fixed
+- It's now possible to register hooks at any time, even if an IJulia kernel is
+  not running ([#1188]). This was accidentally broken in v1.30.
 
 ### Changed
 - Implemented lazy loading for Conda.jl ([#1187]), which shaves off about 60% of

docs/src/library/internals.md

@@ -7,19 +7,6 @@
 IJulia.init
 ```
 
-
-## Cell execution hooks
-
-```@docs
-IJulia.pop_posterror_hook
-IJulia.pop_postexecute_hook
-IJulia.pop_preexecute_hook
-IJulia.push_posterror_hook
-IJulia.push_postexecute_hook
-IJulia.push_preexecute_hook
-```
-
-
 ## Messaging
 
 ```@docs

docs/src/library/public.md

@@ -47,3 +47,14 @@ IJulia.readprompt
 IJulia.set_max_stdio
 IJulia.reset_stdio_count
 ```
+
+## Cell execution hooks
+
+```@docs
+IJulia.push_preexecute_hook
+IJulia.pop_preexecute_hook
+IJulia.push_postexecute_hook
+IJulia.pop_postexecute_hook
+IJulia.push_posterror_hook
+IJulia.pop_posterror_hook
+```

src/IJulia.jl

@@ -117,9 +117,6 @@ REPL.REPLDisplay(repl::MiniREPL) = repl.display
     # from the front-end.
     comms::Dict{String, Comm} = Dict{String, Comm}()
 
-    postexecute_hooks::Vector{Function} = Function[]
-    preexecute_hooks::Vector{Function} = Function[]
-    posterror_hooks::Vector{Function} = Function[]
     shutdown::Function = exit
 
     # the following constants need to be initialized in init().
@@ -405,7 +402,10 @@ history
 # Similar to the ipython kernel, we provide a mechanism by
 # which modules can register thunk functions to be called after
 # executing an input cell, e.g. to "close" the current plot in Pylab.
-# Modules should only use these if isdefined(Main, IJulia) is true.
+
+const _preexecute_hooks = Function[]
+const _postexecute_hooks = Function[]
+const _posterror_hooks = Function[]
 
 function _pop_hook!(f, hooks)
     hook_idx = findlast(isequal(f), hooks)
@@ -422,29 +422,31 @@ end
 Push a function `f()` onto the end of a list of functions to
 execute after executing any notebook cell.
 """
-push_postexecute_hook(f::Function; kernel=_default_kernel) = push!(kernel.postexecute_hooks, f)
+push_postexecute_hook(f::Function) = push!(IJulia._postexecute_hooks, f)
+
 """
     pop_postexecute_hook(f::Function)
 
 Remove a function `f()` from the list of functions to
 execute after executing any notebook cell.
 """
-pop_postexecute_hook(f::Function; kernel=_default_kernel) = _pop_hook!(f, kernel.postexecute_hooks)
+pop_postexecute_hook(f::Function) = _pop_hook!(f, IJulia._postexecute_hooks)
 
 """
     push_preexecute_hook(f::Function)
 
 Push a function `f()` onto the end of a list of functions to
 execute before executing any notebook cell.
 """
-push_preexecute_hook(f::Function; kernel=_default_kernel) = push!(kernel.preexecute_hooks, f)
+push_preexecute_hook(f::Function) = push!(IJulia._preexecute_hooks, f)
+
 """
     pop_preexecute_hook(f::Function)
 
 Remove a function `f()` from the list of functions to
 execute before executing any notebook cell.
 """
-pop_preexecute_hook(f::Function; kernel=_default_kernel) = _pop_hook!(f, kernel.preexecute_hooks)
+pop_preexecute_hook(f::Function) = _pop_hook!(f, IJulia._preexecute_hooks)
 
 # similar, but called after an error (e.g. to reset plotting state)
 """
@@ -453,14 +455,15 @@ pop_preexecute_hook(f::Function; kernel=_default_kernel) = _pop_hook!(f, kernel.
 Remove a function `f()` from the list of functions to
 execute after an error occurs when a notebook cell is evaluated.
 """
-push_posterror_hook(f::Function; kernel=_default_kernel) = push!(kernel.posterror_hooks, f)
+push_posterror_hook(f::Function) = push!(IJulia._posterror_hooks, f)
+
 """
     pop_posterror_hook(f::Function)
 
 Remove a function `f()` from the list of functions to
 execute after an error occurs when a notebook cell is evaluated.
 """
-pop_posterror_hook(f::Function; kernel=_default_kernel) = _pop_hook!(f, kernel.posterror_hooks)
+pop_posterror_hook(f::Function) = _pop_hook!(f, IJulia._posterror_hooks)
 
 #######################################################################
 

src/execute_request.jl

@@ -75,7 +75,7 @@ function execute_request(socket, kernel, msg)
     hcode = replace(code, r"^\s*\?" => "")
 
     try
-        foreach(invokelatest, kernel.preexecute_hooks)
+        foreach(invokelatest, IJulia._preexecute_hooks)
 
         kernel.ans = result = if hcode != code # help request
             Core.eval(Main, helpmode(hcode))
@@ -114,7 +114,7 @@ function execute_request(socket, kernel, msg)
             end
         end
 
-        foreach(invokelatest, kernel.postexecute_hooks)
+        foreach(invokelatest, IJulia._postexecute_hooks)
 
         # flush pending stdio
         flush_all()
@@ -151,7 +151,7 @@ function execute_request(socket, kernel, msg)
         try
             # flush pending stdio
             flush_all()
-            foreach(invokelatest, kernel.posterror_hooks)
+            foreach(invokelatest, IJulia._posterror_hooks)
         catch
         end
         empty!(kernel.displayqueue) # discard pending display requests on an error

test/kernel.jl

@@ -407,7 +407,7 @@ end
                     shutdown(client; wait=false)
                 end
 
-                @test timedwait(() -> process_exited(kernel_proc), 30) == :ok
+                @test timedwait(() -> process_exited(kernel_proc), 60) == :ok
             finally
                 kill(kernel_proc)
             end