common.hh

Go to the documentation of this file.

// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set ts=8 sw=4 et sts=4:
 
// SPDX-FileCopyrightText: Copyright © DUNE-FUFEM Project contributors, see file AUTHORS.md
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception OR LGPL-3.0-or-later
 
#ifndef DUNE_FUFEM_PYTHON_COMMON_HH
#define DUNE_FUFEM_PYTHON_COMMON_HH
 
// Only introduce the dune-python interface if python
// was found and enabled.
#if HAVE_PYTHON || DOXYGEN
 
#include <Python.h>
 
#include <string>
#include <sstream>
#include <type_traits>
#include <tuple>
 
#include <dune/common/exceptions.hh>
 
#include <dune/functions/common/signature.hh>
#include <dune/functions/common/differentiablefunctionfromcallables.hh>
 
#include <dune/fufem/python/reference.hh>
#include <dune/fufem/python/module.hh>
#include <dune/fufem/python/callable.hh>
 
 
namespace Python
{
 
// Forward declarations
bool isModule(const Reference&);
 
 
 
 
 
// *****************************************************************************
// Base class of Conversion that do the PyObject* <-> C++-type conversion
// *****************************************************************************
 
template<class T>
struct Conversion
{
    static void toC(PyObject* x, T& y)
    {
        DUNE_THROW(Dune::Exception, "Conversion to C type " << typeid(T).name() << " not implemented");
    }
 
    static PyObject* toPy(const T& x)
    {
        DUNE_THROW(Dune::Exception, "Conversion from C type " << typeid(T).name() << " not implemented");
        return 0;
    }
};
 
 
 
// *****************************************************************************
// The following are helper functions for implementors and should not be
// used by user code in order to avoid messing up reference counts.
// *****************************************************************************
namespace Imp
{
    PyObject* inc(PyObject* p)
    {
        Py_XINCREF(p);
        return p;
    }
 
    Reference& inc(Reference& p)
    {
        Py_XINCREF(p);
        return p;
    }
 
    // Calling makeObject() with a type derived from Reference should
    // just return a Reference to the same object.
    template<class T>
    typename std::enable_if<std::is_base_of<Reference,T>::value, Reference>::type
    makeObject(const T& t)
    {
        return t;
    }
 
