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

Author: Christopher Rowley

.github/workflows/tests.yml

@@ -57,20 +57,23 @@ jobs:
         uses: julia-actions/julia-buildpkg@v1
         env:
           PYTHON: python
-      
+
       - name: Install Python
         id: setup-python
         uses: actions/setup-python@v7
         if: ${{ matrix.pythonexe == 'python' }}
         with:
           python-version: ${{ matrix.pyversion }}
 
+      # Always build PyCall (and hence Conda) so that Conda's root env directory exists;
+      # otherwise Conda fails to precompile on cached runners, which can cause errors.
+      # Use a temporary environment because `--project=test` has no manifest on Julia
+      # versions without workspace support (< 1.12).
       - name: Build PyCall
-        if: ${{ matrix.pythonexe == 'python' }}
         run: |
-          julia --project=test -e 'import Pkg; Pkg.build("PyCall")'
+          julia -e 'import Pkg; Pkg.activate(temp=true); Pkg.add("PyCall"); Pkg.build("Conda"); Pkg.build("PyCall")'
         env:
-          PYTHON: ${{ steps.setup-python.outputs.python-path }}
+          PYTHON: ${{ case(matrix.pythonexe == 'python', steps.setup-python.outputs.python-path, 'python') }}
 
       - name: Run tests
         uses: julia-actions/julia-runtest@v1
@@ -116,7 +119,7 @@ jobs:
         uses: actions/setup-python@v7
         with:
           python-version: ${{ matrix.pyversion }}
-      
+
       # - name: Check Python OpenSSL version (see setup_julia)
       #   shell: python
       #   run: |

AGENTS.md

@@ -21,6 +21,10 @@ The majority of tests live in the Julia package; Python tests cover functionalit
 
 ## Branch and CI compatibility
 - On `v1`, JuliaCall uses `jl_eval` (returning a Julia wrapper), whereas `main` uses `seval`. Adapt tests brought over from `main` accordingly.
+- The `v1` Python wrapper hierarchy uses `JlBase`, `Jl`, and `JlCollection`, unlike
+  `main`'s `ValueBase`/`AnyValue` hierarchy. Keep the collection wrapper when porting
+  `_jlwrap` changes. Wrapper modules load before `juliacall.Base` is assigned, so
+  constructors must look it up through `juliacall` when called.
 - The benchmark suite is shared across the compared revisions: `main` uses `pydel!`, while `v1` uses `unsafe_pydel`.
 - `main` does not have `@pyregion`. Benchmark region wrappers must select a plain-body fallback before macro expansion; a runtime conditional around an unavailable macro still fails when loading the suite.
 - Julia CI caches can preserve Conda's build metadata without its root environment. Rebuild `Conda` before building `PyCall` or running tests to recreate that directory.

CHANGELOG.md

@@ -46,6 +46,8 @@
   * New functions: `pyjlarray`, `pyjldict`, `pyjlset`.
 
 ## Unreleased
+* Add `exe=@ENV` preference to read `JULIA_PYTHONCALL_EXE` without loading CondaPkg.
+* Improved TTFX in JuliaCall.
 * Minimum supported Python version is now 3.11.
 
 ## 0.9.37 (2026-10-12)

docs/src/pythoncall.md

@@ -310,6 +310,9 @@ special values:
 - `@CondaPkg`: Use Python from CondaPkg (the default).
 - `@PyCall`: Use the same Python as PyCall. [See here](@ref faq-pycall).
 - `@venv`: Use Python from a `.venv` virtual environment in the current active project.
+- `@ENV` (preference only): Use `JULIA_PYTHONCALL_EXE`, which must be set to a Python
+  executable path or command name (see below). Avoids loading CondaPkg while allowing
+  Python environments to be changed via the environment variable.
 
 Otherwise, the value is interpreted as:
 - An absolute path to a Python executable.

pysrc/juliacall/__init__.py

@@ -37,6 +37,24 @@ def exception(self):
     def backtrace(self):
         return self.args[1]
 
+def _init_jlwrap():
+    # Called by PythonCall once the native JlBase type is available.
+    global JlBase2, JlIter, Jl, JlCollection, JlArray, JlVector, JlDict, JlSet, JlIOBase, JlBinaryIO, JlTextIO
+    from ._jlwrap import (
+        JlBase2,
+        JlIter,
+        Jl,
+        JlCollection,
+        JlArray,
+        JlVector,
+        JlDict,
+        JlSet,
+        JlIOBase,
+        JlBinaryIO,
+        JlTextIO,
+    )
+
+
 CONFIG = {'inited': False}
 
 def init():

