Pass all tests

Author: znicholls

meson.build

@@ -53,6 +53,7 @@ if pyprojectwheelbuild_enabled
   srcs = files(
     'src/example_fgen_basic/error_v/creation_wrapper.f90',
     'src/example_fgen_basic/error_v/error_v_wrapper.f90',
+    'src/example_fgen_basic/error_v/passing_wrapper.f90',
     'src/example_fgen_basic/get_wavelength_wrapper.f90',
   )
 
@@ -62,6 +63,7 @@ if pyprojectwheelbuild_enabled
     'src/example_fgen_basic/error_v/creation.f90',
     'src/example_fgen_basic/error_v/error_v.f90',
     'src/example_fgen_basic/error_v/error_v_manager.f90',
+    'src/example_fgen_basic/error_v/passing.f90',
     'src/example_fgen_basic/fpyfgen/base_finalisable.f90',
     'src/example_fgen_basic/fpyfgen/derived_type_manager_helpers.f90',
     'src/example_fgen_basic/get_wavelength.f90',
@@ -75,12 +77,11 @@ if pyprojectwheelbuild_enabled
     'src/example_fgen_basic/error_v/__init__.py',
     'src/example_fgen_basic/error_v/creation.py',
     'src/example_fgen_basic/error_v/error_v.py',
+    'src/example_fgen_basic/error_v/passing.py',
     'src/example_fgen_basic/exceptions.py',
     'src/example_fgen_basic/get_wavelength.py',
     'src/example_fgen_basic/pyfgen_runtime/__init__.py',
-    'src/example_fgen_basic/pyfgen_runtime/base_finalisable.py',
     'src/example_fgen_basic/pyfgen_runtime/exceptions.py',
-    'src/example_fgen_basic/pyfgen_runtime/formatting.py',
   )
 
     # The ancillary library,

src/example_fgen_basic/error_v/error_v_manager.f90

@@ -15,11 +15,29 @@ module m_error_v_manager
     logical, dimension(:), allocatable :: instance_available
 
     ! TODO: think about ordering here, alphabetical probably easiest
-    public :: finalise_instance, get_available_instance_index, get_instance, set_instance_index_to, &
+    public :: build_instance, finalise_instance, get_available_instance_index, get_instance, set_instance_index_to, &
               ensure_instance_array_size_is_at_least
 
 contains
 
+    function build_instance(code, message) result(instance_index)
+        !! Build an instance
+
+        integer, intent(in) :: code
+        !! Error code
+
+        character(len=*), optional, intent(in) :: message
+        !! Error message
+
+        integer :: instance_index
+        !! Index of the built instance
+
+        call ensure_instance_array_size_is_at_least(1)
+        call get_available_instance_index(instance_index)
+        call instance_array(instance_index) % build(code=code, message=message)
+
+    end function build_instance
+
     subroutine finalise_instance(instance_index)
         !! Finalise an instance
 
@@ -59,7 +77,6 @@ subroutine get_available_instance_index(available_instance_index)
         end do
 
         ! TODO: switch to returning a Result type with an error set
-        print *, "No free indexes"
         error stop 1
 
     end subroutine get_available_instance_index
@@ -112,9 +129,6 @@ subroutine check_index_claimed(instance_index)
 
     end subroutine check_index_claimed
 
-    ! TODO: think about exposing this to Python
-    ! so power users can ensure there are enough arrays at the start
-    ! rather than relying on automatic resizing.
     subroutine ensure_instance_array_size_is_at_least(n)
         !! Ensure that `instance_array` and `instance_available` have at least `n` slots
 
@@ -139,6 +153,7 @@ subroutine ensure_instance_array_size_is_at_least(n)
 
             allocate(tmp_available(n))
             tmp_available(1:size(instance_available)) = instance_available
+            tmp_available(size(instance_available) + 1:size(tmp_available)) = .true.
             call move_alloc(tmp_available, instance_available)
 
         end if

src/example_fgen_basic/error_v/error_v_wrapper.f90

@@ -9,17 +9,41 @@ module m_error_v_w
 
     ! The manager module, which makes this all work
     use m_error_v_manager, only: &
+        error_v_manager_build_instance => build_instance, &
         error_v_manager_finalise_instance => finalise_instance, &
-        error_v_manager_get_instance => get_instance
+        error_v_manager_get_instance => get_instance, &
+        error_v_manager_ensure_instance_array_size_is_at_least => ensure_instance_array_size_is_at_least
 
     implicit none
     private
 
-    public :: finalise_instance, finalise_instances, &
+    public :: build_instance, finalise_instance, finalise_instances, &
+              ensure_at_least_n_instances_can_be_passed_simultaneously, &
               get_code, get_message
 
 contains
 
