Merge branch 'main' of https://github.com/JuliaPy/PythonCall.jl

Author: Christopher Doris

.github/workflows/benchmark_pr.yml

@@ -0,0 +1,16 @@
+name: Benchmark PR
+on:
+  pull_request:
+
+jobs:
+  bench:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: MilesCranmer/AirspeedVelocity.jl@action-v1
+        with:
+          julia-version: "1"
+          tune: "true"
+          # Post to "summary" tab of workflow run:
+          job-summary: "true"
+          # Run benchmark using PR's version of the script:
+          bench-on: ${{ github.event.pull_request.head.sha }}

.github/workflows/tests.yml

@@ -67,7 +67,7 @@ jobs:
           python-version: ${{ matrix.pyversion }}
 
       - name: Set up uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
         with:
           python-version: ${{ matrix.pyversion }}
 

benchmark/Project.toml

@@ -0,0 +1,2 @@
+[deps]
+BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"

benchmark/benchmarks.jl

@@ -0,0 +1,62 @@
+using BenchmarkTools
+using PythonCall
+using PythonCall: pydel!, pyimport, pydict, pystr, pyrange
+
+const SUITE = BenchmarkGroup()
+
+function test_pydict_init()
+    random = pyimport("random").random
+    x = pydict()
+    for i in pyrange(1000)
+        x[pystr(i)] = i + random()
+    end
+    return x
+end
+
+SUITE["basic"]["julia"]["pydict"]["init"] = @benchmarkable test_pydict_init()
+
+function test_pydict_pydel()
+    random = pyimport("random").random
+    x = pydict()
+    for i in pyrange(1000)
+        k = pystr(i)
+        r = random()
+        v = i + r
+        x[k] = v
+        pydel!(k)
+        pydel!(r)
+        pydel!(v)
+        pydel!(i)
+    end
+    return x
+end
+
+SUITE["basic"]["julia"]["pydict"]["pydel"] = @benchmarkable test_pydict_pydel()
+
+@generated function test_atpy(::Val{use_pydel}) where {use_pydel}
+    quote
+        @py begin
+            import random: random
+            x = {}
+            for i in range(1000)
+                x[str(i)] = i + random()
+                $(use_pydel ? :(@jl PythonCall.pydel!(i)) : :(nothing))
+            end
+            x
+        end
+    end
+end
+
+SUITE["basic"]["@py"]["pydict"]["init"] = @benchmarkable test_atpy(Val(false))
+SUITE["basic"]["@py"]["pydict"]["pydel"] = @benchmarkable test_atpy(Val(true))
+
+
+include("gcbench.jl")
+using .GCBench: append_lots
+
+SUITE["gc"]["full"] = @benchmarkable(
+    GC.gc(true),
+    setup=(GC.gc(true); append_lots(size=159)),
+    seconds=30,
+    evals=1,
+)

benchmark/gcbench.jl

@@ -0,0 +1,13 @@
+module GCBench
+
+using PythonCall
+
+function append_lots(; iters=100 * 1024, size=1596)
+    v = pylist()
+    for i = 1:iters
+        v.append(pylist(rand(size)))
+    end
+    return v
+end
+
+end

docs/src/faq.md

@@ -10,14 +10,19 @@ To force PythonCall to use the same Python interpreter as PyCall, set the enviro
 
 Alternatively, to force PyCall to use the same interpreter as PythonCall, set the environment variable `PYTHON` to [`PythonCall.python_executable_path()`](@ref) and then `Pkg.build("PyCall")`. You will need to do this each time you change project, because PythonCall by default uses a different Python for each project.
 
