Merge remote-tracking branch 'origin/main' into v1

Author: Christopher Rowley

.github/workflows/tests.yml

@@ -64,7 +64,7 @@ jobs:
       - name: Run tests
         uses: julia-actions/julia-runtest@v1
         env:
-          JULIA_DEBUG: PythonCall
+          JULIA_DEBUG: ${{ runner.debug == '1' && 'PythonCall' || '' }}
           JULIA_NUM_THREADS: '2'
           PYTHON: ${{ steps.setup-python.outputs.python-path }}
           JULIA_PYTHONCALL_EXE: ${{ case(matrix.pythonexe == 'python', steps.setup-python.outputs.python-path, matrix.pythonexe) }}

CHANGELOG.md

@@ -32,6 +32,15 @@
   * `pyjltype(x)` removed.
   * New functions: `pyjlarray`, `pyjldict`, `pyjlset`.
 
+## Unreleased
+* Add option `lib` to JuliaCall. Setting this will skip the discovery subprocess.
+* Add support for using a system image in `juliacall` that has `PythonCall` baked in.
+* Add method `pynext(x, d)` to return a default value `d` if there are no more elements.
+* Bug fixes.
+
+## 0.9.34 (2026-05-18)
+* Bug fixes.
+
 ## 0.9.33 (2026-05-18)
 * Add configuration via Preferences in addition to environment variables (e.g. `exe`
   rather than `JULIA_PYTHONCALL_EXE`.)

Project.toml

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

docs/src/juliacall.md

@@ -142,6 +142,7 @@ be configured in two ways:
 | `-X juliacall-heap-size-hint=<N>` | `PYTHON_JULIACALL_HEAP_SIZE_HINT=<N>` | Hint for initial heap size in bytes. |
 | `-X juliacall-exe=<file>` | `PYTHON_JULIACALL_EXE=<file>` | Path to Julia binary to use (overrides JuliaPkg). |
 | `-X juliacall-project=<dir>` | `PYTHON_JULIACALL_PROJECT=<dir>` | Path to the Julia project to use (overrides JuliaPkg). |
