Pythonizations.py

Go to the documentation of this file.

# File: GaudiPython/Pythonizations.py
# Author: Pere Mato (pere.mato@cern.ch)
""" 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.__repr__ = _printHisto1D
gbl.AIDA.IHistogram1D.contents = _contentsHisto1D
gbl.AIDA.IHistogram2D.__repr__ = _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:
    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))