Pythonizations.py

Go to the documentation of this file.

 
""" This Pythonizations module provides a number of useful pythonizations
    of adaptation of some classes.
"""
from __future__ import print_function
 
import six
 
__all__ = []
 
try:
    from cppyy import gbl
except ImportError:
    # FIXME: backward compatibility
    print("# WARNING: using PyCintex as cppyy implementation")
    from PyCintex import gbl
 
if not hasattr(gbl, "ostream"):
    gbl.gROOT.ProcessLine("#include <ostream>")
if not hasattr(gbl, "stringstream"):
    gbl.gROOT.ProcessLine("#include <sstream>")
 
# --- Adding extra functionality to C++ raw classes------------------------------------
 
 
def _printHisto1D(h):
    x = h.axis()
    return 'Histogram 1D "%s" %d bins [%f,%f]' % (
        h.title(),
        x.bins(),
        x.lowerEdge(),
        x.upperEdge(),
    )
 
 
def _contentsHisto1D(h):
    x = h.axis()
    return map(h.binEntries, range(x.bins()))
 
 
def _printHisto2D(h):
    x, y = h.xAxis(), h.yAxis()
    return 'Histogram 2D "%s" %d xbins [%f,%f], %d ybins [%f,%f]' % (
        h.title(),
        x.bins(),
        x.lowerEdge(),
        x.upperEdge(),
        y.bins(),
        y.lowerEdge(),
        y.upperEdge(),
    )
 
 
def _printStatusCode(s):
    if s.isSuccess():
        return "SUCCESS"
    else:
        return "FAILURE"
 
 
def _printBitReference(b):
    return str(1 == b.bool())
 
 
def _printFillStream(o):
    if o:
        s = gbl.stringstream()
        o.fillStream(s)
        out = str(s.str())
        if out == "":
            out = o.__class__.__name__ + " object"
            if hasattr(o, "hasKey") and o.hasKey():
                out += " key = " + str(o.key())
    else:
        out = o.__class__.__name__ + " NULL object"
    return out
 
 
def _container__getitem__(self, k):
    return self.containedObject(k)
 
 
def _container__len__(self):
    return self.numberOfObjects()
 
 
def _container__iter__(self):
    if hasattr(self, "containedObjects"):
        sequential = self.containedObjects()
    else:
        sequential = self
    count = 0
    limit = self.__len__()
    while count < limit:
        yield sequential.__getitem__(count)
        count += 1
 
 
def _draw_aida_(self, *args):
    """
    Draw AIDA histogram (through access to internal ROOT histogram
 
    >>> aida = ...    # get the historgam
    >>> aida.Draw()
 
    """
    _fun = gbl.Gaudi.Utils.Aida2ROOT.aida2root
    _root = _fun(self)
    return _root.Draw(*args)
 
 
gbl.AIDA.IHistogram1D.__str__ = _printHisto1D
gbl.AIDA.IHistogram1D.contents = _contentsHisto1D
gbl.AIDA.IHistogram2D.__str__ = _printHisto2D
for h in (
    gbl.AIDA.IHistogram,
    gbl.AIDA.IHistogram1D,
    gbl.AIDA.IHistogram2D,
    gbl.AIDA.IHistogram3D,
    gbl.AIDA.IProfile1D,
    gbl.AIDA.IProfile2D,
):
    h.Draw = _draw_aida_
    h.plot = _draw_aida_
 
gbl.StatusCode.__repr__ = _printStatusCode
try:
    gbl._Bit_reference.__repr__ = _printBitReference
except Exception:
    pass
gbl.ContainedObject.__repr__ = _printFillStream
gbl.DataObject.__repr__ = _printFillStream
gbl.ObjectContainerBase.__getitem__ = _container__getitem__
gbl.ObjectContainerBase.__len__ = _container__len__
gbl.ObjectContainerBase.__iter__ = _container__iter__
 
gbl.IUpdateManagerSvc.update = (
    lambda self, obj: gbl.IUpdateManagerSvc.PythonHelper.update(self, obj)
)
gbl.IUpdateManagerSvc.invalidate = (
    lambda self, obj: gbl.IUpdateManagerSvc.PythonHelper.invalidate(self, obj)
)
 
# ---Globals--------------------------------------------------------------------
if not hasattr(gbl.StatusCode, "SUCCESS"):
    # emulate enums
    gbl.StatusCode.SUCCESS = 1
    gbl.StatusCode.FAILURE = 0
 