pysrc/juliacall/_jlwrap/__init__.py

@@ -0,0 +1,9 @@
+"""Python implementations of Julia wrappers, initialized by PythonCall."""
+
+from .any import JlBase2, JlIter, Jl
+from .collection import JlCollection
+from .array import JlArray
+from .vector import JlVector
+from .dict import JlDict
+from .set import JlSet
+from .io import JlIOBase, JlBinaryIO, JlTextIO

pysrc/juliacall/_jlwrap/any.py

@@ -0,0 +1,185 @@
+"""Julia wrappers initialized by PythonCall."""
+
+from juliacall import JlBase
+
+# Populated by Julia during initialization.
+_jl_methods = {}
+
+
+class JlBase2(JlBase):
+    __module__ = "juliacall"
+    __slots__ = ()
+    def __repr__(self):
+        t = type(self)
+        if t is Jl:
+            name = "Julia"
+        else:
+            name = t.__name__
+        return name + ":" + self._jl_callmethod(_jl_methods["__repr__"])
+class JlIter(JlBase2):
+    __module__ = "juliacall"
+    __slots__ = ()
+    def __iter__(self):
+        return self
+    def __hash__(self):
+        return self._jl_callmethod(_jl_methods["__hash__"])
+    def __next__(self):
+        return self._jl_callmethod(_jl_methods["iterator_next"])
+class Jl(JlBase2):
+    __module__ = "juliacall"
+    __slots__ = ()
+    def __str__(self):
+        return self._jl_callmethod(_jl_methods["__str__"])
+    def __getattr__(self, k):
+        if k.startswith("__") and k.endswith("__"):
+            raise AttributeError(k)
+        else:
+            return self._jl_callmethod(_jl_methods["__getattr__"], k)
+    def __setattr__(self, k, v):
+        try:
+            JlBase.__setattr__(self, k, v)
+        except AttributeError:
+            if k.startswith("__") and k.endswith("__"):
+                raise
+        else:
+            return
+        self._jl_callmethod(_jl_methods["__setattr__"], k, v)
+    def __dir__(self):
+        return JlBase.__dir__(self) + self._jl_callmethod(_jl_methods["__dir__"])
+    def __call__(self, *args, **kwargs):
+        return self._jl_callmethod(_jl_methods["__call__"], args, kwargs)
+    def __bool__(self):
+        return self._jl_callmethod(_jl_methods["__bool__"])
+    def __len__(self):
+        return self._jl_callmethod(_jl_methods["__len__"])
+    def __getitem__(self, k):
+        return self._jl_callmethod(_jl_methods["__getitem__"], k)
+    def __setitem__(self, k, v):
+        self._jl_callmethod(_jl_methods["__setitem__"], k, v)
+    def __delitem__(self, k):
+        self._jl_callmethod(_jl_methods["__delitem__"], k)
+    def __iter__(self):
+        return self._jl_callmethod(_jl_methods["__iter__"])
+    def __next__(self):
+        return self._jl_callmethod(_jl_methods["__next__"])
+    def __reversed__(self):
+        return self._jl_callmethod(_jl_methods["__reversed__"])
+    def __contains__(self, v):
+        return self._jl_callmethod(_jl_methods["__contains__"], v)
+    def __pos__(self):
+        return self._jl_callmethod(_jl_methods["__pos__"])
+    def __neg__(self):
+        return self._jl_callmethod(_jl_methods["__neg__"])
+    def __abs__(self):
+        return self._jl_callmethod(_jl_methods["__abs__"])
+    def abs(self):
+        return self._jl_callmethod(_jl_methods["__abs__"])
+    def __invert__(self):
+        return self._jl_callmethod(_jl_methods["__invert__"])
+    def __add__(self, other):
+        return self._jl_callmethod(_jl_methods["__add__"], other)
+    def __sub__(self, other):
+        return self._jl_callmethod(_jl_methods["__sub__"], other)
+    def __mul__(self, other):
+        return self._jl_callmethod(_jl_methods["__mul__"], other)
+    def __truediv__(self, other):
+        return self._jl_callmethod(_jl_methods["__truediv__"], other)
+    def __floordiv__(self, other):
+        return self._jl_callmethod(_jl_methods["__floordiv__"], other)
+    def __mod__(self, other):
+        return self._jl_callmethod(_jl_methods["__mod__"], other)
+    def __pow__(self, other, modulo=None):
+        if modulo is None:
+            return self._jl_callmethod(_jl_methods["__pow__"], other)
+        else:
+            return self._jl_callmethod(_jl_methods["__pow_modulo__"], other, modulo)
+    def __lshift__(self, other):
+        return self._jl_callmethod(_jl_methods["__lshift__"], other)
+    def __rshift__(self, other):
+        return self._jl_callmethod(_jl_methods["__rshift__"], other)
+    def __and__(self, other):
+        return self._jl_callmethod(_jl_methods["__and__"], other)
+    def __xor__(self, other):
+        return self._jl_callmethod(_jl_methods["__xor__"], other)
+    def __or__(self, other):
+        return self._jl_callmethod(_jl_methods["__or__"], other)
+    def __radd__(self, other):
+        return self._jl_callmethod(_jl_methods["__radd__"], other)
+    def __rsub__(self, other):
+        return self._jl_callmethod(_jl_methods["__rsub__"], other)
+    def __rmul__(self, other):
+        return self._jl_callmethod(_jl_methods["__rmul__"], other)
+    def __rtruediv__(self, other):
+        return self._jl_callmethod(_jl_methods["__rtruediv__"], other)
+    def __rfloordiv__(self, other):
+        return self._jl_callmethod(_jl_methods["__rfloordiv__"], other)
+    def __rmod__(self, other):
+        return self._jl_callmethod(_jl_methods["__rmod__"], other)
+    def __rpow__(self, other, modulo=None):
+        if modulo is None:
+            return self._jl_callmethod(_jl_methods["__rpow__"], other)
+        else:
+            return self._jl_callmethod(_jl_methods["__rpow_modulo__"], other, modulo)
+    def __rlshift__(self, other):
+        return self._jl_callmethod(_jl_methods["__rlshift__"], other)
+    def __rrshift__(self, other):
+        return self._jl_callmethod(_jl_methods["__rrshift__"], other)
+    def __rand__(self, other):
+        return self._jl_callmethod(_jl_methods["__rand__"], other)
+    def __rxor__(self, other):
+        return self._jl_callmethod(_jl_methods["__rxor__"], other)
+    def __ror__(self, other):
+        return self._jl_callmethod(_jl_methods["__ror__"], other)
+    def __hash__(self):
+        return self._jl_callmethod(_jl_methods["__hash__"])
+    def __eq__(self, other):
+        return self._jl_callmethod(_jl_methods["__eq__"], other)
+    def __ne__(self, other):
+        return self._jl_callmethod(_jl_methods["__ne__"], other)
+    def __le__(self, other):
+        return self._jl_callmethod(_jl_methods["__le__"], other)
+    def __lt__(self, other):
+        return self._jl_callmethod(_jl_methods["__lt__"], other)
+    def __ge__(self, other):
+        return self._jl_callmethod(_jl_methods["__ge__"], other)
+    def __gt__(self, other):
+        return self._jl_callmethod(_jl_methods["__gt__"], other)
+    def __int__(self):
+        return self._jl_callmethod(_jl_methods["__int__"])
+    def __float__(self):
+        return self._jl_callmethod(_jl_methods["__float__"])
+    def __complex__(self):
+        return self._jl_callmethod(_jl_methods["__complex__"])
+    def __index__(self):
+        return self._jl_callmethod(_jl_methods["__index__"])
+    def __trunc__(self):
+        return self._jl_callmethod(_jl_methods["__trunc__"])
+    def __floor__(self):
+        return self._jl_callmethod(_jl_methods["__floor__"])
+    def __ceil__(self):
+        return self._jl_callmethod(_jl_methods["__ceil__"])
+    def __round__(self, ndigits=None):
+        if ndigits is None:
+            return self._jl_callmethod(_jl_methods["__round__"])
+        else:
+            return self._jl_callmethod(_jl_methods["__round__"], ndigits)
+    @property
+    def __name__(self):
+        return self._jl_callmethod(_jl_methods["__name__"])
+    def jl_display(self, mime=None):
+        '''Display this, optionally specifying the MIME type.'''
+        return self._jl_callmethod(_jl_methods["jl_display"], mime)
+    def jl_help(self, mime=None):
+        '''Show help for this Julia object.'''
+        return self._jl_callmethod(_jl_methods["jl_help"], mime)
+    def jl_eval(self, expr):
+        return self._jl_callmethod(_jl_methods["jl_eval"], expr)
+    def jl_to_py(self):
+        return self._jl_callmethod(_jl_methods["jl_to_py"])
+    def jl_callback(self, *args, **kwargs):
+        return self._jl_callmethod(_jl_methods["jl_callback"], args, kwargs)
+    def _repr_mimebundle_(self, include=None, exclude=None):
+        return self._jl_callmethod(_jl_methods["_repr_mimebundle_"], include, exclude)
+    @property
+    def __numpy_dtype__(self):
+        return self._jl_callmethod(_jl_methods["__numpy_dtype__"])

