python.RootUtils Namespace Reference

Classes
class	RootFileDumper

Functions
	import_root (batch=True)
	functions --------------------------------------------------------------—
	root_compile (src=None, fname=None, batch=True)
	_root_compile (src, fname, batch)
	_pythonize_tfile ()
	_getLeaf (l)
	_test_main ()

Variables
str	__doc__ = "a few utils to ease the day-to-day work with ROOT"
str	__author__ = "Sebastien Binet"
list	__all__
list	_tempfiles = []
bool	_first_compile = True

Function Documentation

_getLeaf()

python.RootUtils._getLeaf ( l )

protected

Definition at line 184 of file RootUtils.py.

def _getLeaf (l):
    tname = l.GetTypeName()
    ndat = l.GetNdata()
    if (l.GetLeafCount()  # a varying length array
        or ndat > 1):     # a fixed size array
        if tname in ['UInt_t', 'Int_t', 'ULong_t', 'Long_t', 'ULong64_t', 'Long64_t', 'UShort_t', 'Short_t', 'Bool_t']:
            return tuple(l.GetValueLong64(i) for i in range(ndat))
        elif tname in ['Float_t', 'Double_t', 'Float16_t', 'Double32_t']:
            return tuple(l.GetValue(i) for i in range(ndat))
        elif tname in ['UChar_t', 'Char_t']:
            try:
                return l.GetValueString() # TLeafC for variable size string
            except Exception:
                return tuple(l.GetValueLong64(i) for i in range(ndat)) # TLeafB for 8-bit integers
    elif ndat == 1:  # a single value
        if tname in ['UInt_t', 'Int_t', 'ULong_t', 'Long_t', 'ULong64_t', 'Long64_t', 'UShort_t', 'Short_t', 'Bool_t']:
            return l.GetValueLong64()
        elif tname in ['Float_t', 'Double_t', 'Float16_t', 'Double32_t']:
            return l.GetValue()
        elif tname in ['UChar_t', 'Char_t']:
            try:
                return l.GetValueString()  # TLeafC for variable size string
            except Exception:
                return l.GetValueLong64()  # TLeafB for 8-bit integers
 
    return None
 

_pythonize_tfile()

python.RootUtils._pythonize_tfile ( )

protected

Definition at line 120 of file RootUtils.py.

def _pythonize_tfile():
    import cppyy
    root = import_root()
    import PyUtils.Helpers as H
    with H.ShutUp(filters=[
        re.compile(
            'TClass::TClass:0: RuntimeWarning: no dictionary for.*'),
        re.compile(
            'Warning in <TEnvRec::ChangeValue>: duplicate entry.*'
            ),
        ]):
        cppyy.load_library("libRootUtilsPyROOTDict")
        _ = root.RootUtils.PyBytes
        #MN: lines below fail in ROOT6 if PCM from RootUtils is not found
        read_root_file = root.RootUtils._pythonize_read_root_file
        tell_root_file = root.RootUtils._pythonize_tell_root_file
        pass
    def read(self, size=-1):
        """read([size]) -> read at most size bytes, returned as a string.
 
        If the size argument is negative or omitted, read until EOF is reached.
        Notice that when in non-blocking mode, less data than what was requested
        may be returned, even if no size parameter was given.
 
        FIXME: probably doesn't follow python file-like conventions...
        """
        SZ = 4096
 
        if size>=0:
            #size = _adjust_sz(size)
            #print ("-->0",self.tell(),size)
            c_buf = read_root_file(self, size)
            if c_buf and c_buf.sz:
                v = c_buf.buf
                return bytes([ord(v[i]) for i in range(v.size())])
            return ''
        else:
            size = SZ
            out = []
            while True:
                #size = _adjust_sz(size)
                c_buf = read_root_file(self, size)
                if c_buf and c_buf.sz:
                    v = c_buf.buf
                    chunk = bytes([ord(v[i]) for i in range(v.size())])
                    out.append(chunk)
                else:
                    break
            return b''.join(out)
            
    root.TFile.read = read
    del read
    
    root.TFile.seek = root.TFile.Seek
    root.TFile.tell = lambda self: tell_root_file(self)
    
    return 
 
 

_root_compile()

python.RootUtils._root_compile ( src, fname, batch )

protected

Definition at line 66 of file RootUtils.py.

def _root_compile (src, fname, batch):
    import os
    from .Helpers import ShutUp as root_shutup
    
    ROOT = import_root(batch=batch)
    compile_options = "f"
    if 'dbg' in os.environ.get('CMTCONFIG', 'opt'):
        compile_options += 'g'
    else:
        compile_options += 'O'
 
    src_file = None
    if src:
        import textwrap
        import tempfile
        src_file = tempfile.NamedTemporaryFile(prefix='root_aclic_',
                                               suffix='.cxx')
        src_file.write(textwrap.dedent(src).encode())
        src_file.flush()
        src_file.seek(0)
        fname = src_file.name
 
        # Apparently, cling caches files by inode.
        # If you ask it to read a file that has the same inode as one
        # that it has already read, then it will just use the cached
        # contents rather than rereading.  This, however, doesn't play
        # very well if we're reading temp files, where inodes may be reused,
        # giving rise to hard-to-reproduce failures.
        #
        # Try to avoid this by keeping the temp files open until the
        # the program exits.
        _tempfiles.append (src_file)
        pass
 
    elif fname:
        import os.path as osp
        fname = osp.expanduser(osp.expandvars(fname))
        pass
        
    assert os.access(fname, os.R_OK), "could not read [%s]"%(fname,)
    orig_root_lvl = ROOT.gErrorIgnoreLevel
    ROOT.gErrorIgnoreLevel = ROOT.kWarning
    try:
        with root_shutup():
            sc = ROOT.gSystem.CompileMacro(fname, compile_options)
        if sc == ROOT.kFALSE:
            raise RuntimeError(
                'problem compiling ROOT macro (rc=%s)'%(sc,)
                )
    finally:
        ROOT.gErrorIgnoreLevel = orig_root_lvl
    return
        
