python.ConfigurableDb Namespace Reference

Classes
class	_CfgDb
	singleton holding configurable and loadable information ---------------— More...
class	_Singleton
	create configurable DB, and pre-fill it, then clean-up remnants -------— More...

Functions
def	_fillConfDict ()
	helpers ---------------------------------------------------------------— More...
def	loadConfigurableDb ()
def	unloadConfigurableDb ()
	function to UNload all ConfigurableDb informations --------------------— More...
def	getConfigurable (className, requester='', assumeCxxClass=True)

Variables
string	__version__ = '3.0.0'
	data ------------------------------------------------------------------— More...
string	__author__ = 'Sebastien Binet (binet@cern.ch)'
list	__all__
	_transtable = str.maketrans('<>&*,: ().', '__rp__s___')
	CfgDb = _Singleton()
	cfgDb = CfgDb()
def	conf = getConfigurable( 'StoreGateSvc' )

Function Documentation

_fillConfDict()

def python.ConfigurableDb._fillConfDict ( )

private

helpers ---------------------------------------------------------------—

Definition at line 25 of file ConfigurableDb.py.

def _fillConfDict():
   global cfgDb
 
   nFiles = loadConfigurableDb()
   cfgDb.msg.info( "Read module info for %d configurables from %d genConfDb files",
             len(cfgDb), nFiles )
 
   if 0 < len( cfgDb.duplicates() ):
      cfgDb.msg.warning( "Found %d duplicates among the %d genConfDb files :",
                   len(cfgDb.duplicates()), nFiles )
      cfgDb.msg.warning( "--------------------------------------------------" )
      cfgDb.msg.warning( "  -%s: %s - %s",
                   "<component name>", "<module>", "[ <duplicates> ]" )
      cfgDb.msg.warning( "--------------------------------------------------" )
 
      dups = cfgDb.duplicates()
      for cfgName in dups.keys():
         cfgDb.msg.warning( "  -%s: %s - %s",
                      cfgName,
                      cfgDb[cfgName]['module'],
                      str([ d['module'] for d in dups[cfgName]]) )
      del dups
 
   else:
      cfgDb.msg.info( "No duplicates have been found: that's good !" )
 
 

getConfigurable()

def python.ConfigurableDb.getConfigurable	(		className,
			requester = '',
			assumeCxxClass = True
	)

Localize and load a Configurable class based on the (C++) class name.

Definition at line 208 of file ConfigurableDb.py.

def getConfigurable( className, requester = '', assumeCxxClass = True ):
   """Localize and load a Configurable class based on the (C++) class name.
   """
 
   global cfgDb
 
 # fill the configurable dict, first time only
   try:
      global _fillConfDict
      _fillConfDict()
      del _fillConfDict
   except NameError:
      pass
 
   confClass = className
   if assumeCxxClass:
    # assume className is C++: --> translate to python
      confClass = str.translate( confClass, _transtable )
 
 # attempt to retrieve existing information
   confClassInfo = cfgDb.get( confClass )
 
 # get the python module, if info available
   confMod = confClassInfo and confClassInfo.get( 'module' )
   if not confMod:
      cfgDb.msg.warning( "%s: Class %s not in database", requester, className )
      return None
 
 # load the module
   try:
      mod = __import__( confMod, globals(), locals(), confClass, level=0 )
   except ImportError:
      cfgDb.msg.warning( "%s: Module %s not found (needed for configurable %s)",
                   requester, confMod, className )
      return None
 
 # localize class
   try:
      confClass = getattr( mod, confClass )
   except AttributeError:
      cfgDb.msg.warning( "%s: Configurable %s not found in module %s",
                   requester, confClass, confMod )
      return None
 
 # got this far, assume confClass to be valid
   cfgDb.msg.debug( "%s: Found configurable %s in module %s",
              requester, confClass, confMod )
 
   return confClass
 
 

loadConfigurableDb()

def python.ConfigurableDb.loadConfigurableDb

(

)

Load all ConfigurableDb files (modules) holding informations about
Configurables available in the release

Definition at line 136 of file ConfigurableDb.py.