pysrc/juliacall/_jlwrap/array.py

@@ -0,0 +1,50 @@
+"""Julia wrappers initialized by PythonCall."""
+
+import juliacall as jl
+from juliacall import JlBase
+from .collection import JlCollection
+
+# Populated by Julia during initialization.
+_jl_methods = {}
+
+
+class JlArray(JlCollection):
+    __module__ = "juliacall"
+    __slots__ = ()
+    _jl_buffer_info = None
+    def __init__(self, value):
+        JlBase.__init__(self, value, jl.Base.AbstractArray)
+    @property
+    def ndim(self):
+        return self._jl_callmethod(_jl_methods["ndim"])
+    @property
+    def shape(self):
+        return self._jl_callmethod(_jl_methods["shape"])
+    def reshape(self, shape):
+        return self._jl_callmethod(_jl_methods["reshape"], shape)
+    def __getitem__(self, k):
+        return self._jl_callmethod(_jl_methods["__getitem__"], k)
+    def __setitem__(self, k, v):
+        self._jl_callmethod(_jl_methods["__setitem__"], k, v)
+    def __delitem__(self, k):
+        self._jl_callmethod(_jl_methods["__delitem__"], k)
+    @property
+    def __array_interface__(self):
+        return self._jl_callmethod(_jl_methods["__array_interface__"])
+    def __array__(self, dtype=None, copy=None):
+        import numpy
+        # convert to an array-like object
+        arr = self
+        if not (hasattr(arr, "__array_interface__") or hasattr(arr, "__array_struct__")):
+            if copy is False:
+                raise ValueError("copy=False is not supported when collecting ArrayValue data")
+            # the first attempt collects into an Array
+            arr = self._jl_callmethod(_jl_methods["__array__"])
+            if not (hasattr(arr, "__array_interface__") or hasattr(arr, "__array_struct__")):
+                # the second attempt collects into a PyObjectArray
+                arr = self._jl_callmethod(_jl_methods["__array___2"])
+        # convert to a numpy array if numpy is available
+        return numpy.array(arr, dtype=dtype, copy=copy)
+    def to_numpy(self, dtype=None, copy=True, order="K"):
+        import numpy
+        return numpy.array(self, dtype=dtype, copy=copy, order=order)

