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

Christopher Doris · Christopher Doris · commit b81c389269ce · 2024-05-04T08:42:09.000+01:00
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
@@ -56,21 +56,21 @@ jobs:
       fail-fast: true
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        pyversion: ["3.x", "3.7"]
+        pyversion: ["3.x", "3.8"]
     steps:
       - uses: actions/checkout@v3
       - name: Set up Python ${{ matrix.pyversion }}
         uses: actions/setup-python@v4
         with:
           python-version: ${{ matrix.pyversion }}
-      - name: Set up Julia 1.10.0
+      - name: Set up Julia
         uses: julia-actions/setup-julia@v1
         with:
-          version: '1.10.0'
+          version: '1'
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install flake8 pytest pytest-cov
+          pip install flake8 pytest pytest-cov nbval numpy
           cp pysrc/juliacall/juliapkg-dev.json pysrc/juliacall/juliapkg.json
           pip install -e .
       - name: Lint with flake8
@@ -81,7 +81,7 @@ jobs:
           flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
       - name: Run tests
         run: |
-          pytest -s --cov=pysrc
+          pytest -s --nbval --cov=pysrc ./pytest/
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v2
         env:
diff --git a/CondaPkg.toml b/CondaPkg.toml
@@ -3,4 +3,4 @@ version = "<=julia"
 
 [deps.python]
 build = "**cpython**"
-version = ">=3.7,<4"
+version = ">=3.8,<4"
diff --git a/Project.toml b/Project.toml
@@ -1,7 +1,7 @@
 name = "PythonCall"
 uuid = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d"
 authors = ["Christopher Doris <github.com/cjdoris>"]
-version = "0.9.17"
+version = "0.9.20"
 
 [deps]
 CondaPkg = "992eb4ea-22a4-4c89-a5bb-47a3300528ab"
diff --git a/README.md b/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.6.1 upwards and Python 3.7 upwards.
+- Supports modern systems: tested on Windows, MacOS and Linux, 64-bit, Julia 1.6.1 upwards and Python 3.8 upwards.
 
 ⭐ If you like this, a GitHub star would be lovely thank you. ⭐
 