    // Calling makeObject() with any type not derived from Reference should
    // convert this object to a Reference.
    template<class T>
    typename std::enable_if<not(std::is_base_of<Reference,T>::value), Reference>::type
    makeObject(const T& t)
    {
        return Conversion<T>::toPy(t);
    }
 
 
} // end of namespace Imp
 
 
// *****************************************************************************
// The following methods simplify the usage of the python api from C++.
// *****************************************************************************
 
void start()
{
    // initialize without registering signal handlers
    // otherwise you cannot stop the program with ctrl-c
    Py_InitializeEx(0);
}
 
void stop()
{
    Py_Finalize();
}
 
Module import(const std::string& moduleName)
{
    Module pModule = PyImport_ImportModule(moduleName.c_str());
    if (not pModule)
        DUNE_THROW(Dune::Exception, "failed to retrieve python module " << moduleName);
    return pModule;
}
 
Module createModule(const std::string& moduleName)
{
    // PyImport_AddModule returns a borrowed reference so we have to call inc.
    Module pModule = Imp::inc(PyImport_AddModule(moduleName.c_str()));
    if (not pModule)
        DUNE_THROW(Dune::Exception, "failed to create python module " << moduleName);
#if PY_MAJOR_VERSION >= 3
    Reference pBuiltin = Python::import("builtins");
#else
    Reference pBuiltin = Python::import("__builtin__");
#endif
    if (pBuiltin)
        pModule.set("__builtins__", pBuiltin);
    return pModule;
}
 
Module main()
{
    return import("__main__");
}
 
void run(const std::string& code)
{
    PyRun_SimpleString(code.c_str());
}
 
void run(const std::string& code, Reference& module)
{
    if (not isModule(module))
        DUNE_THROW(Dune::Exception, "tried to use non-module where a module is expected");
    Python::Reference dict = module.get("__dict__");
    PyRun_String(code.c_str(), Py_file_input, dict, dict);
}
 
Module::AutoRunCodeStream runStream()
{
    return Module::AutoRunCodeStream();
}
 
Module::AutoRunCodeStream runStream(Module module)
{
    return module.runStream();
}
 
void runFile(const std::string& fileName)
{
    // the last argument specifies that the file should be closed
    // after executing the code
    PyRun_SimpleFileEx(fopen(fileName.c_str(), "r"),fileName.c_str(), 1);
}
 
void runFile(const std::string& fileName, Module module)
{
    module.runFile(fileName);
}
 
Reference evaluate(const std::string& expression)
{
    Module main = Python::import("__main__");
    return main.evaluate(expression);
}
 
Reference evaluate(const std::string& expression, Module module)
{
    return module.evaluate(expression);
}
 
template<class T>
Reference makeObject(const T& t)
{
    return Imp::makeObject(t);
}
 
template<typename... Ts>
Reference makeTuple(const Ts&... ts)
{
    return PyTuple_Pack(sizeof...(Ts), (static_cast<PyObject*>(makeObject(ts)))...);
}
 
template<typename... Ts>
Reference tuple(const Ts&... ts)
{
    return makeTuple(ts...);
}
 
Reference dict()
{
    return PyDict_New();
}
 
int size(const Reference& s)
{
    return PySequence_Size(s);
}
 
Reference iter(const Reference& seq)
{
    return PyObject_GetIter(seq);
}
 
Reference next(const Reference& iter)
{
    return PyIter_Next(iter);
}
 
Reference getItem(const Reference& seq, int i)
{
    return PySequence_GetItem(seq, i);
}
 
Reference getItem(const Reference& dict, const Reference& k)
{
    // We have to use inc() since PyDict_GetItem returns a borrowed reference!
    return Reference(Imp::inc(PyDict_GetItem(dict, k)));
}
 
template<class V>
void setItem(Reference& seq, int i, const V& v)
{
    PySequence_SetItem(seq, i, makeObject(v));
}
 
template<class K, class V>
void setItem(Reference& dict, const K& k, const V& v)
{
    PyDict_SetItem(dict, makeObject(k), makeObject(v));
}
 
bool isSequence(const Reference& ref)
{
    return PySequence_Check(ref);
}
 
bool isDict(const Reference& ref)
{
    return PyDict_Check(ref);
}
 
bool isModule(const Reference& ref)
{
    return ref && PyModule_Check(ref);
}
 
bool isCallable(const Reference& ref)
{
    return ref && PyCallable_Check(ref);
}
 
Reference keys(const Reference& dict)
{
    return PyDict_Keys(dict);
}
 
template<class Signature, template<class> class DerivativeTraits = Dune::Functions::DefaultDerivativeTraits>
auto makeFunction(const Reference& f)
{
    using Range = typename Dune::Functions::SignatureTraits<Signature>::Range;
    using Domain = typename Dune::Functions::SignatureTraits<Signature>::Domain;
    return [callable = Python::Callable(f)](const Domain& x) {
        return callable(x).template toC<Range>();
    };
}
 
template<class Signature, template<class> class DerivativeTraits = Dune::Functions::DefaultDerivativeTraits, class... R>
auto makeDifferentiableFunction(const R&... f)
{
    auto signatureTag = Dune::Functions::SignatureTag<Signature, DerivativeTraits>();
    auto derivativeSignatureTags = Dune::Functions::derivativeSignatureTags<sizeof...(f)-1>(signatureTag);
 
    return std::apply([&f..., &signatureTag](auto... tag) {
            return Dune::Functions::makeDifferentiableFunctionFromCallables(signatureTag,
                makeFunction<typename decltype(tag)::Signature>(f)...);
        }, derivativeSignatureTags);
}
 
void handlePythonError(const std::string& origin, const std::string& message)
{
    PyObject *rawType, *rawValue, *rawTraceback;
    PyErr_Fetch(&rawType, &rawValue, &rawTraceback);
 
    Reference type(rawType);
    Reference value(rawValue);
    Reference traceback(rawTraceback);
    if (type and value)
        DUNE_THROW(Dune::Exception,
            "Python error occurred." << std::endl <<
            "  Origin:  " << origin << std::endl <<
            "  Error:   " << message << std::endl <<
            "  Python error message: " << value.str() );
    else if (type)
        DUNE_THROW(Dune::Exception,
            "Python error occurred." << std::endl <<
            "  Origin:  " << origin << std::endl <<
            "  Error:   " << message);
}
 
 
} // end of namespace Python
 
 
 
#else
    #warning dunepython.hh was included but python was not found or enabled!
#endif // DUNE_FUFEM_PYTHON_COMMON_HH
 
 
#endif