Get tests passing again

Author: znicholls

Makefile

@@ -49,8 +49,7 @@ test:  ## run the tests (re-installs the package every time so you might want to
 	# because it is looking for lines in `src` to be run,
 	# but they're not because lines in `.venv` are run instead.
 	# We don't have a solution to this yet.
-	#
-	# Coverage directory - needed to trick code cov to looking at the right place
+	uv run --no-sync python scripts/inject-srcs-into-meson-build.py
 	uv run --no-sync python -c 'from pathlib import Path; import example_fgen_basic' || ( echo "Run make virtual-environment first" && false )
 	COV_DIR=$$(uv run --no-sync python -c 'from pathlib import Path; import example_fgen_basic; print(Path(example_fgen_basic.__file__).parent)'); \
 		uv run --no-editable --reinstall-package example-fgen-basic pytest -r a -v tests src --doctest-modules --doctest-report ndiff --cov=$$COV_DIR

meson.build

@@ -52,7 +52,6 @@ if pyprojectwheelbuild_enabled
   # Injected with `script/inject-srcs-into-meson-build.py`
   srcs = files(
     'src/example_fgen_basic/error_v/creation_wrapper.f90',
-    'src/example_fgen_basic/error_v/error_v_ptr_based_wrapper.f90',
     'src/example_fgen_basic/error_v/error_v_wrapper.f90',
     'src/example_fgen_basic/get_wavelength_wrapper.f90',
   )

src/example_fgen_basic/error_v/__init__.py

@@ -2,6 +2,6 @@
 Definition of an error value
 """
 
-from example_fgen_basic.error_v.error_v import ErrorV, ErrorVPtrBased
+from example_fgen_basic.error_v.error_v import ErrorV
 
-__all__ = ["ErrorV", "ErrorVPtrBased"]
+__all__ = ["ErrorV"]

src/example_fgen_basic/error_v/creation.py

@@ -4,7 +4,7 @@
 
 from __future__ import annotations
 
-from example_fgen_basic.error_v.error_v import ErrorV, ErrorVPtrBased
+from example_fgen_basic.error_v.error_v import ErrorV
 from example_fgen_basic.pyfgen_runtime.exceptions import CompiledExtensionNotFoundError
 
 try:
@@ -24,16 +24,3 @@ def create_error(inv: int) -> ErrorV:
     error = ErrorV(instance_index)
 
     return error
-
-
-def create_error_ptr_based(inv: int) -> ErrorVPtrBased:
-    """
-    Create an instance of error (a wrapper around our Fortran derived type)
-
-    Uses the pointer based logic
-    """
-    instance_ptr = m_error_v_creation_w.create_error_ptr_based(inv)
-
-    error = ErrorVPtrBased(instance_ptr)
-
-    return error

src/example_fgen_basic/error_v/creation_wrapper.f90

@@ -19,7 +19,7 @@ module m_error_v_creation_w
     implicit none
     private
 
-    public :: create_error, create_error_ptr_based
+    public :: create_error
 
 contains
 
@@ -39,45 +39,22 @@ subroutine create_error(inv, res_instance_index)
 
         type(ErrorV), pointer :: res
 
-        ! Use the pointer more or less like a normal instance of the derived type
-        res = o_create_error(inv)
-
         ! This is the other trick for wrapping.
         ! We have to ensure that we have correctly associated pointers
         ! with the derived type instances we want to 'pass' across the Python-Fortran interface.
         ! Once we've done this, we can then set them more or less like normal derived types.
         res_instance_index = error_v_manager_get_free_instance_number()
+        ! We have to associate res with the right index
+        ! before we can set it to the output of the function call
+        ! (in this case `o_create_error`).
         call error_v_manager_associate_pointer_with_instance(res_instance_index, res)
-        ! Ensure that the instance index is set correctly
-        res % instance_index = res_instance_index
-
-    end subroutine create_error
-
-    subroutine create_error_ptr_based(inv, res_instance_ptr)
-    ! Needs to be subroutine to have the created instance persist I think
-    ! (we can check)
-    ! function create_error(inv) result(res_instance_index)
 
-        integer, intent(in) :: inv
-        !! Input value to use to create the error
-
-        !f2py integer(8), intent(out) :: res_instance_ptr
-        type(c_ptr), intent(out) :: res_instance_ptr
-        !! Pointer to the resulting instance
-        !
-        ! This is the major trick for wrapping.
-        ! We return pointers (passed as integers) to Python rather than the instance itself.
-
-        type(ErrorV), pointer :: res
-
-        ! Question is: when does this get deallocated?
-        ! When we go out of scope?
-        ! If yes, that will be why we had to do this array thing.
-        allocate(res)
+        ! Use the pointer more or less like a normal instance of the derived type
         res = o_create_error(inv)
 
-        res_instance_ptr = c_loc(res)
+        ! Ensure that the instance index is set correctly
+        res % instance_index = res_instance_index
 
-    end subroutine create_error_ptr_based
+    end subroutine create_error
 
 end module m_error_v_creation_w

src/example_fgen_basic/error_v/error_v.py

@@ -10,16 +10,13 @@
 
 from example_fgen_basic.pyfgen_runtime.base_finalisable import (
     FinalisableWrapperBase,
-    FinalisableWrapperBasePtrBased,
     check_initialised,
-    check_initialised_ptr_based,
-    execute_finalise_on_fail_ptr_based,
+    execute_finalise_on_fail,
 )
 from example_fgen_basic.pyfgen_runtime.exceptions import CompiledExtensionNotFoundError
 
 try:
     from example_fgen_basic._lib import (  # type: ignore
-        m_error_v_ptr_based_w,
         m_error_v_w,
     )
 except (ModuleNotFoundError, ImportError) as exc:  # pragma: no cover
@@ -48,77 +45,20 @@ def exposed_attributes(self) -> tuple[str, ...]:
         """
         return ("code", "message")
 
