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
	_fillConfDict ()
	helpers ---------------------------------------------------------------—
	loadConfigurableDb ()
	unloadConfigurableDb ()
	function to UNload all ConfigurableDb informations --------------------—
	getConfigurable (className, requester='', assumeCxxClass=True)

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

Detailed Description

Provides cfgDb, a Singleton that holds the information on the whereabouts
of all the accessible, automatically generated, Configurables.
This repository of (informations on) Configurables is used by the PropertyProxy
class to locate Configurables and feed the JobOptionsSvc. It could also be used
to feed the AthenaEmacs module...

Function Documentation

_fillConfDict()

_fillConfDict ( )

protected

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

Definition at line 25 of file ConfigurableDb.py.

def _fillConfDict():
   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()

getConfigurable	(		className,
			requester = '',
			assumeCxxClass = True )

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

Definition at line 202 of file ConfigurableDb.py.

def getConfigurable( className, requester = '', assumeCxxClass = True ):
   """Localize and load a Configurable class based on the (C++) class name.
   """
 
 # 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()

loadConfigurableDb

(

)

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

Definition at line 134 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
   import GaudiPluginService.cpluginsvc
 
   cfgDb.msg.debug( "loading confDb files..." )
   nFiles = 0
   for path in GaudiPluginService.cpluginsvc.GAUDI_DEFAULT_PLUGIN_PATH:
      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()

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 177 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
   """
 
   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__

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

private

Definition at line 16 of file ConfigurableDb.py.

__version__

str python.ConfigurableDb.__version__ = '3.0.0'

private

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

Definition at line 15 of file ConfigurableDb.py.

_transtable

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

protected

Definition at line 22 of file ConfigurableDb.py.

CfgDb

python.ConfigurableDb.CfgDb = _Singleton()

Definition at line 260 of file ConfigurableDb.py.

cfgDb

python.ConfigurableDb.cfgDb = CfgDb()

Definition at line 261 of file ConfigurableDb.py.

conf

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

Definition at line 274 of file ConfigurableDb.py.