Merge remote-tracking branch 'origin' into api

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-nightly.yml

@@ -10,7 +10,7 @@ on:
 
 jobs:
   tests:
-    name: Test (${{ matrix.os }}-${{ matrix.arch }}, julia ${{ matrix.jlversion }})
+    name: Test Julia (${{ matrix.jlversion }}, ${{ matrix.os }}-${{ matrix.arch }})
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false

.github/workflows/tests.yml

@@ -12,70 +12,89 @@ on:
 
 jobs:
   julia:
-    name: Test (${{ matrix.os }}, julia ${{ matrix.jlversion }})
+    name: Test Julia (${{ matrix.jlversion }}, ${{ matrix.os }})
     runs-on: ${{ matrix.os }}
     strategy:
-      fail-fast: true
+      fail-fast: false
       matrix:
         arch: [x64] # x86 unsupported by MicroMamba
         os: [ubuntu-latest, windows-latest, macos-latest]
         jlversion: ['1','1.9']
+
     steps:
       - uses: actions/checkout@v4
+
       - name: Set up Julia ${{ matrix.jlversion }}
         uses: julia-actions/setup-julia@v2
         with:
           version: ${{ matrix.jlversion }}
           arch: ${{ matrix.arch }}
+
       - uses: julia-actions/cache@v2
+
       - name: Build package
         uses: julia-actions/julia-buildpkg@v1
+
       - name: Run tests
         uses: julia-actions/julia-runtest@v1
         env:
           JULIA_DEBUG: PythonCall
           JULIA_NUM_THREADS: '2'
+
       - name: Process coverage
         uses: julia-actions/julia-processcoverage@v1
+
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v5
         env:
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
   python:
-    name: Test (${{ matrix.os }}, python ${{ matrix.pyversion }})
+    name: Test Python (${{ matrix.pyversion }}, ${{ matrix.os }})
     runs-on: ${{ matrix.os }}
     strategy:
-      fail-fast: true
+      fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        pyversion: ["3.x", "3.8"]
+        pyversion: ["3", "3.9"]
+
     steps:
       - uses: actions/checkout@v4
+
       - name: Set up Python ${{ matrix.pyversion }}
         uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.pyversion }}
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v6
+        with:
+          python-version: ${{ matrix.pyversion }}
+  
       - name: Set up Julia
         uses: julia-actions/setup-julia@v2
         with:
           version: '1'
+
       - name: Install dependencies
         run: |
-          python -m pip install --upgrade pip
-          pip install flake8 pytest pytest-cov nbval numpy
           cp pysrc/juliacall/juliapkg-dev.json pysrc/juliacall/juliapkg.json
-          pip install -e .
+          uv sync --dev
+
       - name: Lint with flake8
         run: |
           # stop the build if there are Python syntax errors or undefined names
-          flake8 . --count --select=E9,F63,F7,F82 --ignore=F821 --show-source --statistics
+          uv run flake8 ./pysrc ./pytest --count --select=E9,F63,F7,F82 --ignore=F821 --show-source --statistics
           # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
-          flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+          uv run flake8 ./pysrc ./pytest --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+
       - name: Run tests
         run: |
-          pytest -s --nbval --cov=pysrc ./pytest/
+          uv run pytest -s --nbval --cov=pysrc ./pytest/
         env:
           PYTHON_JULIACALL_THREADS: '2'
+          PYTHON_JULIACALL_HANDLE_SIGNALS: 'yes'
+
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v5
         env:

CondaPkg.toml

@@ -6,4 +6,4 @@ version = "<=julia"
 
 [deps.python]
 build = "**cpython**"
-version = ">=3.8,<4"
+version = ">=3.9,<4"

Project.toml

@@ -1,7 +1,7 @@
 name = "PythonCall"
 uuid = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d"
 authors = ["Christopher Doris <github.com/cjdoris>"]
-version = "0.9.25"
+version = "0.9.26"
 
 [deps]
 CondaPkg = "992eb4ea-22a4-4c89-a5bb-47a3300528ab"

README.md

@@ -14,7 +14,7 @@ Bringing [**Python®**](https://www.python.org/) and [**Julia**](https://juliala
 - Fast non-copying conversion of numeric arrays in either direction: modify Python arrays (e.g. `bytes`, `array.array`, `numpy.ndarray`) from Julia or Julia arrays from Python.
 - Helpful wrappers: interpret Python sequences, dictionaries, arrays, dataframes and IO streams as their Julia counterparts, and vice versa.
 - Beautiful stack-traces.
-- Supports modern systems: tested on Windows, MacOS and Linux, 64-bit, Julia 1.9 upwards and Python 3.8 upwards.
+- Supports modern systems: tested on Windows, MacOS and Linux, 64-bit, Julia 1.9 upwards and Python 3.9 upwards.
 
 ⭐ If you like this, a GitHub star would be lovely thank you. ⭐
 

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),
@@ -89,3 +94,17 @@ Related issues: [#255](https://github.com/JuliaPy/PythonCall.jl/issues/255)
 Yes, it may be possible. A good example of that is having Julia running inside the Python that is running inside Blender, as presented in [this Discourse post](https://discourse.julialang.org/t/running-julia-inside-blender-through-vscode-using-pythoncall-juliacall/96838/6).
 From the point that one has JuliaCall running inside Python, if it has access to the terminal, one can even launch a Julia REPL there, and if needed connect with VSCode Julia extension to it.
 The full Python script to install, launch JuliaCall, and launch a Julia REPL in Blender is [here](https://gist.github.com/cdsousa/d820d27174238c0d48e5252355584172).
+
+## Using PythonCall.jl and CondaPkg.jl in a script
+
+If running from a script, make sure that [CondaPkg.jl](https://github.com/JuliaPy/CondaPkg.jl) is used before [PythonCall.jl](https://github.com/JuliaPy/PythonCall.jl) to ensure proper loading of Python packages in your path. E.g.,
+
+```julia
+using CondaPkg
+
+CondaPkg.add("numpy")
+
+using PythonCall
+
+np = pyimport("numpy")
+```