-    # TODO: from_build_args, from_new_connection, context manager, finalise
-
-    @property
-    @check_initialised
-    def code(self) -> int:
-        """
-        Error code
-
-        Returns
-        -------
-        :
-            Error code, retrieved from Fortran
-        """
-        code: int = m_error_v_w.iget_code(instance_index=self.instance_index)
-
-        return code
-
-    @property
-    @check_initialised
-    def message(self) -> str:
-        """
-        Error message
-
-        Returns
-        -------
-        :
-            Error message, retrieved from Fortran
-        """
-        message: str = m_error_v_w.iget_message(
-            instance_index=self.instance_index
-        ).decode()
-
-        return message
-
-
-@define
-class ErrorVPtrBased(FinalisableWrapperBasePtrBased):
-    """
-    TODO: auto docstring e.g. "Wrapper around the Fortran :class:`ErrorV`"
-
-    Uses the pointer-based passing logic
-    """
-
-    # Bug in Ipython pretty hence have to put this on every object?
-    def _repr_pretty_(self, p: Any, cycle: bool) -> None:
-        """
-        Get pretty representation of self
-
-        Used by IPython notebooks and other tools
-        """
-        super()._repr_pretty_(p=p, cycle=cycle)
-
-    @property
-    def exposed_attributes(self) -> tuple[str, ...]:
-        """
-        Attributes exposed by this wrapper
-        """
-        return ("code", "message")
-
+    # TODO: context manager
     @classmethod
-    def from_new_connection(cls) -> ErrorVPtrBased:
+    def from_new_connection(cls) -> ErrorV:
         """
         Initialise from a new connection
 
         The user is responsible for releasing this connection
         using :attr:`~finalise` when it is no longer needed.
-        Alternatively a :obj:`~AtmosphereToOceanCarbonFluxCalculatorContext`
+        Alternatively an [ErrorVContext][]
         can be used to handle the finalisation using a context manager.
 
         Returns
         -------
+        :
             A new instance with a unique instance index
 
         Raises
@@ -128,26 +68,24 @@ def from_new_connection(cls) -> ErrorVPtrBased:
 
             This could occur if too many instances are allocated at any one time
         """
-        instance_ptr = m_error_v_ptr_based_w.get_instance_ptr()
-        # TODO: result type handling here
+        instance_ptr: int = m_error_v_w.get_free_instance_number()
 
         return cls(instance_ptr)
 
-    # TODO: from_build_args, from_new_connection, context manager, finalise
     @classmethod
     def from_build_args(
         cls,
         code: int,
         message: str = "",
-    ) -> ErrorVPtrBased:
+    ) -> ErrorV:
         """
         Build the class (including connecting to Fortran)
         """
         out = cls.from_new_connection()
         # TODO: remove or update this construct when we have result types
-        execute_finalise_on_fail_ptr_based(
+        execute_finalise_on_fail(
             out,
-            m_error_v_ptr_based_w.instance_build,
+            m_error_v_w.instance_build,
             code=code,
             message=message,
         )
@@ -159,28 +97,11 @@ def finalise(self) -> None:
         """
         Close the connection with the Fortran module
         """
-        m_error_v_ptr_based_w.instance_finalise(self.instance_ptr)
-        self._uninitialise_instance_ptr()
-
-    @property
-    def is_associated(self) -> bool:
-        """
-        Check whether `self`'s pointer is associated on the Fortran side
-
-        Returns
-        -------
-        :
-            Whether `self`'s pointer is associated on the Fortran side
-        """
-        if self.instance_ptr is None:
-            return False
-
-        res: bool = bool(m_error_v_ptr_based_w.is_associated(self.instance_ptr))  # type: ignore
-
-        return res
+        m_error_v_w.instance_finalise(self.instance_index)
+        self._uninitialise_instance_index()
 
     @property
-    @check_initialised_ptr_based
+    @check_initialised
     def code(self) -> int:
         """
         Error code
@@ -190,12 +111,12 @@ def code(self) -> int:
         :
             Error code, retrieved from Fortran
         """
-        code: int = m_error_v_ptr_based_w.iget_code(instance_ptr=self.instance_ptr)
+        code: int = m_error_v_w.iget_code(instance_index=self.instance_index)
 
         return code
 
     @property
-    @check_initialised_ptr_based
+    @check_initialised
     def message(self) -> str:
         """
         Error message
@@ -205,8 +126,8 @@ def message(self) -> str:
         :
             Error message, retrieved from Fortran
         """
-        message: str = m_error_v_ptr_based_w.iget_message(
-            instance_ptr=self.instance_ptr
+        message: str = m_error_v_w.iget_message(
+            instance_index=self.instance_index
         ).decode()
 
         return message