F2PY wrap procedure that uses derived types only internally

Question

It is stated in a lot of places that F2PY does not "support derived types", however, it is unclear to me whether this means that either

derived types may not be used as parameters to procedures wrapped by F2PY
derived types may not even be used internally in procedures I want to wrap with F2PY

To my use case the first point is an inconvenience but the second rather a deal breaker.

As an example, consider this module that computes a vector sum:

module derived_types

implicit none
public :: point, add

type :: point
   real :: x
   real :: y
end type point

contains

type(point) function add(p1, p2)

type(point), intent(in) :: p1
type(point), intent(in) :: p2

add%x = p1%x + p2%x
add%y = p1%y + p2%y

end function add

end module derived_types


module expose

use derived_types, only: point, add
implicit none

contains

subroutine vector_sum(x1, y1, x2, y2, x3, y3)

real, intent(in) ::  x1, y1, x2, y2
real, intent(out) :: x3, y3

type(point) :: p1, p2, p3

p1 = point(x1, y1)
p2 = point(x2, y2)

p3 = add(p1, p2)

x3 = p3%x
y3 = p3%y

end subroutine vector_sum

end module expose

Subroutine vector_sum shall be exposed to Python. The derived type point is not to be passed between Python and Fortran.

This works as plain Fortran program (with an appropriate program block added) but F2PY fails:

f2py -c ff.f90 only: vector_sum

running build
running config_cc
unifing config_cc, config, build_clib, build_ext, build commands --compiler options
running config_fc
unifing config_fc, config, build_clib, build_ext, build commands --fcompiler options
running build_src
build_src
building extension "untitled" sources
f2py options: ['only:', 'vector_sum', ':']
f2py:> /tmp/tmpjdq8b9dq/src.linux-x86_64-3.8/untitledmodule.c
creating /tmp/tmpjdq8b9dq/src.linux-x86_64-3.8
Reading fortran codes...
    Reading file 'ff.f90' (format:free)
Line #7 in ff.f90:"type :: point "
    analyzeline: No name/args pattern found for line.
Post-processing...
    Block: untitled
            Block: derived_types
                Block: unknown_type
            Block: expose
                Block: vector_sum
            Block: run
Post-processing (stage 2)...
    Block: untitled
        Block: unknown_interface
            Block: derived_types
                Block: unknown_type
            Block: expose
                Block: vector_sum
            Block: run
Building modules...
    Building module "untitled"...
        Constructing F90 module support for "derived_types"...
          Variables: point add
getctype: No C-type found in "{'attrspec': ['public']}", assuming void.
Traceback (most recent call last):
File "/home/me/.pyenv/versions/anaconda3-2020.11/lib/python3.8/site-packages/numpy/f2py/f90mod_rules.py", line 143, in buildhooks
    at = capi_maps.c2capi_map[ct]
KeyError: 'void'

Can such a thing be done using F2PY at all?

score 2 · Answer 1 · answered May 13 '21 at 12:15

You can use a single procedure, define the derived type therein as well as using contained procedures. This is a quick and dirty approach which will only suffice for smaller problems.

An example implementation follows

! file: a.f90
subroutine vector_sum(x1, y1, x2, y2, x3, y3)
  real, intent(in)  :: x1, y1, x2, y2
  real, intent(out) :: x3, y3

  type point
    real :: x(2)
  end type

  type(point) :: p1, p2, p3

  p1%x = [x1, y1]
  p2%x = [x2, y2]

  p3 = add(p1, p2)

  x3 = p3%x(1)
  y3 = p3%x(2)

contains

  type(point) function add(p1, p2)
    type(point), intent(in) :: p1
    type(point), intent(in) :: p2

    add%x = p1%x + p2%x
  end function

end subroutine

Compilation

$ f2py -c a.f90 -m amod

Usage in python

>>> import amod
>>> amod.vector_sum(1, 2, 3, 4)
(4.0, 6.0)

This works and answers the question (+1), but prevents the derived type to be shared between different subroutines. — Christoph90, May 13 '21 at 12:40
You can pass objects between contained procedures. But this might be of limited use for larger projects... — jack, May 13 '21 at 19:23

Christoph90 · Accepted Answer · 2021-05-14T07:15:38.967

After some tinkering, I figured it would probably be easiest to compile the code that defines all derived types into a static library first, i.e.:

libff.f90 containing:

module derived_types

implicit none

public :: point, add

type :: point
   real :: x
   real :: y
end type point

contains

type(point) function add(p1, p2)

type(point), intent(in) :: p1
type(point), intent(in) :: p2

add%x = p1%x + p2%x
add%y = p1%y + p2%y

end function add

end module derived_types

Compile with gfortran -free -c libff.f90 to produce libff.o.

Then the code that uses the derived types from the pre-compiled module can be compiled with F2PY when linking the library, i.e.:

ff.f90 containing:

module expose

use derived_types, only: point, add
implicit none

contains

subroutine vector_sum(x1, y1, x2, y2, x3, y3)

real, intent(in) ::  x1, y1, x2, y2
real, intent(out) :: x3, y3

type(point) :: p1, p2, p3

p1 = point(x1, y1)
p2 = point(x2, y2)

p3 = add(p1, p2)

x3 = p3%x
y3 = p3%y

end subroutine vector_sum

end module expose

After using F2PY to build the Python extention with f2py -c ff.f90 libff.o -m ff, we can import it in Python with from ff.expose import vector_sum.

Lesson learned: Put the definition of derived types into a pre-compiled library then compile only the code using these types with F2PY.

F2PY wrap procedure that uses derived types only internally

2 Answers2

Linked