#include <LightApp_PyInterp.h>

Inheritance diagram for LightApp_PyInterp:

Public Member Functions
	LightApp_PyInterp ()
virtual	~LightApp_PyInterp ()
void	initialize ()
	Initialize embedded interpreter.
virtual int	run (const char *command)
	Run Python command.
PyLockWrapper	GetLockWrapper ()
	Get Python GIL wrapper.
std::string	getbanner ()
	Get embedded Python interpreter banner.
void	setverrcb (PyOutChanged , void )
	Set Python standard error device hook.
void	setvoutcb (PyOutChanged , void )
	Set Python standard output device hook.
const char *	getPrevious ()
	Get previous command in the commands history.
const char *	getNext ()
	Get next command in the commands history.
Static Public Attributes
static int	_argc = 1
static char *	_argv [] = {(char*)""}
static PyObject *	builtinmodule = NULL
static PyThreadState *	_gtstate = NULL
static PyInterpreterState *	_interp = NULL
Protected Member Functions
virtual void	initPython ()
virtual bool	initContext ()
virtual bool	initState ()
	Initialize internal Python interpreter state.
virtual int	beforeRun ()
int	simpleRun (const char *command, const bool addToHistory=true)
	Run Python command (used internally).
virtual bool	initRun ()
	Initialize run command.
Protected Attributes
PyThreadState *	_tstate
PyObject *	_vout
PyObject *	_verr
PyObject *	_g
PyObject *	_codeop
std::list< std::string >	_history
std::list< std::string >::iterator	_ith

Detailed Description

EDF-CCAR When SALOME uses multi Python interpreter feature, Every study has its own interpreter and thread state (_tstate = Py_NewInterpreter()) This is fine because every study has its own modules (sys.modules) stdout and stderr BUT some Python modules must be imported only once. In multi interpreter context Python modules (*.py) are imported several times. The pyqt module must be imported only once because it registers classes in a C module. It's quite the same with omniorb modules (internals and generated with omniidl) This problem is handled with "shared modules" defined in salome_shared_modules.py These "shared modules" are imported only once and only copied in all the other interpreters BUT it's not the only problem. Every interpreter has its own __builtin__ module. That's fine but if we have copied some modules and imported others problems may arise with operations that are not allowed in restricted execution environment. So we must impose that all interpreters have identical __builtin__ module. That's all, for the moment ...

Constructor & Destructor Documentation

LightApp_PyInterp::LightApp_PyInterp ( )

constructor : multi Python interpreter, one per SALOME study. calls initialize method defined in base class, which calls virtual methods initstate & initcontext redefined here.

LightApp_PyInterp::~LightApp_PyInterp ( ) [virtual]

Destructor.

Member Function Documentation

void LightApp_PyInterp::initPython ( ) [protected, virtual]

Do nothing The initialization has been done in main

Reimplemented from PyInterp_Interp.

References PyInterp_Interp._gtstate, and PyInterp_Interp._interp.

bool LightApp_PyInterp::initContext ( ) [protected, virtual]

The GIL is assumed to be held It is the caller responsability caller to acquire the GIL It will still be held on initContext output

Reimplemented from PyConsole_Interp.

References PyConsole_Interp.initContext(), and SUIT_PYTHON.salome_shared_modules_module.

bool PyConsole_Interp::initState ( ) [protected, virtual, inherited]

When calling initState the GIL is not held It must not be held on exit

Returns:: true on success

Implements PyInterp_Interp.

References PyInterp_Interp._argc, PyInterp_Interp._argv, PyInterp_Interp._interp, PyInterp_Interp._tstate, and PyInterp_Interp.builtinmodule.

void PyInterp_Interp::initialize ( ) [inherited]

This method shoud be called after construction of the interpreter. The method initialize() calls virtuals methods

initPython() to initialize global Python interpreter
initState() to initialize embedded interpreter state
initContext() to initialize interpreter internal context
initRun() to prepare interpreter for running commands which should be implemented in the successor classes, according to the embedded Python interpreter policy (mono or multi interpreter, etc).

References PyInterp_Interp._history, PyInterp_Interp._ith, PyInterp_Interp._tstate, PyInterp_Interp._verr, PyInterp_Interp._vout, PyInterp_Interp.initContext(), PyInterp_Interp.initPython(), PyInterp_Interp.initRun(), PyInterp_Interp.initState(), and newPyStdOut().