@@ -45,4 +45,4 @@ The existing package [PyCall](https://github.com/JuliaPy/PyCall.jl) is another s
 - PythonCall by default never copies mutable objects when converting, but instead directly wraps the mutable object. This means that modifying the converted object modifies the original, and conversion is faster.
 - PythonCall does not usually automatically convert results to Julia values, but leaves them as Python objects. This makes it easier to do Pythonic things with these objects (e.g. accessing methods) and is type-stable.
 - PythonCall installs dependencies into a separate Conda environment for each Julia project. This means each Julia project can have an isolated set of Python dependencies.
-- PythonCall supports Julia 1.6.1+ and Python 3.7+ whereas PyCall supports Julia 0.7+ and Python 2.7+.
+- PythonCall supports Julia 1.6.1+ and Python 3.8+ whereas PyCall supports Julia 0.7+ and Python 2.7+.
diff --git a/docs/src/compat.md b/docs/src/compat.md
@@ -67,8 +67,9 @@ The `juliacall` IPython extension adds these features to your IPython session:
 
 The extension is experimental and unstable - the API can change at any time.
 
-Enable the extension with `%load_ext juliacall`.
-See [the IPython docs](https://ipython.readthedocs.io/en/stable/config/extensions/).
+You can explicitly enable the extension with `%load_ext juliacall`, but
+it will automatically be loaded if `juliacall` is imported and IPython is detected.
+You can disable this behavior with an [environment variable](@ref julia-config).
 
 The `%%julia` cell magic can synchronise variables between Julia and Python by listing them
 on the first line:
@@ -88,6 +89,9 @@ In [5]: z
 Out[5]: '2^8 = 256'
 ```
 
+Also see [the IPython docs](https://ipython.readthedocs.io/en/stable/config/extensions/)
+for more information on extensions.
+
 ## Asynchronous Julia code (including Makie)
 
 Asynchronous Julia code will not normally run while Python is executing, unless it is in a
diff --git a/docs/src/index.md b/docs/src/index.md
@@ -7,4 +7,4 @@ 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.
-- Works anywhere: tested on Windows, MacOS and Linux, 32- and 64-bit, Julia Julia 1.6.1 upwards and Python 3.7 upwards.
+- Works anywhere: tested on Windows, MacOS and Linux, 32- and 64-bit, Julia Julia 1.6.1 upwards and Python 3.8 upwards.
diff --git a/docs/src/juliacall.md b/docs/src/juliacall.md
@@ -123,3 +123,4 @@ be configured in two ways:
 | `-X juliacall-sysimage=<file>` | `PYTHON_JULIACALL_SYSIMAGE=<file>` | Use the given system image. |
 | `-X juliacall-threads=<N\|auto>` | `PYTHON_JULIACALL_THREADS=<N\|auto>` | Launch N threads. |
 | `-X juliacall-warn-overwrite=<yes\|no>` | `PYTHON_JULIACALL_WARN_OVERWRITE=<yes\|no>` | Enable or disable method overwrite warnings. |
+| `-X juliacall-autoload-ipython-extension=<yes\|no>` | `PYTHON_JULIACALL_AUTOLOAD_IPYTHON_EXTENSION=<yes\|no>` | Enable or disable IPython extension autoloading. |
diff --git a/docs/src/pycall.md b/docs/src/pycall.md
@@ -72,4 +72,4 @@ Note also that JuliaCall will use a separate Julia project for each virtual/cond
 
 ### Compatibility
 
-PyCall supports Julia 0.7+ and Python 2.7+, whereas PythonCall supports Julia 1.6.1+ and Python 3.7+. PyCall requires numpy to be installed, PythonCall doesn't (it provides the same fast array access through the buffer protocol and array interface).
+PyCall supports Julia 0.7+ and Python 2.7+, whereas PythonCall supports Julia 1.6.1+ and Python 3.8+. PyCall requires numpy to be installed, PythonCall doesn't (it provides the same fast array access through the buffer protocol and array interface).
diff --git a/docs/src/releasenotes.md b/docs/src/releasenotes.md
@@ -3,6 +3,17 @@
 ## Unreleased (v1)
 * `PythonCall.GC` is now more like `Base.GC`: `enable(true)` replaces `enable()`, `enable(false)` replaces `disable()`, and `gc()` is added.
 
+## 0.9.20 (2024-05-01)
+* The IPython extension is now automatically loaded upon import if IPython is detected.
+* JuliaCall now compatible with Julia 1.10.3.
+* Minimum supported Python version is now 3.8.
+
+## 0.9.19 (2024-03-19)
+* Bug fixes.
+
+## 0.9.18 (2024-03-18)
+* Bug fixes.
+
 ## 0.9.17 (2024-03-16)
 * Bug fixes.
 
diff --git a/pysrc/juliacall/__init__.py b/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.17'
+__version__ = '0.9.20'
 
 _newmodule = None
 
@@ -248,8 +248,30 @@ def jlstr(x):
                 "PYTHON_JULIACALL_HANDLE_SIGNALS=no."
             )
 
-init()
+    # Next, automatically load the juliacall extension if we are in IPython or Jupyter
+    CONFIG['autoload_ipython_extension'] = choice('autoload_ipython_extension', ['yes', 'no'])[0]
+    if CONFIG['autoload_ipython_extension'] in {'yes', None}:
+        try:
+            get_ipython = sys.modules['IPython'].get_ipython
+
+            if CONFIG['autoload_ipython_extension'] is None:
+                # Only let the user know if it was not explicitly set
+                print(
+                    "Detected IPython. Loading juliacall extension. See https://juliapy.github.io/PythonCall.jl/stable/compat/#IPython"
+                )
+
+            load_ipython_extension(get_ipython())
+        except Exception as e:
+            if CONFIG['autoload_ipython_extension'] == 'yes':
+                # Only warn if the user explicitly requested the extension to be loaded
+                warnings.warn(
+                    "Could not load juliacall extension in Jupyter notebook: " + str(e)
+                )
+            pass
+
 
 def load_ipython_extension(ip):
     import juliacall.ipython
     juliacall.ipython.load_ipython_extension(ip)
+
+init()
diff --git a/pysrc/juliacall/juliapkg-dev.json b/pysrc/juliacall/juliapkg-dev.json
@@ -1,9 +1,9 @@
 {
-    "julia": "~1.6.1, ~1.7, ~1.8, ~1.9, =1.10.0",
+    "julia": "~1.6.1, ~1.7, ~1.8, ~1.9, =1.10.0, ^1.10.3",
     "packages": {
         "PythonCall": {
             "uuid": "6099a3de-0909-46bc-b1f4-468b9a2dfc0d",
-            "version": "=0.9.17",
+            "version": "=0.9.20",
             "path": "../..",
             "dev": true
         }
diff --git a/pysrc/juliacall/juliapkg.json b/pysrc/juliacall/juliapkg.json
@@ -1,9 +1,9 @@
 {
-    "julia": "~1.6.1, ~1.7, ~1.8, ~1.9, =1.10.0",
+    "julia": "~1.6.1, ~1.7, ~1.8, ~1.9, =1.10.0, ^1.10.3",
     "packages": {
         "PythonCall": {
             "uuid": "6099a3de-0909-46bc-b1f4-468b9a2dfc0d",
-            "version": "=0.9.17"
+            "version": "=0.9.20"
         }
     }
 }
diff --git a/pytest/test_nb.ipynb b/pytest/test_nb.ipynb
@@ -0,0 +1,139 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# NBVAL_IGNORE_OUTPUT\n",
+    "import numpy as np\n",
+    "from juliacall import Main as jl"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%julia\n",
+    "\n",
+    "# Automatically activates Julia magic\n",
+    "\n",
+    "x = 1\n",
+    "println(x + 2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4\n"
+     ]
+    }
+   ],
+   "source": [
+    "%julia println(x + 3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1.0"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "jl.cos(0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "f (generic function with 1 method)"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%julia\n",
+    "\n",
+    "function f(x::AbstractArray)\n",
+    "    sum(x)\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "6"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "jl.f(np.array([1, 2, 3]))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/setup.cfg b/setup.cfg
@@ -1,6 +1,6 @@
 [metadata]
 name = juliacall
-version = 0.9.17
+version = 0.9.20
 description = Julia and Python in seamless harmony
 long_description = file: README.md
 long_description_content_type = text/markdown
@@ -15,7 +15,7 @@ zip_safe = False
 package_dir =
     =pysrc
 packages = juliacall
-python_requires = ~=3.7
+python_requires = ~=3.8
 install_requires =
     juliapkg ~=0.1.8
 
diff --git a/src/Compat/Compat.jl b/src/Compat/Compat.jl
@@ -6,7 +6,7 @@ Misc bits and bobs for compatibility.
 module Compat
     using ..PythonCall: PythonCall  # needed for docstring cross-refs
     using ..Core
-    using ..Core: C, Utils, pynew, incref, getptr, pycopy!, pymodulehooks, pyisnull, pybytes_asvector, pysysmodule, pyosmodule, pystr_fromUTF8
+    using ..Core: Core, C, Utils, pynew, incref, getptr, pycopy!, pymodulehooks, pyisnull, pybytes_asvector, pysysmodule, pyosmodule, pystr_fromUTF8
     using ..Convert: pyconvert, @pyconvert
     using ..Wrap: PyArray, PyPandasDataFrame
     using Serialization: Serialization, AbstractSerializer, serialize, deserialize
diff --git a/src/Compat/gui.jl b/src/Compat/gui.jl
@@ -130,7 +130,7 @@ function init_gui()
         pycopy!(new_event_loop_callback, g["new_event_loop_callback"])
 
         # add a hook to automatically call fix_qt_plugin_path()
-        fixqthook = Py(() -> (_Py.CONFIG.auto_fix_qt_plugin_path && fix_qt_plugin_path(); nothing))
+        fixqthook = Py(() -> (Core.CONFIG.auto_fix_qt_plugin_path && fix_qt_plugin_path(); nothing))
         pymodulehooks.add_hook("PyQt4", fixqthook)
         pymodulehooks.add_hook("PyQt5", fixqthook)
         pymodulehooks.add_hook("PySide", fixqthook)
diff --git a/src/Compat/pycall.jl b/src/Compat/pycall.jl
@@ -10,7 +10,7 @@ function init_pycall(PyCall::Module)
     - Set the environment variable `PYTHON` to `PythonCall.C.CTX.exe_path` and rebuild PyCall. This forces PyCall
       to use the same interpreter as PythonCall, but needs to be repeated whenever you switch Julia environment.
     """
-    @eval function _Py.Py(x::$PyCall.PyObject)
+    @eval function Core.Py(x::$PyCall.PyObject)
         C.CTX.matches_pycall::Bool || error($errmsg)
         return pynew(C.PyPtr($PyCall.pyreturn(x)))
     end
diff --git a/src/Core/Core.jl b/src/Core/Core.jl
@@ -5,7 +5,7 @@ Defines the `Py` type and directly related functions.
 """
 module Core
 
-const VERSION = v"0.9.17"
+const VERSION = v"0.9.20"
 const ROOT_DIR = dirname(dirname(@__DIR__))
 
 using ..PythonCall: PythonCall  # needed for docstring cross-refs
@@ -14,7 +14,7 @@ using ..GC: GC
 using ..Utils: Utils
 using Base: @propagate_inbounds, @kwdef
 using Dates: Date, Time, DateTime, year, month, day, hour, minute, second, millisecond, microsecond, nanosecond
-using MacroTools: @capture
+using MacroTools: MacroTools, @capture
 using Markdown: Markdown
 
 include("Py.jl")
diff --git a/src/JlWrap/JlWrap.jl b/src/JlWrap/JlWrap.jl
@@ -9,6 +9,7 @@ using ..PythonCall: PythonCall
 using ..Core
 using ..Core: C, Utils, pynew, @autopy, incref, decref, setptr!, getptr, pyjuliacallmodule, pycopy!, errcheck, errset, PyNULL, pyistuple, pyisnull, pyJuliaError, pydel!, pyistype, pytypecheck, pythrow, pytuple_getitem, pyisslice, pystr_asstring, pyosmodule, pyisstr
 using ..Convert: pyconvert, @pyconvert, PYCONVERT_PRIORITY_WRAP, pyconvert_add_rule, pyconvert_tryconvert, pyconvertarg, pyconvert_result
+using ..GC: GC
 
 using Pkg: Pkg
 using Base: @propagate_inbounds, allocatedinline
diff --git a/src/JlWrap/objectarray.jl b/src/JlWrap/objectarray.jl
diff --git a/src/PythonCall.jl b/src/PythonCall.jl
diff --git a/src/Utils/Utils.jl b/src/Utils/Utils.jl
diff --git a/test/Core.jl b/test/Core.jl
diff --git a/test/Utils.jl b/test/Utils.jl

Original file line number	Diff line number	Diff line change
`@@ -72,4 +72,4 @@ Note also that JuliaCall will use a separate Julia project for each virtual/cond`
`72`	`72`
`73`	`73`	`### Compatibility`
`74`	`74`
`75`		`-PyCall supports Julia 0.7+ and Python 2.7+, whereas PythonCall supports Julia 1.6.1+ and Python 3.7+. PyCall requires numpy to be installed, PythonCall doesn't (it provides the same fast array access through the buffer protocol and array interface).`
	`75`	`+PyCall supports Julia 0.7+ and Python 2.7+, whereas PythonCall supports Julia 1.6.1+ and Python 3.8+. PyCall requires numpy to be installed, PythonCall doesn't (it provides the same fast array access through the buffer protocol and array interface).`