Up to writing wrapper

Author: znicholls

meson.build

@@ -85,9 +85,12 @@ if pyprojectwheelbuild_enabled
     '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_square_root.py',
     'src/example_fgen_basic/get_wavelength.py',
     'src/example_fgen_basic/pyfgen_runtime/__init__.py',
     'src/example_fgen_basic/pyfgen_runtime/exceptions.py',
+    'src/example_fgen_basic/result/__init__.py',
+    'src/example_fgen_basic/result/result_dp.py',
     'src/example_fgen_basic/typing.py',
   )
 

src/example_fgen_basic/error_v/creation.py

@@ -54,10 +54,6 @@ def create_error(inv: int) -> ErrorV:
     # Initialise the result from the received index
     res = ErrorV.from_instance_index(instance_index)
 
-    # Tell Fortran to finalise the object on the Fortran side
-    # (all data has been copied to Python now)
-    m_error_v_w.finalise_instance(instance_index)
-
     return res
 
 

src/example_fgen_basic/error_v/error_v.py

@@ -59,6 +59,10 @@ def from_instance_index(cls, instance_index: int) -> ErrorV:
 
         res = cls(code=code, message=message)
 
+        # Tell Fortran to finalise the object on the Fortran side
+        # (all data has been copied to Python now)
+        m_error_v_w.finalise_instance(instance_index)
+
         return res
 
     def build_fortran_instance(self) -> int:

src/example_fgen_basic/get_square_root.py

@@ -0,0 +1,61 @@
+"""
+Get square root of a number
+"""
+
+from __future__ import annotations
+
+from example_fgen_basic.pyfgen_runtime.exceptions import (
+    CompiledExtensionNotFoundError,
+    FortranError,
+)
+from example_fgen_basic.result import ResultDP
+
+try:
+    from example_fgen_basic._lib import m_get_square_root_w  # type: ignore
+except (ModuleNotFoundError, ImportError) as exc:  # pragma: no cover
+    raise CompiledExtensionNotFoundError(
+        "example_fgen_basic._lib.m_get_square_root_w"
+    ) from exc
+
+try:
+    from example_fgen_basic._lib import m_result_dp_w  # type: ignore
+except (ModuleNotFoundError, ImportError) as exc:  # pragma: no cover
+    raise CompiledExtensionNotFoundError(
+        "example_fgen_basic._lib.m_result_dp_w"
+    ) from exc
+
+
+def get_square_root(inv: float) -> float:
+    """
+    Get square root
+
+    Parameters
+    ----------
+    inv
+        Value for which to get the square root
+
+    Returns
+    -------
+    :
+        Square root of `inv`
+
+    Raises
+    ------
+    FortranError
+        `inv` is negative
+
+        TODO: use a more specific error
+    """
+    result_instance_index: int = m_get_square_root_w.get_wavelength(inv)
+
+    result = ResultDP.from_instance_index(result_instance_index)
+
+    if result.is_error:
+        # TODO: be more specific
+        raise FortranError(result.error_v.message)
+
+    res = result.data_v
+
+    m_result_dp_w.finalise_instance(result_instance_index)
+
+    return res

src/example_fgen_basic/result/__init__.py

@@ -0,0 +1,7 @@
+"""
+Definition of result values
+"""
+
+from example_fgen_basic.result.result_dp import ResultDP
+
+__all__ = ["ResultDP"]

src/example_fgen_basic/result/result_dp.py

@@ -0,0 +1,92 @@
+"""
+Python equivalent of the Fortran `ResultDP` class [TODO: x-refs]
+"""
+
+from __future__ import annotations
+
+from attrs import define
+
+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_result_dp_w,
+    )
+except (ModuleNotFoundError, ImportError) as exc:  # pragma: no cover
+    raise CompiledExtensionNotFoundError(
+        "example_fgen_basic._lib.m_result_dp_w"
+    ) from exc
+
+
+@define
+class ResultDP:
+    """
+    Result type that can hold double precision real values
+    """
+
+    # TODO: add validation that one of data_v and error_v is provided but not both
+
+    # data_v: np.Float64
+    data_v: float
+    """Data"""
+
+    error_v: ErrorV
+    """Error"""
+
+    @classmethod
+    def from_instance_index(cls, instance_index: int) -> ErrorV:
+        """
+        Initialise from an instance index received from Fortran
+
+        Parameters
+        ----------
+        instance_index
+            Instance index received from Fortran
+
+        Returns
+        -------
+        :
+            Initialised index
+        """
+        # Different wrapping strategies are needed
+
+        # Integer is very simple
+        if m_result_dp_w.data_v_is_set(instance_index):
+            data_v = m_result_dp_w.get_data_v(instance_index)
+
+        else:
+            data_v = None
+
+        # Error type requires derived type handling
+        if m_result_dp_w.error_v_is_set(instance_index):
+            error_v_instance_index: int = m_result_dp_w.get_error_v(instance_index)
+
+            # Initialise the result from the received index
+            error_v = ErrorV.from_instance_index(error_v_instance_index)
+
+        else:
+            error_v = None
+
+        res = cls(data_v=data_v, error_v=error_v)
+
+        return res
+
+    def build_fortran_instance(self) -> int:
+        """
+        Build an instance equivalent to `self` on the Fortran side
+
+        Intended for use mainly by wrapping functions.
+        Most users should not need to use this method directly.
+
+        Returns
+        -------
+        :
+            Instance index of the object which has been created on the Fortran side
+        """
+        raise NotImplementedError
+        # instance_index: int = m_error_v_w.build_instance(
+        #     code=self.code, message=self.message
+        # )
+        #
+        # return instance_index