Simple fortran example

module f_module

    implicit none

    type :: f_type

        integer :: exponent
        double precision :: mantissa

    end type f_type

contains

    subroutine f_pow(a, b)

        implicit none

        type (f_type), intent(in) :: a
        double precision, intent(out) :: b

        b = (a % mantissa)**(a % exponent)

    end subroutine f_pow

end module f_module

gfortran -c f_module.f90
f90wrap -c -m f_module f_module.f90
f2py-f90wrap -c -m _f_module f90wrap_f_module.f90 -L. f_module.o

import _f_module
import f90wrap.runtime
import logging

class F_Module(f90wrap.runtime.FortranModule):
    class F_Type(f90wrap.runtime.FortranDerivedType):

        def __init__(self, handle=None):
            f90wrap.runtime.FortranDerivedType.__init__(self)
            self._handle = _f_module.f90wrap_f_type_initialise()

        def __del__(self):
            if self._alloc:
                _f_module.f90wrap_f_type_finalise(this=self._handle)

        @property
        def exponent(self):
            return _f_module.f90wrap_f_type__get__exponent(self._handle)

        @exponent.setter
        def exponent(self, exponent):
            _f_module.f90wrap_f_type__set__exponent(self._handle, exponent)

        @property
        def mantissa(self):
            return _f_module.f90wrap_f_type__get__mantissa(self._handle)

        @mantissa.setter
        def mantissa(self, mantissa):
            _f_module.f90wrap_f_type__set__mantissa(self._handle, mantissa)

    @staticmethod
    def f_pow(a):
        b = _f_module.f90wrap_f_pow(a=a._handle)
        return b

f_module = F_Module()

from f_module import f_module

a = f_module.F_Type()
a.mantissa = 2.5
a.exponent = 2

f_module.f_pow(a)

>> 6.25

from unittest.mock import patch
import unittest
import numpy as np

class TestCase(unittest.TestCase):

    class mocked_F_type():
        def __init__(self):
            print("\nUsing mocked F_type")
            self.exponent = 0
            self.mantissa = 0

    def mocked_f_pow(a):
        print("\nUsing mocked f_pow")
        return a.mantissa ** a.exponent

    @patch('f_module.f_module.f_pow', new=mocked_f_pow)
    @patch('f_module.f_module.F_Type', new=mocked_F_type)
    def test_py_pow(self):
        from run_f_module import py_pow

        np.testing.assert_equal(py_pow(2.5, 2), 6.25)

    def test_py_pow2(self):
        from run_f_module import py_pow

        np.testing.assert_equal(py_pow(2.5, 2), 6.25)

Simple python example

def add_me(x, y):
    return x + y

#include "Python.h"

int add(int x, int y)
{
    PyObject *pName, *pModule, *pDict, *pFunc, *pArgs, *pValue;
    int i;
    const char* pymodule = "python_ex";
    const char* pyfunc = "add_me";

    // initialise python interpreter
    Py_Initialize();

    // add current directory to python path
    PyRun_SimpleString("import sys");
    PyRun_SimpleString("sys.path.append(\".\")");

    // build the name object
    pName = PyUnicode_FromString(pymodule);

    // build the module object
    pModule = PyImport_Import(pName);
    Py_DECREF(pName);

    if (pModule != NULL) {
        pDict = PyModule_GetDict(pModule);
        pFunc = PyDict_GetItemString(pDict, pyfunc);

        if (pFunc && PyCallable_Check(pFunc)) {
            pArgs = Py_BuildValue("(ii)", x, y);
            pValue = PyObject_CallObject(pFunc, pArgs);
            Py_DECREF(pArgs);
            if (pValue != NULL) {
                printf("Result of call: %ld\n", PyLong_AsLong(pValue));
                Py_DECREF(pValue);
            }
            else { /* Call failed */ }
        }
        else { /* Cannot find function */ }
        Py_XDECREF(pFunc);
        Py_DECREF(pModule);
    }
    else { /* Cannot load module */ }

    i = PyLong_AsLong(pValue);
    Py_Finalize();
    return i;
}
	

yt hello world

import yt

# load data into DataSet
ds = yt.load('plt13740')

# create Slice Plot of prim_density
yt.SlicePlot(ds, 'z', 'prim_density').save('13740')

ds.create_field_info()
ds.field_info[('boxlib', 'prim_density')].display_name = r'$\rho$'

centre = 0.5 * (ds.domain_left_edge + ds.domain_right_edge) *
         np.sign(ds.domain_width)

p = yt.SlicePlot(ds, 'z', 'prim_density', origin='native', center=centre)

v, c = ds.find_max('prim_density')
p.annotate_sphere([c[0],c[1]], radius=0.015, coord_system='axis',
                   text=f'Max density = {float(v.d):.2f}',
                   circle_args={'color':'black', 'linewidth':4},
                   text_args={'color':'black', 'size':30})

p.annotate_quiver('prim_u', 'prim_v', 70)

axis_widths = tuple([(ds.domain_width.value[i], 'unitary') for i in range(3)])
p.set_width(axis_widths)

p.annotate_timestamp(draw_inset_box=True)