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

Christopher Rowley · Christopher Rowley · commit 2d0f36eaa737 · 2026-01-23T22:13:07.000Z
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
@@ -17,7 +17,7 @@ jobs:
     name: Documentation
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: julia-actions/setup-julia@v2
         with:
           version: '1'
diff --git a/.github/workflows/docscleanup.yml b/.github/workflows/docscleanup.yml
@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout gh-pages branch
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         with:
           ref: gh-pages
 
diff --git a/.github/workflows/register-pypi.yml b/.github/workflows/register-pypi.yml
@@ -11,7 +11,7 @@ jobs:
   register:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v6
       with:
         ref: ${{ inputs.git_ref }}
     - name: Set up Python
diff --git a/.github/workflows/tests-nightly.yml b/.github/workflows/tests-nightly.yml
@@ -19,12 +19,12 @@ jobs:
         os: [ubuntu-latest, windows-latest, macos-latest]
         jlversion: ['~1.9.0-0', 'nightly']
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: julia-actions/setup-julia@v2
         with:
           version: ${{ inputs.jl_version }}
           arch: ${{ matrix.arch }}
-      - uses: actions/cache@v4
+      - uses: actions/cache@v5
         env:
           cache-name: cache-artifacts
         with:
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
@@ -29,7 +29,7 @@ jobs:
           pythonexe: python
 
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
 
       - name: Set up Julia ${{ matrix.jlversion }}
         uses: julia-actions/setup-julia@v2
@@ -74,19 +74,19 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        pyversion: ['3.13', '3.10']
+        pyversion: ['3', '3.10']
         juliaexe: ["@JuliaPkg"]
         include:
         - os: ubuntu-latest
-          pyversion: '3.13'
+          pyversion: '3'
           juliaexe: julia
     env:
       MANUAL_TEST_PROJECT: /tmp/juliacall-test-project
       PYTHON_JULIACALL_THREADS: '2'
       PYTHON_JULIACALL_HANDLE_SIGNALS: 'yes'
 
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
 
       - name: Set up Python ${{ matrix.pyversion }}
         uses: actions/setup-python@v6
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -24,6 +24,13 @@
   * `pyjltype(x)` removed.
   * New functions: `pyjlarray`, `pyjldict`, `pyjlset`.
 