def loadConfigurableDb():
   """Load all ConfigurableDb files (modules) holding informations about
   Configurables available in the release
   """
 
   import os
   from os.path import join as path_join
 
   global cfgDb
 
   cfgDb.msg.debug( "loading confDb files..." )
   nFiles = 0
   pathlist = os.getenv("LD_LIBRARY_PATH", "").split(os.pathsep)
   for path in pathlist:
      if not os.path.isdir(path):
         continue
      cfgDb.msg.verbose( "walking in [%s]..." % path )
      confDbFiles = [f for f in [path_join(path, f) for f in os.listdir(path)
                                 if f.endswith('.confdb')]
                     if os.path.isfile(f)]
 
      # check if we use "*_merged.confdb"
      mergedConfDbFiles = [f for f in confDbFiles
                           if f.endswith('_merged.confdb')]
      if mergedConfDbFiles:
         # use only the merged ones
         confDbFiles = mergedConfDbFiles
 
      for confDb in confDbFiles:
         cfgDb.msg.debug( "\t-loading [%s]...", confDb )
         try:
            cfgDb._loadModule( confDb )
         except Exception as err:
            import traceback
            traceback.print_exc()
            cfgDb.msg.warning( "Could not load file [%s] !", confDb )
            cfgDb.msg.warning( "Reason: %s", err )
         nFiles += 1
   cfgDb.msg.debug( "loading confDb files... [DONE]" )
   nPkgs = len( set([k['package'] for k in cfgDb.values()]) )
   cfgDb.msg.debug( "loaded %i confDb packages", nPkgs )
   return nFiles
 
 

unloadConfigurableDb()

def python.ConfigurableDb.unloadConfigurableDb

(

)

function to UNload all ConfigurableDb informations --------------------—

UNload all ConfigurableDb files (modules) holding informations about
Configurables available in the release:
 - remove imported modules from sys.modules
 - clear the configurable Db

Definition at line 181 of file ConfigurableDb.py.

def unloadConfigurableDb():
   """UNload all ConfigurableDb files (modules) holding informations about
   Configurables available in the release:
    - remove imported modules from sys.modules
    - clear the configurable Db
   """
 
   global cfgDb
 
   confModules = set( [ cfgDb.get(k).get('module')  for k in cfgDb ] +
                       [ cfgDb.get(k).get('package') for k in cfgDb ] )
   cfgDb.clear()
   import sys
   for m in sys.modules.keys():
      if m in confModules or \
         m.count("_merged_confDb") > 0 or \
         m.count(".GaudiHandles" ) > 0 or \
         m.count("ConfigurableDb") > 0 or \
         m.count("AthenaPython")   > 0:
 
         if hasattr(sys.modules[m], '__dict__'):
            for i in sys.modules[m].__dict__.keys():
               del sys.modules[m].__dict__[i]
         del sys.modules[m]
   del confModules
 
 

Variable Documentation

__all__

list python.ConfigurableDb.__all__

private

Initial value:

=  [ 'CfgDb', 'cfgDb',
            'loadConfigurableDb', 'unloadConfigurableDb',
            'getConfigurable' ]

Definition at line 18 of file ConfigurableDb.py.

__author__

string python.ConfigurableDb.__author__ = 'Sebastien Binet (binet@cern.ch)'

private

Definition at line 16 of file ConfigurableDb.py.

__version__

string python.ConfigurableDb.__version__ = '3.0.0'

private

data ------------------------------------------------------------------—

Definition at line 15 of file ConfigurableDb.py.

_transtable

python.ConfigurableDb._transtable = str.maketrans('<>&*,: ().', '__rp__s___')

private

Definition at line 22 of file ConfigurableDb.py.

CfgDb

python.ConfigurableDb.CfgDb = _Singleton()

Definition at line 268 of file ConfigurableDb.py.

cfgDb

python.ConfigurableDb.cfgDb = CfgDb()

Definition at line 269 of file ConfigurableDb.py.

conf

def python.ConfigurableDb.conf = getConfigurable( 'StoreGateSvc' )

Definition at line 282 of file ConfigurableDb.py.