@cache

_test_main()

python.RootUtils._test_main ( )

protected

Definition at line 506 of file RootUtils.py.

def _test_main():
    root = import_root()  # noqa: F841
    def no_raise(msg, fct, *args, **kwds):
        caught = False
        err = None
        try:
            fct(*args, **kwds)
        except Exception as xerr:
            err = xerr
            caught = True
        assert not caught, "%s:\n%s\nERROR" % (msg, err,)
 
    no_raise("problem pythonizing TFile", fct=_pythonize_tfile)
    no_raise("problem compiling dummy one-liner",
             root_compile, "void foo1() { return ; }")
    no_raise("problem compiling dummy one-liner w/ kwds",
             fct=root_compile, src="void foo1a() { return ; }")
    import tempfile
    # PvG workaround for ROOT-7059
    dummy = tempfile.NamedTemporaryFile(prefix="foo_",suffix=".cxx")  # noqa: F841
    with tempfile.NamedTemporaryFile(prefix="foo_",suffix=".cxx") as tmp:
        tmp.write (b"void foo2() { return ; }\n")
        tmp.flush()
        no_raise("problem compiling a file",
                 fct=root_compile, fname=tmp.name)
 
    print ("OK")
    return True
 

import_root()

python.RootUtils.import_root

(

batch = True

)

functions --------------------------------------------------------------—

a helper method to wrap the 'import ROOT' statement to prevent ROOT
from screwing up the display or loading graphics libraries when in batch
mode (which is the default.)

e.g.
>>> ROOT = import_root(batch=True)
>>> f = ROOT.TFile.Open(...)

Definition at line 22 of file RootUtils.py.

def import_root(batch=True):
    """a helper method to wrap the 'import ROOT' statement to prevent ROOT
    from screwing up the display or loading graphics libraries when in batch
    mode (which is the default.)
 
    e.g.
    >>> ROOT = import_root(batch=True)
    >>> f = ROOT.TFile.Open(...)
    """
    import ROOT
    ROOT.gROOT.SetBatch(batch)
    if batch:
        ROOT.PyConfig.IgnoreCommandLineOptions = True
    import cppyy  # noqa: F401
    if os.environ.get('GLIBCXX_USE_CXX11_ABI') == '0':
        cmd = ROOT.gSystem.GetMakeSharedLib()
        if cmd.find('GLIBCXX_USE_CXX11_ABI') < 0:
            cmd = cmd.replace ('$SourceFiles', '$SourceFiles -D_GLIBCXX_USE_CXX11_ABI=0 ')
            ROOT.gSystem.SetMakeSharedLib(cmd)
    return ROOT
 

root_compile()

python.RootUtils.root_compile	(		src = None,
			fname = None,
			batch = True )

a helper method to compile a set of C++ statements (via ``src``) or
a C++ file (via ``fname``) via ACLiC

Definition at line 45 of file RootUtils.py.

def root_compile(src=None, fname=None, batch=True):
    """a helper method to compile a set of C++ statements (via ``src``) or
    a C++ file (via ``fname``) via ACLiC
    """
    if src is not None and fname is not None:
        raise ValueError("'src' xor 'fname' should be not None, *not* both")
 
    if src is None and fname is None:
        raise ValueError("'src' xor 'fname' should be None, *not* both")
 
    # Cling bug workaround: Cling will try to find a definition for the
    # hidden __gmon_start__ by opening all libraries on LD_LIBRARY_PATH.
    # But it will crash if it encounters a separate-debug library.
    # Work around by adding a dummy definition of __gmon_start__.
    # See !31633.
    global _first_compile
    if _first_compile:
        _first_compile = False
        root_compile ('extern "C" { void __gmon_start__(){}; }', None, True)
    return _root_compile (src, fname, batch)
 

Variable Documentation

__all__

list python.RootUtils.__all__

private

Initial value:

=  [
    'import_root',
    'root_compile',
    ]

Definition at line 11 of file RootUtils.py.

__author__

str python.RootUtils.__author__ = "Sebastien Binet"

private

Definition at line 9 of file RootUtils.py.

__doc__

str python.RootUtils.__doc__ = "a few utils to ease the day-to-day work with ROOT"

private

Definition at line 8 of file RootUtils.py.

_first_compile

bool python.RootUtils._first_compile = True

protected

Definition at line 44 of file RootUtils.py.

_tempfiles

list python.RootUtils._tempfiles = []

protected

Definition at line 43 of file RootUtils.py.