Loading...
Searching...
No Matches
Python.hpp
/*
Copyright 2019 Equinor ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef OPM_PYTHON_HPP
#define OPM_PYTHON_HPP
#include <memory>
#include <string>
namespace Opm {
class EclipseState;
class PythonInterp;
class Parser;
class Deck;
class SummaryState;
class Schedule;
namespace Action {
class PyAction;
}
/*
This class is a thin wrapper around the PythonInterp class. The Python class
can always be safely instantiated, but the actual PythonInterp implementation
depends on whether Python support was enabled when this library instance was
compiled.
If one the methods actually invoking the Python interpreter is invoked without
proper Python support a dummy PythinInterp instance will be used; and that
will just throw std::logic_error. The operator bool can be used to check if
this Python manager indeed has a valid Python runtime:
auto python = std::make_shared<Python>();
if (python)
python.exec("print('Hello world')")
else
OpmLog::Error("This version of opmcommon has been built with support for embedded Python");
The default constructor will enable the Python interpreter if the current
version of opm-common has been built support for embedded Python, by using the
alternative Python(Enable enable) constructor you can explicitly say if you
want Python support or not; if that request can not be satisfied you will get
std::logic_error().
Observe that the real underlying Python interpreter is essentially a singleton
- i.e. only a one interpreter can be active at any time. If a Python
interpreter has already been instantiated you can still create an additional
Opm::Python instance, but that will be empty and not capable of actually
running Python code - so although it is technically possible to have more than
simultaneous Opm::Python instance it is highly recommended to create only one.
The details of the interaction between build configuration, constructor arg
and multiple instances is summarized in the table below. The columns should be
interpreted as follows:
Build: This is whether opm has been built with support for embedding Python,
i.e. whether the flag OPM_ENABLE_EMBEDDED_PYTHON was set to True at
configure time.
Constructor arg: This the enum argument passed to the constructor. The
default value is Enable::TRY which means that we will try to instantiate
a Python interpreter. If that fails - either because a Python interpreter
is already running or because opm-common has been built without Python
support - you will get a empty but valid Opm::Python object back.
Existing instance: Is there already Python interpreter running? The value *
implies that the end result will be the same irrespective of whether we
have a Python instance running.
Result: What kind of Opm::Python instance will we get - here { } implies an
empty Opm::Python instance. This does *not* hold on to an actual
interpreter and can not be used to run code - for this type of
Opm::Python instance the enabled() method will return false. { Python }
means that we will get a Opm::Python instance which manages a true Python
interpreter.
std::logic_error means that you have asked for something which can not be
satisfied and std::logic_error exception will be raised.
Build: | Constructor arg | Existing instance | Result
---------|--------------------|---------------------|-------
True | OFF | * | { }
True | ON | True | std::logic_error
True | ON | False | { Python }
True | TRY | True | { }
True | TRY | False | { Python }
False | OFF | * | { }
False | ON | * | std::logic_error
False | TRY | * | { }
---------|--------------------|---------------------|-------
*/
class Python {
public:
enum class Enable {
ON, /* Enable the Python extensions - throw std::logic_error() if it fails. */
TRY, /* Try to enable Python extensions*/
OFF /* Do not enable Python */
};
explicit Python(Enable enable = Enable::TRY);
bool exec(const std::string& python_code) const;
bool exec(const std::string& python_code, const Parser& parser, Deck& deck) const;
bool exec(const Action::PyAction& py_action, EclipseState& ecl_state, Schedule& schedule, std::size_t report_step, SummaryState& st) const;
/*
The enabled function returns true if this particular Python instance
manages a true Python interpreter.
*/
bool enabled() const;
/*
The supported function return true if this instance of opm-common has been
compiled with support for Python.
*/
static bool supported();
bool run_module(const std::string& path);
private:
std::shared_ptr<PythonInterp> interp;
};
}
#endif
Opm::Action::PyAction
Definition PyAction.hpp:40
Opm::Deck
Definition Deck.hpp:46
Opm::EclipseState
Definition EclipseState.hpp:62
Opm::Parser
The hub of the parsing process.
Definition Parser.hpp:60
Opm::PythonInterp
Definition PythonInterp.hpp:67
Opm::Schedule
Definition Schedule.hpp:101
Opm::SummaryState
Definition SummaryState.hpp:72
Opm
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition Exceptions.hpp:30
Opm::path
const std::string & path() const
Returns the path of the parameter group.