+| `-X juliacall-lib=<file>` | `PYTHON_JULIACALL_LIB=<file>` | Path to libjulia. Set to skip the relatively slow discovery process. |
 | `-X juliacall-trace-compile=<stderr\|name>` | `PYTHON_JULIACALL_TRACE_COMPILE=<stderr\|name>` | Print precompile statements. |
 | `-X juliacall-trace-compile-timing` | `PYTHON_JULIACALL_TRACE_COMPILE_TIMING=<yes\|no>` | Include timings with precompile statements. |
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "juliacall"
-version = "0.9.33"
+version = "0.9.34"
 description = "Julia and Python in seamless harmony"
 readme = { file = "README.md", content-type = "text/markdown" }
 classifiers = [
@@ -13,7 +13,7 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 requires-python = ">=3.10, <4"
-dependencies = ["juliapkg >=0.1.21, <0.2"]
+dependencies = ["juliapkg >=0.1.24, <0.2"]
 
 [dependency-groups]
 dev = [

pysrc/juliacall/__init__.py

@@ -1,7 +1,7 @@
 # This module gets modified by PythonCall when it is loaded, e.g. to include Core, Base
 # and Main modules.
 
-__version__ = '0.9.33'
+__version__ = '0.9.34'
 
 _newmodule = None
 
@@ -170,39 +170,47 @@ def args_from_config(config):
     CONFIG['opt_handle_signals'] = choice('handle_signals', ['yes', 'no'])[0]
     CONFIG['opt_startup_file'] = choice('startup_file', ['yes', 'no'])[0]
     CONFIG['opt_heap_size_hint'] = option('heap_size_hint')[0]
-    CONFIG['project'] = path_option('project', check_exists=True)[0]
-    CONFIG['exepath'] = executable_option('exe')[0]
+    CONFIG['project'] = project = path_option('project', check_exists=True)[0]
+    CONFIG['libpath'] = libpath = path_option('lib', check_exists=True)[0]
+    CONFIG['exepath'] = exepath = executable_option('exe')[0]
 
     # Stop if we already initialised
     if CONFIG['inited']:
         return
 
-    have_exepath = CONFIG['exepath'] is not None
-    have_project = CONFIG['project'] is not None
-    if have_exepath and have_project:
+    if (exepath is None) and (bindir is not None):
+        # if bindir is set then set exepath={bindir}/julia
+        CONFIG['exepath'] = exepath = os.path.join(bindir, 'julia.exe' if os.name == 'nt' else 'julia')
+    if (exepath is not None) and (project is not None):
         pass
-    elif (not have_exepath) and (not have_project):
+    elif (exepath is None) and (project is None):
         # we don't import this at the top level because it is not required when
         # juliacall is loaded by PythonCall and won't be available, or if both
         # `exepath` and `project` are set by the user.
         import juliapkg
 
         # Find the Julia executable and project
-        CONFIG['exepath'] = juliapkg.executable()
-        CONFIG['project'] = juliapkg.project()
+        CONFIG['exepath'] = exepath = juliapkg.executable()
+        CONFIG['project'] = project = juliapkg.project()
+        if libpath is None:
+            CONFIG['libpath'] = libpath = juliapkg.libjulia()
     else:
         raise Exception("Both PYTHON_JULIACALL_PROJECT and PYTHON_JULIACALL_EXE must be set together, not only one of them.")
-
-    exepath = CONFIG['exepath']
-    project = CONFIG['project']
-
-    # Find the Julia library
-    cmd = [exepath, '--project='+project, '--startup-file=no', '-O0', '--compile=min',
-           '-e', 'import Libdl; print(abspath(Libdl.dlpath("libjulia")), "\\0", Sys.BINDIR)']
-    libpath, default_bindir = subprocess.run(cmd, check=True, capture_output=True, encoding='utf8').stdout.split('\0')
+    if (libpath is not None) and (exepath is None):
+        raise Exception("PYTHON_JULIACALL_EXE is required if PYTHON_JULIACALL_LIB is set.")
+
+    # Find the Julia library, if not specified.
+    if libpath is None:
+        cmd = [exepath, '--project='+project, '--startup-file=no', '-O0', '--compile=min',
+               '-e', 'import Libdl; print(abspath(Libdl.dlpath("libjulia")), "\\0", Sys.BINDIR)']
+        libpath, found_bindir = subprocess.run(cmd, check=True, capture_output=True, encoding='utf8').stdout.split('\0')
+        CONFIG['libpath'] = libpath
+        if bindir is None:
+            CONFIG['bindir'] = bindir = found_bindir
+    if bindir is None:
+        bindir = os.path.dirname(exepath)
     assert os.path.exists(libpath)
-    assert os.path.exists(default_bindir)
-    CONFIG['libpath'] = libpath
+    assert os.path.exists(bindir)
 
     # Add the Julia library directory to the PATH on Windows so Julia's system libraries can
     # be found. They are normally found because they are in the same directory as julia.exe,
@@ -225,6 +233,11 @@ def args_from_config(config):
     jl_parse_opts(c.pointer(argc), c.pointer(argv))
     assert argc.value == 0
 
+    # override some environment variables
+    # we do this here because PythonCall is initialised during jl_init if it is in a sysimg
+    os.environ['JULIA_PYTHONCALL_EXECUTABLE'] = sys.executable or ''
+    os.environ['__JULIA_PYTHONCALL_EMBEDDED_LIBPTR__'] = hex(c.pythonapi._handle)
+
     # initialise julia
     try:
         jl_init = lib.jl_init_with_image__threading
@@ -233,7 +246,7 @@ def args_from_config(config):
     jl_init.argtypes = [c.c_char_p, c.c_char_p]
     jl_init.restype = None
     jl_init(
-        (default_bindir if bindir is None else bindir).encode('utf8'),
+        None if bindir is None else bindir.encode('utf8'),
         None if sysimg is None else sysimg.encode('utf8'),
     )
 
@@ -254,23 +267,22 @@ def jlstr(x):
         return 'raw"' + x + '"'
     script = '''
     try
-        Base.require(Main, :CompilerSupportLibraries_jll)
-        global __PythonCall_libptr = Ptr{{Cvoid}}(UInt({}))
-        ENV["JULIA_PYTHONCALL_EXE"] = {}
+        import CompilerSupportLibraries_jll as _
         using PythonCall
     catch err
         print(stderr, "ERROR: ")
         showerror(stderr, err, catch_backtrace())
         flush(stderr)
         rethrow()
     end
-    '''.format(
-        hex(c.pythonapi._handle),
-        jlstr(sys.executable or ''),
-    )
+    '''
     res = jl_eval(script.encode('utf8'))
     if res is None:
         raise Exception('PythonCall.jl did not start properly')
+    
+    # unset this env var so any other julia processes started do not think they are
+    # embedded in python
+    os.environ.pop('__JULIA_PYTHONCALL_EMBEDDED_LIBPTR__', None)
 
     CONFIG['inited'] = True
 

pysrc/juliacall/juliapkg-dev.json

@@ -3,7 +3,7 @@
     "packages": {
         "PythonCall": {
             "uuid": "6099a3de-0909-46bc-b1f4-468b9a2dfc0d",
-            "version": "=0.9.33",
+            "version": "=0.9.34",
             "path": "../..",
             "dev": true
         },

pysrc/juliacall/juliapkg.json

@@ -3,9 +3,7 @@
     "packages": {
         "PythonCall": {
             "uuid": "6099a3de-0909-46bc-b1f4-468b9a2dfc0d",
-            "version": "=0.9.33",
-            "path": "../..",
-            "dev": true
+            "version": "=0.9.34"
         },
         "OpenSSL_jll": {
             "uuid": "458c3c95-2e84-50aa-8efc-19380b2a3a95",

src/API/API.jl

@@ -1,5 +1,5 @@
 "The version of PythonCall."
-const VERSION = v"0.9.33"
+const VERSION = v"0.9.34"
 
 include("types.jl")
 include("functions.jl")

src/C/context.jl

@@ -105,11 +105,14 @@ on_main_thread
 
 function init_context()
 
-    CTX.is_embedded = hasproperty(Base.Main, :__PythonCall_libptr)
+    CTX.is_embedded = haskey(ENV, "__JULIA_PYTHONCALL_EMBEDDED_LIBPTR__")
 
     if CTX.is_embedded
         # In this case, getting a handle to libpython is easy
-        CTX.lib_ptr = Base.Main.__PythonCall_libptr::Ptr{Cvoid}
+        CTX.lib_ptr = Ptr{Cvoid}(parse(UInt, ENV["__JULIA_PYTHONCALL_EMBEDDED_LIBPTR__"]))
+        # Delete the env var so subprocesses don't think they are embedded
+        delete!(ENV, "__JULIA_PYTHONCALL_EMBEDDED_LIBPTR__")
+        # Initialise pointers from libpython
         init_pointers()
         # Check Python is initialized
         Py_IsInitialized() == 0 && error("Python is not already initialized.")