# - string key, equality
if hasattr(gbl.Gaudi.StringKey, "__cpp_eq__"):
    _eq = gbl.Gaudi.StringKey.__cpp_eq__
    setattr(gbl.Gaudi.StringKey, "__eq__", _eq)
 
# - string key, non-equality
if hasattr(gbl.Gaudi.StringKey, "__cpp_ne__"):
    _ne = gbl.Gaudi.StringKey.__cpp_ne__
    setattr(gbl.Gaudi.StringKey, "__ne__", _ne)
 
# ---Enabling Pickle support----------------------------------------------------
if gbl.gROOT.GetVersionInt() <= 51800:
    import libPyROOT
 
    gbl.GaudiPython.PyROOTPickle.Initialize(libPyROOT, libPyROOT.ObjectProxy)
 
# =============================================================================
# decorate some map-like objects
# =============================================================================
# The iterator for MapBase class
#
#  @code
#
#    >>> m = ...  ## the map
#    >>> for key in m : print(key , m[key])
#
#  @endcode
#  @see Gaudi::Utils::MapBase
#  @see GaudiUtils::Map
#  @see GaudiUtils::HashMap
#  @see GaudiUtils::VectorMap
#  @see GaudiUtils::Map::key_at
#  @see GaudiUtils::HashMap::key_at
#  @see GaudiUtils::VectorMap::key_at
#  @author Vanya BELYAEV Ivan.Belyaev@itep.ru
#  @date 2010-02-20
 
 
def __mapbase_iter__(self):
    """
    The iterator for MapBase-based containers
 
    >>> m = ...  ## the map
    >>> for key in m : print(key , m[key])
 
    """
    _size = len(self)
    _index = 0
    while _index < _size:
        yield self.key_at(_index)
        _index += 1
 
 
# =============================================================================
# The iterator for MapBase class
#
#  @code
#
#    >>> m = ...  ## the map
#    >>> for key,value in m.iteritems() : print(key , value)
#
#  @endcode
#  @see Gaudi::Utils::MapBase
#  @see GaudiUtils::Map
#  @see GaudiUtils::HashMap
#  @see GaudiUtils::VectorMap
#  @see GaudiUtils::Map::key_at
#  @see GaudiUtils::HashMap::key_at
#  @see GaudiUtils::VectorMap::key_at
#  @see GaudiUtils::Map::value_at
#  @see GaudiUtils::HashMap::value_at
#  @see GaudiUtils::VectorMap::value_at
#  @author Vanya BELYAEV Ivan.Belyaev@itep.ru
#  @date 2010-02-20
 
 
def __mapbase_iteritems__(self):
    """
    The iterator for MapBase-based containers
 
    >>> m = ...  ## the map
    >>> for key,value in m.iteritems() : print(key, value)
 
    """
    _size = len(self)
    _index = 0
    while _index < _size:
        _key = self.key_at(_index)
        yield (_key, self.at(_key))
        _index += 1
 
 
# ============================================
# Get the list of keys for the map
#
#  @code
#
#    >>> m    = ...        ## the map
#    >>> keys = m.keys()   ## get the list of keys
#
#  @endcode
#  @see Gaudi::Utils::MapBase
#  @see GaudiUtils::Map
#  @see GaudiUtils::HashMap
#  @see GaudiUtils::VectorMap
#  @see GaudiUtils::Map::key_at
#  @see GaudiUtils::HashMap::key_at
#  @ see GaudiUtils::VectorMap::key_at
#  @author Vanya BELYAEV Ivan.BElyaev@itep.ru
#  @date 2010-02-20
 
 
def __mapbase_keys__(self):
    """
    Get the list of keys
 
    >>> m = ...           ## the map
    >>> keys = m.keys()   ## get the list of keys
 
    """
    _size = len(self)
    _keys = []
    for i in range(0, _size):
        _keys.append(self.key_at(i))
    return _keys
 
 
# ============================================
# Get the list of items for the map
#
#  @code
#
#    >>> m     = ...        ## the map
#    >>> items = m.items()   ## get the list of items
#
#  @endcode
#  @see Gaudi::Utils::MapBase
#  @see GaudiUtils::Map
#  @see GaudiUtils::HashMap
#  @see GaudiUtils::VectorMap
#  @see GaudiUtils::Map::key_at
#  @see GaudiUtils::HashMap::key_at
#  @ see GaudiUtils::VectorMap::key_at
#  @author Vanya BELYAEV Ivan.BElyaev@itep.ru
#  @date 2010-02-20
 
 
def __mapbase_items__(self):
    """
    Get the list of items
 
    >>> m     = ...        ## the map
    >>> items = m.keys()   ## get the list of items
 
    """
    _size = len(self)
    _items = []
    for i in range(0, _size):
        _key = self.key_at(i)
        _value = self.at(_key)
        _items.append((_key, _value))
    return _items
 
 
