Python interpreter access
The TPython class allows for access to python objects from CINT. The current
functionality is only basic: ROOT objects and builtin types can freely cross
the boundary between the two interpreters, python objects can be instantiated
and their methods can be called. All other cross-coding is based on strings
that are run on the python interpreter.
Examples:
$ cat MyPyClass.py
print 'creating class MyPyClass ... '
class MyPyClass:
def __init__( self ):
print 'in MyPyClass.__init__'
def gime( self, what ):
return what
$ root -l
// Execute a string of python code.
root [0] TPython::Exec( "print \'Hello World!\'" );
Hello World!
// Create a TBrowser on the python side, and transfer it back and forth.
// Note the required explicit (void*) cast!
root [1] TBrowser* b = (void*)TPython::Eval( "ROOT.TBrowser()" );
root [2] TPython::Bind( b, "b" );
root [3] b == (void*) TPython::Eval( "b" )
(int)1
// Builtin variables can cross-over by using implicit casts.
root [4] int i = TPython::Eval( "1 + 1" );
root [5] i
(int)2
// Load a python module with a class definition, and use it.
root [6] TPython::LoadMacro( "MyPyClass.py" );
creating class MyPyClass ...
root [7] MyPyClass m;
in MyPyClass.__init__
root [8] char* s = m.gime( "aap" );
root [9] s
(char* 0x41ee7754)"aap"
It is possible to switch between interpreters by calling "TPython::Prompt()"
on the CINT side, while returning with ^D (EOF). State is preserved between
successive switches.
The API part provides (direct) C++ access to the bindings functionality of
PyROOT. It allows verifying that you deal with a PyROOT python object in the
first place (ObjectProxy_Check for ObjectProxy and any derived types, as well
as ObjectProxy_CheckExact for ObjectProxy's only); and it allows conversions
of void* to an ObjectProxy and vice versa.