-## Is PythonCall/JuliaCall thread safe?
+## [Is PythonCall/JuliaCall thread safe?](@id faq-multi-threading)
 
 Yes, as of v0.9.22, provided you handle the GIL correctly. See the guides for
 [PythonCall](@ref jl-multi-threading) and [JuliaCall](@ref py-multi-threading).
 
 Before, tricks such as disabling the garbage collector were required. See the
 [old docs](https://juliapy.github.io/PythonCall.jl/v0.9.21/faq/#Is-PythonCall/JuliaCall-thread-safe?).
 
+When starting a Julia REPL with multiple threads, there must be exactly one interactive thread,
+to avoid triggering a segmentation fault on tab completion (issue [#586](https://github.com/JuliaPy/PythonCall.jl/issues/586)).
+Check this with `Threads.nthreads(:interactive)` or `versioninfo()`, set it with `JULIA_NUM_THREADS=X,1`,
+where `X` is the number of default threads, or use the Julia `--threads` CLI flag, see `julia --help`.
+
 Related issues:
 [#201](https://github.com/JuliaPy/PythonCall.jl/issues/201),
 [#202](https://github.com/JuliaPy/PythonCall.jl/issues/202),

docs/src/pythoncall.md

@@ -392,6 +392,8 @@ Both `@unlock` and `@lock` are important. If the GIL were not unlocked, then a d
 would occur when attempting to lock the already-locked GIL from the threads. If the GIL
 were not re-locked, then Python would crash when interacting with it.
 
+With multiple Julia threads you need exactly one interactive thread, see the [FAQ](@ref faq-multi-threading).
+
 You can also use [multi-threading from Python](@ref py-multi-threading).
 
 ### Caveat: Garbage collection

src/Compat/gui.jl

@@ -7,26 +7,49 @@ This fixes the problem that Qt does not know where to find its `qt.conf` file, b
 always looks relative to `sys.executable`, which can be the Julia executable not the Python
 one when using this package.
 
-If `CONFIG.auto_fix_qt_plugin_path` is true, then this is run automatically before `PyQt4`, `PyQt5`, `PySide` or `PySide2` are imported.
+If `CONFIG.auto_fix_qt_plugin_path` is true, then this is run automatically before `PyQt4`, `PyQt5`, `PySide`, `PySide2` or `PySide6` are imported.
 """
 function fix_qt_plugin_path()
     C.CTX.exe_path === nothing && return false
     e = pyosmodule.environ
     "QT_PLUGIN_PATH" in e && return false
-    qtconf = joinpath(dirname(C.CTX.exe_path::AbstractString), "qt.conf")
-    isfile(qtconf) || return false
-    for line in eachline(qtconf)
-        m = match(r"^\s*prefix\s*=(.*)$"i, line)
-        if m !== nothing
-            path = strip(m.captures[1]::AbstractString)
-            path[1] == path[end] == '"' && (path = path[2:end-1])
-            path = joinpath(path, "plugins")
-            if isdir(path)
-                e["QT_PLUGIN_PATH"] = realpath(path)
-                return true
+    
+    exe_dir = dirname(C.CTX.exe_path::AbstractString)
+    
+    # Check for Qt6 configuration first (PySide6)
+    qt6conf = joinpath(exe_dir, "qt6.conf")
+    if isfile(qt6conf)
+        for line in eachline(qt6conf)
+            m = match(r"^\s*Libraries\s*=(.*)$"i, line)
+            if m !== nothing
+                path = strip(m.captures[1]::AbstractString)
+                path[1] == path[end] == '"' && (path = path[2:end-1])
+                path = joinpath(path, "qt6", "plugins")
+                if isdir(path)
+                    e["QT_PLUGIN_PATH"] = realpath(path)
+                    return true
+                end
+            end
+        end
+    end
+    
+    # Check for Qt5 configuration (PyQt4, PyQt5, PySide, PySide2)
+    qtconf = joinpath(exe_dir, "qt.conf")
+    if isfile(qtconf)
+        for line in eachline(qtconf)
+            m = match(r"^\s*prefix\s*=(.*)$"i, line)
+            if m !== nothing
+                path = strip(m.captures[1]::AbstractString)
+                path[1] == path[end] == '"' && (path = path[2:end-1])
+                path = joinpath(path, "plugins")
+                if isdir(path)
+                    e["QT_PLUGIN_PATH"] = realpath(path)
+                    return true
+                end
             end
         end
     end
+    
     return false
 end
 
@@ -65,7 +88,7 @@ function init_gui()
         pyexec(
             """
      def new_event_loop_callback(g, interval=0.04):
-         if g in ("pyqt4","pyqt5","pyside","pyside2"):
+         if g in ("pyqt4","pyqt5","pyside","pyside2","pyside6"):
              if g == "pyqt4":
                  import PyQt4.QtCore as QtCore
              elif g == "pyqt5":
@@ -74,6 +97,8 @@ function init_gui()
                  import PySide.QtCore as QtCore
              elif g == "pyside2":
                  import PySide2.QtCore as QtCore
+             elif g == "pyside6":
+                 import PySide6.QtCore as QtCore
              instance = QtCore.QCoreApplication.instance
              AllEvents = QtCore.QEventLoop.AllEvents
              processEvents = QtCore.QCoreApplication.processEvents
@@ -139,6 +164,7 @@ function init_gui()
         pymodulehooks.add_hook("PyQt5", fixqthook)
         pymodulehooks.add_hook("PySide", fixqthook)
         pymodulehooks.add_hook("PySide2", fixqthook)
+        pymodulehooks.add_hook("PySide6", fixqthook)
     end
 end
 
@@ -161,11 +187,11 @@ Activate an event loop for the GUI framework `g`, so that the framework can run
 
 The event loop runs every `interval` seconds. If `fix` is true and `g` is a Qt framework, then [`fix_qt_plugin_path`](@ref PythonCall.fix_qt_plugin_path) is called.
 
-Supported values of `g` (and the Python module they relate to) are: `:pyqt4` (PyQt4), `:pyqt5` (PyQt5), `:pyside` (PySide), `:pyside2` (PySide2), `:gtk` (gtk), `:gtk3` (gi), `:wx` (wx), `:tkinter` (tkinter).
+Supported values of `g` (and the Python module they relate to) are: `:pyqt4` (PyQt4), `:pyqt5` (PyQt5), `:pyside` (PySide), `:pyside2` (PySide2), `:pyside6` (PySide6), `:gtk` (gtk), `:gtk3` (gi), `:wx` (wx), `:tkinter` (tkinter).
 """
 function event_loop_on(g::Symbol; interval::Real = 0.04, fix::Bool = false)
     haskey(EVENT_LOOPS, g) && return EVENT_LOOPS[g]
-    fix && g in (:pyqt4, :pyqt5, :pyside, :pyside2) && fix_qt_plugin_path()
+    fix && g in (:pyqt4, :pyqt5, :pyside, :pyside2, :pyside6) && fix_qt_plugin_path()
     callback = new_event_loop_callback(string(g), Float64(interval))
     EVENT_LOOPS[g] = Timer(t -> callback(), 0; interval = interval)
 end

test/Compat.jl

@@ -5,7 +5,7 @@
         @test PythonCall.fix_qt_plugin_path() === false
     end
     @testset "event_loop_on/off" begin
-        for g in [:pyqt4, :pyqt5, :pyside, :pyside2, :gtk, :gtk3, :wx]
+        for g in [:pyqt4, :pyqt5, :pyside, :pyside2, :pyside6, :gtk, :gtk3, :wx]
             # TODO: actually test the various GUIs somehow?
             @show g
             @test_throws PyException PythonCall.event_loop_on(g)