+## Unreleased
+* Added `juliacall.TypeValue.__numpy_dtype__` attribute to allow converting Julia types
+  to the corresponding NumPy dtype, like `numpy.dtype(jl.Int)`.
+
+## 0.9.31 (2025-12-17)
+* Restore support for Python 3.14+.
+
 ## 0.9.30 (2025-11-18)
 * Maximum supported Python version is now 3.13 ([see the FAQ](https://juliapy.github.io/PythonCall.jl/stable/faq/#faq-python-314) for why).
 
diff --git a/CondaPkg.toml b/CondaPkg.toml
@@ -10,10 +10,9 @@ version = "<=julia"
 
 [deps.python]
 build = "**cpython**"
-version = ">=3.10,<3.14"
+version = ">=3.10,!=3.14.0,!=3.14.1,<4"
 
 [dev.deps]
 matplotlib = ""
 numpy = ""
 pyside6 = ""
-python = "<3.14"
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.30"
+version = "0.9.31"
 
 [deps]
 CondaPkg = "992eb4ea-22a4-4c89-a5bb-47a3300528ab"
diff --git a/docs/src/faq.md b/docs/src/faq.md
@@ -1,19 +1,5 @@
 # FAQ & Troubleshooting
 
-## [Why is Python 3.14 not supported?](@id faq-python-314)
-
-Python has always had a mechanism for detecting recursion errors (stack overflows).
-The heuristics for this have been made stricter in Python 3.14, which means that any
-system which uses a non-standard stack and calls Python from it is likely to crash.
-Julia is such a system because each task has its own stack.
-
-There are discussions among Python developers about how to make the situation better but
-for now, PythonCall is highly likely to crash when using Python 3.14, so for the time
-being it is not supported.
-
-See the discussion and linked GitHub issue here:
-https://discuss.python.org/t/python-3-14-0-is-incompatible-with-stack-switching-systems-what-do-we-do/104880.
-
 ## [Can I use PythonCall and PyCall together?](@id faq-pycall)
 
 Yes, you can use both PyCall and PythonCall in the same Julia session. This is platform-dependent:
diff --git a/docs/src/juliacall-reference.md b/docs/src/juliacall-reference.md
@@ -75,6 +75,8 @@ and ending with `__` (since these are Python special methods) or starting with `
 - `jl_eval(expr)`: If the object is a Julia `Module`, evaluates the given expression.
 - `jl_help()`: Display help for the object.
 - `jl_to_py()`: Convert to a Python object using the [usual conversion rules](@ref jl2py).
+- `__numpy_dtype__`: Special attribute which allows you to do `numpy.dtype(jl.Int)` for
+  supported types - scalars, tuples and named tuples.
 `````
 
 `````@customdoc
diff --git a/pyproject.toml b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "juliacall"
-version = "0.9.30"
+version = "0.9.31"
 description = "Julia and Python in seamless harmony"
 readme = { file = "README.md", content-type = "text/markdown" }
 classifiers = [
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.30'
+__version__ = '0.9.31'
 
 _newmodule = None
 
diff --git a/pysrc/juliacall/juliapkg-dev.json b/pysrc/juliacall/juliapkg-dev.json
@@ -3,7 +3,7 @@
     "packages": {
         "PythonCall": {
             "uuid": "6099a3de-0909-46bc-b1f4-468b9a2dfc0d",
-            "version": "=0.9.30",
+            "version": "=0.9.31",
             "path": "../..",
             "dev": true
         },
diff --git a/pysrc/juliacall/juliapkg.json b/pysrc/juliacall/juliapkg.json
@@ -3,7 +3,7 @@
     "packages": {
         "PythonCall": {
             "uuid": "6099a3de-0909-46bc-b1f4-468b9a2dfc0d",
-            "version": "=0.9.30"
+            "version": "=0.9.31"
         },
         "OpenSSL_jll": {
             "uuid": "458c3c95-2e84-50aa-8efc-19380b2a3a95",
diff --git a/src/API/API.jl b/src/API/API.jl
@@ -1,5 +1,5 @@
 "The version of PythonCall."
-const VERSION = v"0.9.30"
+const VERSION = v"0.9.31"
 
 include("types.jl")
 include("functions.jl")
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.30"
+const VERSION = v"0.9.31"
 const ROOT_DIR = dirname(dirname(@__DIR__))
 
 using ..PythonCall
diff --git a/src/JlWrap/any.jl b/src/JlWrap/any.jl
@@ -389,6 +389,49 @@ end
 
 pyjlany_hash(self) = pyint(hash(self))
 
+const PYNUMPYDTYPE = IdDict{Type,Py}()
+
+function pyjlany_numpy_dtype(self::Type)
+    ans = get!(PYNUMPYDTYPE, self) do
+        typestr, descr = pytypestrdescr(self)
+        # unsupported type
+        if typestr == ""
+            return PyNULL
+        end
+        np = pyimport("numpy")
+        # simple scalar type
+        if pyisnull(descr)
+            return np.dtype(typestr)
+        end
+        # We could juse use np.dtype(descr), but when there is padding, np.dtype(descr)
+        # changes the names of the padding fields from "" to "f{N}". Using this other
+        # dtype constructor avoids this issue and preserves the invariant:
+        #   np.dtype(eltype(array)) == np.array(array).dtype
+        names = []
+        formats = []
+        offsets = []
+        for i = 1:fieldcount(self)
+            nm = fieldname(self, i)
+            push!(names, nm isa Integer ? "f$(nm-1)" : String(nm))
+            ts, ds = pytypestrdescr(fieldtype(self, i))
+            push!(formats, pyisnull(ds) ? ts : ds)
+            push!(offsets, fieldoffset(self, i))
+        end
+        return np.dtype(
+            pydict(
+                names = pylist(names),
+                formats = pylist(formats),
+                offsets = pylist(offsets),
+                itemsize = sizeof(self),
+            ),
+        )
+    end
+    if pyisnull(ans)
+        errset(pybuiltins.AttributeError, "__numpy_dtype__")
+    end
+    return ans
+end
+
 function init_any()
     jl = pyjuliacallmodule
     pybuiltins.exec(
@@ -573,6 +616,9 @@ class Jl(JlBase2):
         return self._jl_callmethod($(pyjl_methodnum(pyjlany_call_nogil)), args, kwargs)
     def _repr_mimebundle_(self, include=None, exclude=None):
         return self._jl_callmethod($(pyjl_methodnum(pyjlany_mimebundle)), include, exclude)
+    @property
+    def __numpy_dtype__(self):
+        return self._jl_callmethod($(pyjl_methodnum(pyjltype_numpy_dtype)))
 """,
             @__FILE__(),
             "exec",
diff --git a/src/JlWrap/array.jl b/src/JlWrap/array.jl
@@ -187,7 +187,7 @@ pybufferformat(::Type{T}) where {T} =
         T == Complex{Cdouble} ? "Zd" :
         T == Bool ? "?" :
         T == Ptr{Cvoid} ? "P" :
-        if isstructtype(T) && isconcretetype(T) && allocatedinline(T)
+        if (T <: Union{Tuple,NamedTuple}) && isstructtype(T) && isconcretetype(T) && allocatedinline(T)
             n = fieldcount(T)
             flds = []
             for i = 1:n
@@ -234,7 +234,7 @@ pyjlarray_isarrayabletype(::Type{NamedTuple{names,types}}) where {names,types} =
 
 const PYTYPESTRDESCR = IdDict{Type,Tuple{String,Py}}()
 
-pytypestrdescr(::Type{T}) where {T} =
+function pytypestrdescr(::Type{T}) where {T}
     get!(PYTYPESTRDESCR, T) do
         c = Utils.islittleendian() ? '<' : '>'
         if T == Bool
@@ -275,7 +275,7 @@ pytypestrdescr(::Type{T}) where {T} =
                 u == NumpyDates.UNBOUND_UNITS ? "" :
                 m == 1 ? "[$(Symbol(u))]" : "[$(m)$(Symbol(u))]"
             ("$(c)$(tc)8$(us)", PyNULL)
-        elseif isstructtype(T) && isconcretetype(T) && Base.allocatedinline(T)
+        elseif (T <: Union{Tuple,NamedTuple}) && isstructtype(T) && isconcretetype(T) && Base.allocatedinline(T)
             n = fieldcount(T)
             flds = []
             for i = 1:n
@@ -298,6 +298,7 @@ pytypestrdescr(::Type{T}) where {T} =
             ("", PyNULL)
         end
     end
+end
 
 pyjlarray_array__array(x::AbstractArray) = x isa Array ? Py(nothing) : pyjlarray(Array(x))
 pyjlarray_array__pyobjectarray(x::AbstractArray) = pyjlarray(PyObjectArray(x))
diff --git a/test/JlWrap.jl b/test/JlWrap.jl
@@ -1,4 +1,4 @@
-@testitem "any" begin
+@testitem "any" setup=[Setup] begin
     mutable struct Foo
         value::Int
     end
@@ -302,6 +302,70 @@
         @test pyisinstance(z, pybuiltins.int)
         @test pyeq(Bool, z, y)
     end
+    @testset "__numpy_dtype__" begin
+        if Setup.devdeps
+            np = pyimport("numpy")
+
+            # success cases
+            @testset "$t -> $d" for (t, d) in [
+                (Bool, "bool"),
+                (Int8, "int8"),
+                (Int16, "int16"),
+                (Int32, "int32"),
+                (Int64, "int64"),
+                (UInt8, "uint8"),
+                (UInt16, "uint16"),
+                (UInt32, "uint32"),
+                (UInt64, "uint64"),
+                (Float16, "float16"),
+                (Float32, "float32"),
+                (Float64, "float64"),
+                (ComplexF32, "complex64"),
+                (ComplexF64, "complex128"),
+                (InlineDateTime64{SECONDS}, "datetime64[s]"),
+                (InlineDateTime64{(SECONDS, 5)}, "datetime64[5s]"),
+                (InlineDateTime64{NumpyDates.UNBOUND_UNITS}, "datetime64"),
+                (InlineTimeDelta64{MINUTES}, "timedelta64[m]"),
+                (InlineTimeDelta64{(SECONDS, 5)}, "timedelta64[5s]"),
+                (InlineTimeDelta64{NumpyDates.UNBOUND_UNITS}, "timedelta64"),
+                (Tuple{}, pylist()),
+                (Tuple{Int32, Int32}, pylist([("f0", "int32"), ("f1", "int32")])),
+                (@NamedTuple{}, pylist()),
+                (@NamedTuple{x::Int32, y::Int32}, pylist([("x", "int32"), ("y", "int32")])),
+            ]
+                @test Py(t).__numpy_dtype__ == np.dtype(d)
+                @test np.dtype(t) == np.dtype(d)
+                # test the invariant np.dtype(eltype(array)) == np.array(array).dtype
+                @test np.dtype(t) == np.array(t[]).dtype
+            end
+
+            # unsupported cases
+            @testset "$t -> AttributeError" for t in [
+                # structs / mutables
+                Pair,
+                Pair{Int,Int},
+                String,
+                Vector{Int},
+                # pointers
+                Ptr{Cvoid},
+                Ptr{Int},
+                # PyPtr specifically should NOT be interpreted as np.dtype("O")
+                PythonCall.C.PyPtr,
+                # tuples containing illegal things
+                Tuple{String},
+                Tuple{Pair{Int,Int}},
+            ]
+                err = try
+                    Py(t).__numpy_dtype__
+                    nothing
+                catch err
+                    err
+                end
+                @test err isa PythonCall.PyException
+                @test pyis(err.t, pybuiltins.AttributeError)
+            end
+        end
+    end
 end
 
 @testitem "collection" begin