+    subroutine build_instance(code, message, instance_index)
+        !! Build an instance
+
+        integer, intent(in) :: code
+        !! Error code
+        !!
+        !! Use [TODO: figure out xref] `NO_ERROR_CODE` if there is no error
+
+        character(len=*), optional, intent(in) :: message
+        !! Error message
+
+        integer, intent(out) :: instance_index
+        !! Instance index of the built instance
+        !
+        ! This is the major trick for wrapping.
+        ! We pass instance indexes (integers) to Python rather than the instance itself.
+
+        instance_index = error_v_manager_build_instance(code, message)
+
+    end subroutine build_instance
+
     subroutine finalise_instance(instance_index)
         !! Finalise an instance
 
@@ -33,7 +57,6 @@ subroutine finalise_instance(instance_index)
 
     end subroutine finalise_instance
 
-
     subroutine finalise_instances(instance_indexes)
         !! Finalise an instance
 
@@ -51,6 +74,15 @@ subroutine finalise_instances(instance_indexes)
 
     end subroutine finalise_instances
 
+    subroutine ensure_at_least_n_instances_can_be_passed_simultaneously(n)
+        !! Ensure that at least `n` instances of `ErrorV` can be passed via the manager simultaneously
+
+        integer, intent(in) :: n
+
+        call error_v_manager_ensure_instance_array_size_is_at_least(n)
+
+    end subroutine ensure_at_least_n_instances_can_be_passed_simultaneously
+
     ! Full set of wrapping strategies to get/pass different types in e.g.
     ! https://gitlab.com/magicc/fgen/-/blob/switch-to-uv/tests/test-data/exposed_attrs/src/exposed_attrs/exposed_attrs_wrapped.f90
     ! (we will do a full re-write of the code which generates this,

src/example_fgen_basic/error_v/passing.f90

@@ -0,0 +1,57 @@
+!> Error passing
+!>
+!> A very basic demo to get the idea.
+!
+! TODO: discuss - we should probably have some convention for module names.
+! The hard part is avoiding them becoming too long...
+module m_error_v_passing
+
+    use m_error_v, only: ErrorV, NO_ERROR_CODE
+
+    implicit none
+    private
+
+    public :: pass_error, pass_errors
+
+contains
+
+    function pass_error(inv) result(is_err)
+        !! Pass an error
+        !!
+        !! If an error is supplied, we return `.true.`, otherwise `.false.`.
+
+        type(ErrorV), intent(in) :: inv
+        !! Input error value
+
+        logical :: is_err
+        !! Whether `inv` is an error or not
+
+        is_err = (inv % code /= NO_ERROR_CODE)
+
+    end function pass_error
+
+    function pass_errors(invs, n) result(is_errs)
+        !! Pass a number of errors
+        !!
+        !! For each value in `invs`, if an error is supplied, we return `.true.`, otherwise `.false.`.
+
+        type(ErrorV), dimension(n), intent(in) :: invs
+        !! Input error values
+
+        integer, intent(in) :: n
+        !! Number of values being passed
+
+        logical, dimension(n) :: is_errs
+        !! Whether each value in `invs` is an error or not
+
+        integer :: i
+
+        do i = 1, n
+
+            is_errs(i) = pass_error(invs(i))
+
+        end do
+
+    end function pass_errors
+
+end module m_error_v_passing

src/example_fgen_basic/error_v/passing.py

@@ -0,0 +1,96 @@
+"""
+Wrappers of `m_error_v_passing` [TODO think about naming and x-referencing]
+
+At the moment, all written by hand.
+We will auto-generate this in future.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from example_fgen_basic.error_v import ErrorV
+from example_fgen_basic.pyfgen_runtime.exceptions import CompiledExtensionNotFoundError
+
+try:
+    from example_fgen_basic._lib import (  # type: ignore
+        m_error_v_w,
+    )
+except (ModuleNotFoundError, ImportError) as exc:  # pragma: no cover
+    raise CompiledExtensionNotFoundError("example_fgen_basic._lib.m_error_v_w") from exc
+try:
+    from example_fgen_basic._lib import (  # type: ignore
+        m_error_v_passing_w,
+    )
+except (ModuleNotFoundError, ImportError) as exc:  # pragma: no cover
+    raise CompiledExtensionNotFoundError(
+        "example_fgen_basic._lib.m_error_v_passing_w"
+    ) from exc
+
+if TYPE_CHECKING:
+    # TODO: bring back in numpy type hints
+    NP_ARRAY_OF_INT = None
+    NP_ARRAY_OF_BOOL = None
+
+
+def pass_error(inv: ErrorV) -> bool:
+    """
+    Pass an error to Fortran
+
+    Parameters
+    ----------
+    inv
+        Input value to pass to Fortran
+
+    Returns
+    -------
+    :
+        If `inv` is an error, `True`, otherwise `False`.
+    """
+    # Tell Fortran to build the object on the Fortran side
+    instance_index: int = m_error_v_w.build_instance(code=inv.code, message=inv.message)
+
+    # Call the Fortran function
+    # Boolean wrapping strategy, have to cast to bool
+    res_raw: int = m_error_v_passing_w.pass_error(instance_index)
+    res = bool(res_raw)
+
+    # Tell Fortran to finalise the object on the Fortran side
+    # (all data has been used for the call now)
+    m_error_v_w.finalise_instance(instance_index)
+
+    return res
+
+
+def pass_errors(invs: tuple[ErrorV, ...]) -> NP_ARRAY_OF_BOOL:
+    """
+    Pass a number of errors to Fortran
+
+    Parameters
+    ----------
+    invs
+        Errors to pass to Fortran
+
+    Returns
+    -------
+    :
+        Whether each value in `invs` is an error or not
+    """
+    # Controlling memory from the Python side
+    m_error_v_w.ensure_at_least_n_instances_can_be_passed_simultaneously(len(invs))
+    # TODO: consider adding `build_instances` too, might be headache
+    instance_indexes: NP_ARRAY_OF_INT = np.array(
+        [m_error_v_w.build_instance(code=inv.code, message=inv.message) for inv in invs]
+    )
+
+    # Convert the result to boolean
+    res_raw = m_error_v_passing_w.pass_errors(instance_indexes, n=instance_indexes.size)
+    res = res_raw.astype(bool)
+
+    # Tell Fortran to finalise the objects on the Fortran side
+    # (all data has been copied to Python now)
+    m_error_v_w.finalise_instances(instance_indexes)
+
+    return res

src/example_fgen_basic/error_v/passing_wrapper.f90

@@ -0,0 +1,81 @@
+!> Wrapper for interfacing `m_error_v_passing` with Python
+!>
+!> Written by hand here.
+!> Generation to be automated in future (including docstrings of some sort).
+module m_error_v_passing_w
+
+    ! => allows us to rename on import to avoid clashes
+    ! "o_" for original (TODO: better naming convention)
+    use m_error_v_passing, only: &
+        o_pass_error => pass_error, &
+        o_pass_errors => pass_errors
+    use m_error_v, only: ErrorV
+
+    ! The manager module, which makes this all work
+    use m_error_v_manager, only: &
+          error_v_manager_get_instance => get_instance
+    !     error_v_manager_get_available_instance_index => get_available_instance_index, &
+    !     error_v_manager_set_instance_index_to => set_instance_index_to, &
+    !     error_v_manager_ensure_instance_array_size_is_at_least => ensure_instance_array_size_is_at_least
+
+    implicit none
+    private
+
+    public :: pass_error, pass_errors
+
+contains
+
+    function pass_error(inv_instance_index) result(res)
+        !! Wrapper around `m_error_v_passing.pass_error` (TODO: x-ref)
+
+        integer, intent(in) :: inv_instance_index
+        !! Input values
+        !!
+        !! See docstring of `m_error_v_passing.pass_error` for details.
+        !! [TODO: x-ref]
+        !! The trick here is to pass in the instance index, not the instance itself
+
+        logical :: res
+        !! Whether the instance referred to by `inv_instance_index` is an error or not
+
+        type(ErrorV) :: instance
+
+        instance = error_v_manager_get_instance(inv_instance_index)
+
+        ! Do the Fortran call
+        res = o_pass_error(instance)
+
+    end function pass_error
+
+    function pass_errors(inv_instance_indexes, n) result(res)
+        !! Wrapper around `m_error_v_passing.pass_errors` (TODO: x-ref)
+
+        integer, dimension(n), intent(in) :: inv_instance_indexes
+        !! Input values
+        !!
+        !! See docstring of `m_error_v_passing.pass_errors` for details.
+        !! [TODO: x-ref]
+
+        integer, intent(in) :: n
+        !! Number of values to pass
+
+        logical, dimension(n) :: res
+        !! Whether each instance in the array backed by `inv_instance_indexes` is an error or not
+        !
+        ! This is the major trick for wrapping.
+        ! We pass instance indexes (integers) from Python rather than the instance itself.
+
+        type(ErrorV), dimension(n) :: instances
+
+        integer :: i
+
+        do i = 1, n
+            instances(i) = error_v_manager_get_instance(inv_instance_indexes(i))
+        end do
+
+        ! Do the Fortran call
+        res = o_pass_errors(instances, n)
+
+    end function pass_errors
+
+end module m_error_v_passing_w