module.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_MODULE_HH
#define DUNE_FUFEM_PYTHON_MODULE_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 <vector>
#include <map>
 
#include <dune/common/exceptions.hh>
#include <dune/common/shared_ptr.hh>
#include <dune/common/fvector.hh>
#include <dune/common/parametertree.hh>
#include <dune/common/typetraits.hh>
#include <dune/common/stringutility.hh>
 
#include <dune/grid/common/gridfactory.hh>
 
#include <dune/fufem/python/reference.hh>
 
 
namespace Python
{
 
// forward declarations
void handlePythonError(const std::string& origin, const std::string& message);
void run(const std::string& code);
 
 
 
class Module :
    public Reference
{
    public:
 
        class AutoRunCodeStream :
            public std::stringstream
        {
            public:
                ~AutoRunCodeStream()
                {
                    if (module_)
                        Module(module_).run(this->str());
                    else
                        Python::run(this->str());
                }
 
                AutoRunCodeStream()
                {}
 
                AutoRunCodeStream(Reference& module) :
                    module_(module)
                {}
 
                AutoRunCodeStream(const AutoRunCodeStream& other) :
                    module_(other.module_)
                {}
 
            private:
                Reference module_;
        };
 
 
 
    public:
 
        Module() :
            Reference()
        {}
 
        Module(PyObject* p) :
            Reference(p)
        {
            assertModule(p_, "Module(PyObject*)");
            if (p_)
                dict_ = get("__dict__");
        }
 
        Module(const Reference& other) :
            Reference(other)
        {
            assertModule(p_, "Module(Reference&)");
            if (p_)
                dict_ = get("__dict__");
        }
 
        virtual ~Module()
        {}
 
        virtual Module& operator= (const Reference& other)
        {
            assertModule(other, "Module::operator=(Reference&)");
            Reference::operator=(other);
            if (p_)
                dict_ = get("__dict__");
            return *this;
        }
 
        virtual void run(const std::string& code)
        {
            assertPyObject("Module::run()");
            if (not PyRun_String(code.c_str(), Py_file_input, dict_, dict_))
                handlePythonError("Module::run()", Dune::formatString("failed to execute the following code '%s'", code.c_str()));
        }
 
        AutoRunCodeStream runStream()
        {
            assertPyObject("Module::runStream()");
            return AutoRunCodeStream(*this);
        }
 
        void runFile(const std::string& fileName)
        {
            assertPyObject("Module::runFile()");
            // the last argument specifies that the file should be closed
            // after executing the code
            PyRun_FileEx(fopen(fileName.c_str(), "r"), fileName.c_str(), Py_file_input, dict_, dict_, 1);
        }
 
        Reference evaluate(const std::string& expression)
        {
            return PyRun_String(expression.c_str(), Py_eval_input, dict_, dict_);
        }
 
 
        Module importAs(Module module, const std::string& importedName)
        {
            if (not module)
                handlePythonError("Module::importAs(Module,string)", "failed to import module");
            set(importedName, module);
            return module;
        }
 
        Module importAs(const std::string& moduleName, const std::string& importedName)
        {
            Module module(PyImport_ImportModule(moduleName.c_str()));
            return importAs(module, importedName);
        }
 
        Module import(Module module)
        {
            if (not module)
                handlePythonError("Module::import(Module)", "failed to import module");
            return importAs(module, module.get("__name__").str());
        }
 
        Module import(const std::string& moduleName)
        {
            return importAs(moduleName, moduleName);
        }
 
    protected:
 
        static void assertModule(PyObject* p, const std::string& origin)
        {
            if (p and (not PyModule_Check(p)))
                DUNE_THROW(Dune::Exception,
                    "Python error occurred." << std::endl <<
                    "  Origin:  " << origin << std::endl <<
                    "  Error:   Trying to use a non-module as module");
        }
 
        Reference dict_;
};
 
 
} // end of namespace Python
 
 
 
#else
    #warning dunepython.hh was included but python was not found or enabled!
#endif // DUNE_FUFEM_PYTHON_MODULE_HH
 
 
#endif