# ============================================
# Get the list of values for the map
#
#  @code
#
#    >>> m      = ...           ## the map
#    >>> values = m.values ()   ## get the list of values
#
#  @endcode
#  @see Gaudi::Utils::MapBase
#  @see GaudiUtils::Map
#  @see GaudiUtils::HashMap
#  @see GaudiUtils::VectorMap
#  @see GaudiUtils::Map::value_at
#  @see GaudiUtils::HashMap::value_at
#  @ see GaudiUtils::VectorMap::value_at
#  @author Vanya BELYAEV Ivan.Belyaev@itep.ru
#  @date 2010-02-20
 
 
def __mapbase_values__(self):
    """
    Get the list of values
 
    >>> m      = ...          ## the map
    >>> values = m.values()   ## get the list of values
 
    """
    _size = len(self)
    _values = []
    for i in range(0, _size):
        _value = self.value_at(i)
        _values.append(_value)
    return _values
 
 
# ============================================
# Check if the certain key is in the map
#
#  @code
#
#    >>> m      = ...        ## the map
#    >>> if 'a' in m : print('key is in the map!')
#
#  @endcode
#  @see Gaudi::Utils::MapBase
#  @see GaudiUtils::Map
#  @see GaudiUtils::HashMap
#  @see GaudiUtils::VectorMap
#  @see GaudiUtils::Map::count
#  @see GaudiUtils::HashMap::count
#  @ see GaudiUtils::VectorMap::count
#  @author Vanya BELYAEV Ivan.BElyaev@itep.ru
#  @date 2010-02-20
 
 
def __mapbase_contains__(self, key):
    """
    Check if the certainkey is in the map
 
    >>> m     = ...        ## the map
    >>> if 'a' in m : ...  ##  chekc the presence of the key in the map
 
    """
    _num = self.count(key)
    return False if 0 == _num else True
 
 
# ============================================
# Get the value for certain key,
#   return predefined value otherwise
#
#  @code
#
#    >>> m      = ...          ## the map
#    >>> v = m.get( key , 15 ) ## return the value[key] for existing key, else 15
#
#  @endcode
#  @see Gaudi::Utils::MapBase
#  @see GaudiUtils::Map
#  @see GaudiUtils::HashMap
#  @see GaudiUtils::VectorMap
#  @see GaudiUtils::Map::count
#  @see GaudiUtils::HashMap::count
#  @ see GaudiUtils::VectorMap::count
#  @author Vanya BELYAEV Ivan.BElyaev@itep.ru
#  @date 2010-02-20
 
 
def __mapbase_get__(self, key, value=None):
    """
    Get the value for the certain key, or 'value' otherwise
 
    >>> m     = ...        ## the map
    >>> v = m.get ( key , 15 )
 
    """
    if key in self:
        return self.at(key)
    return value
 
 
# ============================================
# Representation of MapBase-based maps
#
#  @code
#
#    >>> m      = ...        ## the map
#    >>> print(m)
#
#  @endcode
#  @see Gaudi::Utils::MapBase
#  @see GaudiUtils::Map
#  @see GaudiUtils::HashMap
#  @see GaudiUtils::VectorMap
#  @author Vanya BELYAEV Ivan.BElyaev@itep.ru
#  @date 2010-02-20
 
 
def __mapbase_str__(self):
    """
    Representation of MapBase-based maps:
 
    >>> m     = ...        ## the map
    >>> print(map)
 
    """
    _result = " { "
    _size = len(self)
    for i in range(0, _size):
        _key = self.key_at(i)
        _val = self.at(_key)
        if 0 != i:
            _result += " , "
        _result += " %s : %s " % (str(_key), str(_val))
    _result += " } "
    return _result
 
 