pysrc/juliacall/_jlwrap/callback.py

@@ -0,0 +1,5 @@
+"""Helpers for wrapping Julia callbacks as Python functions."""
+
+
+def wrap_callback(f):
+    return lambda *args, **kwargs: f(*args, **kwargs)

pysrc/juliacall/_jlwrap/collection.py

@@ -0,0 +1,34 @@
+"""Julia wrappers initialized by PythonCall."""
+
+from juliacall import JlBase
+from .any import JlBase2
+
+# Populated by Julia during initialization.
+_jl_methods = {}
+
+
+class JlCollection(JlBase2):
+    __module__ = "juliacall"
+    __slots__ = ()
+    def __len__(self):
+        return self._jl_callmethod(_jl_methods["__len__"])
+    def __bool__(self):
+        return self._jl_callmethod(_jl_methods["__bool__"])
+    def __iter__(self):
+        return self._jl_callmethod(_jl_methods["__iter__"])
+    def __hash__(self):
+        return self._jl_callmethod(_jl_methods["__hash__"])
+    def __eq__(self, other):
+        if isinstance(self, type(other)) or isinstance(other, type(self)):
+            return self._jl_callmethod(_jl_methods["__eq__"], other)
+        else:
+            return NotImplemented
+    def __contains__(self, v):
+        return self._jl_callmethod(_jl_methods["__contains__"], v)
+    def copy(self):
+        return self._jl_callmethod(_jl_methods["copy"])
+    def clear(self):
+        return self._jl_callmethod(_jl_methods["clear"])
+import collections.abc
+collections.abc.Collection.register(JlCollection)
+del collections