def test01_size_mapping(self): """Use composites to map GetSize() onto buffer returns""" import cppyy exp_pyroot = self.exp_pyroot def set_size(self, buf): if exp_pyroot: buf.reshape((self.GetN(), )) else: buf.SetSize(self.GetN()) return buf if exp_pyroot: cppyy.py.add_pythonization( cppyy.py.compose_method("pythonizables::MyBufferReturner$", "Get[XY]$", set_size)) else: cppyy.add_pythonization( cppyy.compose_method("pythonizables::MyBufferReturner$", "Get[XY]$", set_size)) bsize, xval, yval = 3, 2, 5 m = cppyy.gbl.pythonizables.MyBufferReturner(bsize, xval, yval) x = m.GetX() assert len(x) == bsize assert list(x) == list(map(lambda x: x * xval, range(bsize))) y = m.GetY() assert len(y) == bsize assert list(y) == list(map(lambda x: x * yval, range(bsize)))
def test01_size_mapping(self): """Use composites to map GetSize() onto buffer returns""" import cppyy def set_size(self, buf): buf.SetSize(self.GetN()) return buf cppyy.add_pythonization( cppyy.compose_method('MyBufferReturner$', 'Get[XY]$', set_size)) m = cppyy.gbl.MyBufferReturner
def test01_size_mapping(self): """Use composites to map GetSize() onto buffer returns""" import cppyy def set_size(self, buf): buf.SetSize(self.GetN()) return buf cppyy.add_pythonization( cppyy.compose_method("pythonizables::MyBufferReturner$", "Get[XY]$", set_size)) bsize, xval, yval = 3, 2, 5 m = cppyy.gbl.pythonizables.MyBufferReturner(bsize, xval, yval) x = m.GetX() assert len(x) == bsize assert list(x) == map(lambda x: x*xval, range(bsize)) y = m.GetY() assert len(y) == bsize assert list(y) == map(lambda x: x*yval, range(bsize))
def __finalSetup(self): # prevent this method from being re-entered through the gROOT wrapper self.__dict__['gROOT'] = _root.gROOT # switch to running gettattr/setattr self.__class__.__getattr__ = self.__class__.__getattr2 del self.__class__.__getattr2 self.__class__.__setattr__ = self.__class__.__setattr2 del self.__class__.__setattr2 # normally, you'll want a ROOT application; don't init any further if # one pre-exists from some C++ code somewhere hasargv = hasattr(sys, 'argv') if hasargv and PyConfig.IgnoreCommandLineOptions: argv = sys.argv sys.argv = [] appc = _root.CreateScopeProxy('PyROOT::TPyROOTApplication') if (not _builtin_cppyy and appc.CreatePyROOTApplication()) or _builtin_cppyy: appc.InitROOTGlobals() # TODO Cling equivalent needed: appc.InitCINTMessageCallback(); appc.InitROOTMessageCallback() if hasargv and PyConfig.IgnoreCommandLineOptions: sys.argv = argv # must be called after gApplication creation: if _is_ipython: # IPython's FakeModule hack otherwise prevents usage of python from Cling (TODO: verify necessity) _root.gROOT.ProcessLine('TPython::Exec( "" );') sys.modules['__main__'].__builtins__ = __builtins__ # special case for cout (backwards compatibility) if hasattr(cppyy.gbl.std, '__1'): attr_1 = getattr(cppyy.gbl.std, '__1') if hasattr(attr_1, 'cout'): self.__dict__['cout'] = attr_1.cout # python side pythonizations (should live in their own file, if we get many) def set_size(self, buf): buf.SetSize(self.GetN()) return buf # TODO: add pythonization API to pypy-c if not PYPY_CPPYY_COMPATIBILITY_FIXME: cppyy.add_pythonization( cppyy.compose_method("^TGraph(2D)?$|^TGraph.*Errors$", "GetE?[XYZ]$", set_size)) gRootDir = self.gRootDir else: gRootDir = _root.gRootDir # custom logon file (must be after creation of ROOT globals) if hasargv and not '-n' in sys.argv and not PyConfig.DisableRootLogon: rootlogon = os.path.expanduser('~/.rootlogon.py') if os.path.exists(rootlogon): # could also have used execfile, but import is likely to give fewer surprises import imp imp.load_module('rootlogon', open(rootlogon, 'r'), rootlogon, ('.py', 'r', 1)) del imp else: # if the .py version of rootlogon exists, the .C is ignored (the user can # load the .C from the .py, if so desired) # system logon, user logon, and local logon (skip Rint.Logon) name = '.rootlogon.C' logons = [ os.path.join(str(self.TROOT.GetEtcDir()), 'system' + name), os.path.expanduser(os.path.join('~', name)) ] if logons[-1] != os.path.join(os.getcwd(), name): logons.append(name) for rootlogon in logons: if os.path.exists(rootlogon): appc.ExecuteFile(rootlogon) del rootlogon, logons # use either the input hook or thread to send events to GUIs if self.PyConfig.StartGuiThread and \ not ( self.keeppolling or _root.gROOT.IsBatch() ): if _is_ipython and 'IPython' in sys.modules and sys.modules[ 'IPython'].version_info[0] >= 5: from IPython.terminal import pt_inputhooks def _inputhook(context): while not context.input_is_ready(): _root.gSystem.ProcessEvents() pt_inputhooks.register('ROOT', _inputhook) get_ipython().run_line_magic('gui', 'ROOT') elif self.PyConfig.StartGuiThread == 'inputhook' or\ _root.gSystem.InheritsFrom( 'TMacOSXSystem' ): # new, PyOS_InputHook based mechanism if PyConfig.GUIThreadScheduleOnce: for guicall in PyConfig.GUIThreadScheduleOnce: guicall() PyConfig.GUIThreadScheduleOnce = [] _root.InstallGUIEventInputHook() else: # original, threading based approach import threading self.__dict__['keeppolling'] = 1 self.__dict__[ 'PyGUIThread' ] = \ threading.Thread( None, _processRootEvents, None, ( self, ) ) def _finishSchedule(ROOT=self): import threading if threading.currentThread() != self.PyGUIThread: while self.PyConfig.GUIThreadScheduleOnce: self.PyGUIThread.join(0.1) self.PyGUIThread.finishSchedule = _finishSchedule self.PyGUIThread.setDaemon(1) self.PyGUIThread.start() # store already available ROOT objects to prevent spurious lookups for name in self.module.__pseudo__all__ + _memPolicyAPI + _sigPolicyAPI: self.__dict__[name] = getattr(_root, name) # the macro NULL is not available from Cling globals, but might be useful setattr(_root, 'NULL', 0) # TODO: is the following still necessary? Note: dupe of classes in cppyy.py for name in ('complex', 'pair', 'deque', 'list', 'queue', 'stack', 'vector', 'map', 'multimap', 'set', 'multiset'): setattr(_root, name, getattr(cppyy.gbl.std, name)) # set the display hook sys.displayhook = _displayhook # manually load libMathCore, for example to obtain gRandom # This can be removed once autoloading on selected variables is available _root.gSystem.Load("libMathCore")
def __finalSetup( self ): # prevent this method from being re-entered through the gROOT wrapper self.__dict__[ 'gROOT' ] = _root.gROOT # switch to running gettattr/setattr self.__class__.__getattr__ = self.__class__.__getattr2 del self.__class__.__getattr2 self.__class__.__setattr__ = self.__class__.__setattr2 del self.__class__.__setattr2 # normally, you'll want a ROOT application; don't init any further if # one pre-exists from some C++ code somewhere hasargv = hasattr( sys, 'argv' ) if hasargv and PyConfig.IgnoreCommandLineOptions: argv = sys.argv sys.argv = [] appc = _root.CreateScopeProxy( 'PyROOT::TPyROOTApplication' ) if (not _builtin_cppyy and appc.CreatePyROOTApplication()) or _builtin_cppyy: appc.InitROOTGlobals() # TODO Cling equivalent needed: appc.InitCINTMessageCallback(); appc.InitROOTMessageCallback(); if hasargv and PyConfig.IgnoreCommandLineOptions: sys.argv = argv # must be called after gApplication creation: if _is_ipython: # IPython's FakeModule hack otherwise prevents usage of python from Cling (TODO: verify necessity) _root.gROOT.ProcessLine( 'TPython::Exec( "" );' ) sys.modules[ '__main__' ].__builtins__ = __builtins__ # special case for cout (backwards compatibility) if hasattr( cppyy.gbl.std, '__1' ): attr_1 = getattr( cppyy.gbl.std, '__1' ) if hasattr( attr_1, 'cout' ): self.__dict__[ 'cout' ] = attr_1.cout # python side pythonizations (should live in their own file, if we get many) def set_size(self, buf): buf.SetSize(self.GetN()) return buf # TODO: add pythonization API to pypy-c if not PYPY_CPPYY_COMPATIBILITY_FIXME: cppyy.add_pythonization( cppyy.compose_method("^TGraph(2D)?$|^TGraph.*Errors$", "GetE?[XYZ]$", set_size)) gRootDir = self.gRootDir else: gRootDir = _root.gRootDir # custom logon file (must be after creation of ROOT globals) if hasargv and not '-n' in sys.argv and not PyConfig.DisableRootLogon: rootlogon = os.path.expanduser( '~/.rootlogon.py' ) if os.path.exists( rootlogon ): # could also have used execfile, but import is likely to give fewer surprises import imp imp.load_module( 'rootlogon', open( rootlogon, 'r' ), rootlogon, ('.py','r',1) ) del imp else: # if the .py version of rootlogon exists, the .C is ignored (the user can # load the .C from the .py, if so desired) # system logon, user logon, and local logon (skip Rint.Logon) name = '.rootlogon.C' logons = [ os.path.join( str(self.TROOT.GetEtcDir()), 'system' + name ), os.path.expanduser( os.path.join( '~', name ) ) ] if logons[-1] != os.path.join( os.getcwd(), name ): logons.append( name ) for rootlogon in logons: if os.path.exists( rootlogon ): appc.ExecuteFile( rootlogon ) del rootlogon, logons # use either the input hook or thread to send events to GUIs if self.PyConfig.StartGuiThread and \ not ( self.keeppolling or _root.gROOT.IsBatch() ): if _is_ipython and 'IPython' in sys.modules and sys.modules['IPython'].version_info[0] >= 5 : from IPython.terminal import pt_inputhooks import time def _inputhook(context): while not context.input_is_ready(): _root.gSystem.ProcessEvents() time.sleep( 0.01 ) pt_inputhooks.register('ROOT',_inputhook) if get_ipython() : get_ipython().run_line_magic('gui', 'ROOT') elif self.PyConfig.StartGuiThread == 'inputhook' or\ _root.gSystem.InheritsFrom( 'TMacOSXSystem' ): # new, PyOS_InputHook based mechanism if PyConfig.GUIThreadScheduleOnce: for guicall in PyConfig.GUIThreadScheduleOnce: guicall() PyConfig.GUIThreadScheduleOnce = [] _root.InstallGUIEventInputHook() else: # original, threading based approach import threading self.__dict__[ 'keeppolling' ] = 1 self.__dict__[ 'PyGUIThread' ] = \ threading.Thread( None, _processRootEvents, None, ( self, ) ) def _finishSchedule( ROOT = self ): import threading if threading.currentThread() != self.PyGUIThread: while self.PyConfig.GUIThreadScheduleOnce: self.PyGUIThread.join( 0.1 ) self.PyGUIThread.finishSchedule = _finishSchedule self.PyGUIThread.setDaemon( 1 ) self.PyGUIThread.start() # store already available ROOT objects to prevent spurious lookups for name in self.module.__pseudo__all__ + _memPolicyAPI + _sigPolicyAPI: self.__dict__[ name ] = getattr( _root, name ) # the macro NULL is not available from Cling globals, but might be useful setattr( _root, 'NULL', 0 ) # TODO: is the following still necessary? Note: dupe of classes in cppyy.py for name in ( 'complex', 'pair', 'deque', 'list', 'queue', 'stack', 'vector', 'map', 'multimap', 'set', 'multiset' ): setattr( _root, name, getattr( cppyy.gbl.std, name ) ) # set the display hook sys.displayhook = _displayhook # manually load libMathCore, for example to obtain gRandom # This can be removed once autoloading on selected variables is available _root.gSystem.Load( "libMathCore" )
def __finalSetup( self ): # prevent this method from being re-entered through the gROOT wrapper self.__dict__[ 'gROOT' ] = _root.gROOT # switch to running gettattr/setattr self.__class__.__getattr__ = self.__class__.__getattr2 del self.__class__.__getattr2 self.__class__.__setattr__ = self.__class__.__setattr2 del self.__class__.__setattr2 # normally, you'll want a ROOT application; don't init any further if # one pre-exists from some C++ code somewhere hasargv = hasattr( sys, 'argv' ) if hasargv and PyConfig.IgnoreCommandLineOptions: argv = sys.argv sys.argv = [] appc = _root.CreateScopeProxy( 'PyROOT::TPyROOTApplication' ) if appc.CreatePyROOTApplication(): appc.InitROOTGlobals() # TODO Cling equivalent needed: appc.InitCINTMessageCallback(); appc.InitROOTMessageCallback(); if hasargv and PyConfig.IgnoreCommandLineOptions: sys.argv = argv # must be called after gApplication creation: if '__IPYTHON__' in __builtins__: # IPython's FakeModule hack otherwise prevents usage of python from Cling (TODO: verify necessity) _root.gROOT.ProcessLine( 'TPython::Exec( "" );' ) sys.modules[ '__main__' ].__builtins__ = __builtins__ # special case for cout (backwards compatibility) if hasattr( cppyy.gbl.std, '__1' ): attr_1 = getattr( cppyy.gbl.std, '__1' ) if hasattr( attr_1, 'cout' ): self.__dict__[ 'cout' ] = attr_1.cout # python side pythonizations (should live in their own file, if we get many) def set_size(self, buf): buf.SetSize(self.GetN()) return buf cppyy.add_pythonization( cppyy.compose_method("^TGraph(2D)?$|^TGraph.*Errors$", "GetE?[XYZ]$", set_size)) # custom logon file (must be after creation of ROOT globals) if hasargv and not '-n' in sys.argv and not PyConfig.DisableRootLogon: rootlogon = os.path.expanduser( '~/.rootlogon.py' ) if os.path.exists( rootlogon ): # could also have used execfile, but import is likely to give fewer surprises import imp imp.load_module( 'rootlogon', open( rootlogon, 'r' ), rootlogon, ('.py','r',1) ) del imp else: # if the .py version of rootlogon exists, the .C is ignored (the user can # load the .C from the .py, if so desired) # system logon, user logon, and local logon (skip Rint.Logon) name = '.rootlogon.C' logons = [ os.path.join( str(self.gRootDir), 'etc', 'system' + name ), os.path.expanduser( os.path.join( '~', name ) ) ] if logons[-1] != os.path.join( os.getcwd(), name ): logons.append( name ) for rootlogon in logons: if os.path.exists( rootlogon ): appc.ExecuteFile( rootlogon ) del rootlogon, logons # use either the input hook or thread to send events to GUIs if self.PyConfig.StartGuiThread and \ not ( self.keeppolling or _root.gROOT.IsBatch() ): if self.PyConfig.StartGuiThread == 'inputhook' or\ _root.gSystem.InheritsFrom( 'TMacOSXSystem' ): # new, PyOS_InputHook based mechanism if PyConfig.GUIThreadScheduleOnce: for guicall in PyConfig.GUIThreadScheduleOnce: guicall() PyConfig.GUIThreadScheduleOnce = [] _root.InstallGUIEventInputHook() else: # original, threading based approach import threading self.__dict__[ 'keeppolling' ] = 1 self.__dict__[ 'PyGUIThread' ] = \ threading.Thread( None, _processRootEvents, None, ( self, ) ) def _finishSchedule( ROOT = self ): import threading if threading.currentThread() != self.PyGUIThread: while self.PyConfig.GUIThreadScheduleOnce: self.PyGUIThread.join( 0.1 ) self.PyGUIThread.finishSchedule = _finishSchedule self.PyGUIThread.setDaemon( 1 ) self.PyGUIThread.start() # store already available ROOT objects to prevent spurious lookups for name in self.module.__pseudo__all__ + _memPolicyAPI + _sigPolicyAPI: self.__dict__[ name ] = getattr( _root, name ) # the macro NULL is not available from Cling globals, but might be useful setattr( _root, 'NULL', 0 ) for name in cppyy.gbl.std.stlclasses: setattr( _root, name, getattr( cppyy.gbl.std, name ) ) # set the display hook sys.displayhook = _displayhook