# ============================================
# "Setitem" for MapBase-based maps:
#
#  @code
#
#    >>> m        = ...        ## the map
#    >>> m [ key] = value    ## set the item
#
#  @endcode
#  @see Gaudi::Utils::MapBase
#  @see GaudiUtils::Map
#  @see GaudiUtils::HashMap
#  @see GaudiUtils::VectorMap
#  @see GaudiUtils::Map::update
#  @see GaudiUtils::HashMap::update
#  @see GaudiUtils::VectorMap::update
#  @author Vanya BELYAEV Ivan.BElyaev@itep.ru
#  @date 2010-02-20
 
 
def __mapbase_setitem__(self, key, value):
    """
    'Set-item' for MapBase-based maps:
 
    >>> m      = ...        ## the map
    >>> m[key] = value     ## set the item
 
    """
    _replaced = True if key in self else False
    self.update(key, value)
    return _replaced
 
 
# ============================================
# "Del-item" for MapBase-based maps:
#
#  @code
#
#    >>> m        = ...   ## the map
#    >>> del m [ key]     ## del th eitem
#
#  @endcode
#
#  @see Gaudi::Utils::MapBase
#  @see GaudiUtils::Map
#  @see GaudiUtils::HashMap
#  @see GaudiUtils::VectorMap
#  @see GaudiUtils::Map::erase
#  @see GaudiUtils::HashMap::erase
#  @see GaudiUtils::VectorMap::erase
#  @author Vanya BELYAEV Ivan.BElyaev@itep.ru
#  @date 2010-02-20
 
 
def __mapbase_delitem__(self, key):
    """
    'Del-item' for MapBase-based maps:
 
    >>> m      = ...        ## the map
    >>> del m[key]
 
    """
    _erased = True if key in self else False
    self.erase(key)
    return _erased
 
 
gbl.Gaudi.Utils.MapBase.__len__ = lambda s: s.size()
gbl.Gaudi.Utils.MapBase.__iter__ = __mapbase_iter__
gbl.Gaudi.Utils.MapBase.keys = __mapbase_keys__
gbl.Gaudi.Utils.MapBase.__iteritems__ = __mapbase_iteritems__
gbl.Gaudi.Utils.MapBase.values = __mapbase_values__
gbl.Gaudi.Utils.MapBase.__contains__ = __mapbase_contains__
gbl.Gaudi.Utils.MapBase.get = __mapbase_get__
gbl.Gaudi.Utils.MapBase.__str__ = __mapbase_str__
gbl.Gaudi.Utils.MapBase.__repr__ = __mapbase_str__
gbl.Gaudi.Utils.MapBase.__setitem__ = __mapbase_setitem__
gbl.Gaudi.Utils.MapBase.__delitem__ = __mapbase_delitem__
gbl.Gaudi.Utils.MapBase.__getitem__ = lambda s, key: s.at(key)
if six.PY2:
    # Behaviour is like Python 2 dict
    gbl.Gaudi.Utils.MapBase.iteritems = __mapbase_iteritems__
    gbl.Gaudi.Utils.MapBase.items = __mapbase_items__
    gbl.Gaudi.Utils.MapBase.has_key = __mapbase_contains__
else:
    # Behaviour is like Python 3+ dict
    gbl.Gaudi.Utils.MapBase.items = __mapbase_iteritems__
 
 
gbl.gInterpreter.Declare(
    """
#ifndef REENTINTERFACES_PYTHON_HELPERS
#define REENTINTERFACES_PYTHON_HELPERS
#include <GaudiKernel/IAlgorithm.h>
#include <GaudiKernel/IEventProcessor.h>
#include <GaudiKernel/ThreadLocalContext.h>
 
namespace GaudiPython::Helpers {
  StatusCode executeEvent( IEventProcessor* self ) {
    return self->executeEvent( self->createEventContext() );
  }
  bool isExecuted( IAlgorithm* self ) {
    return self->execState( Gaudi::Hive::currentContext() ).state() == AlgExecState::State::Done;
  }
  bool filterPassed( IAlgorithm* self ) {
    return self->execState( Gaudi::Hive::currentContext() ).filterPassed();
  }
  StatusCode ialg_execute( IAlgorithm* self ) {
    return self->execute( Gaudi::Hive::currentContext() );
  }
}
 
#endif
"""
)
gbl.IEventProcessor.executeEvent = gbl.GaudiPython.Helpers.executeEvent
gbl.IAlgorithm.isExecuted = gbl.GaudiPython.Helpers.isExecuted
gbl.IAlgorithm.filterPassed = gbl.GaudiPython.Helpers.filterPassed
gbl.IAlgorithm._execute_orig = gbl.IAlgorithm.execute
gbl.IAlgorithm.execute = lambda self, ctx=None: (
    gbl.GaudiPython.Helpers.ialg_execute(self)
    if ctx is None
    else self._execute_orig(ctx)
)