Classes
class	Configurable

class	ConfigurableAlgorithm

class	ConfigurableAlgTool

class	ConfigurableAuditor

class	ConfigurableGeneric

class	ConfigurableService

class	ConfigurableUser

class	CreateSequencesVisitor

class	DummyDescriptor
	classes for generic Gaudi component =========== More...

class	Error

class	PropertyReference
	Allow references to options as in old style. More...

class	SuperAlgorithm

Functions
def	expandvars (data)

def	isApplicable (self)
	if isinstance(v,Configurable) and not v.isPublic(): rep += v.__str__( indent + 1 ) + os.linesep elif isinstance(v,GaudiHandleArray): for vi in v: if isinstance(vi,Configurable) and not vi.isPublic(): rep += vi.__str__( indent + 1 ) + os.linesep More...

def	appendPostConfigAction (function)

def	removePostConfigAction (function)

def	applyConfigurableUsers ()

def	applyConfigurableUsers_old ()

def	getNeededConfigurables ()

def	purge ()

def	makeSequences (expression)

Variables
list	__all__
	data ------------------------------------------------------------------— More...

	log = logging.getLogger( 'Configurable' )

list	postConfigActions = []

bool	_appliedConfigurableUsers_ = False

Function Documentation

def GaudiKernel.Configurable.appendPostConfigAction ( function )

Add a new callable ('function') to the list of post-configuration actions.
If the callable is already in the list, it is moved to the end of the list.
The list is directly accessible as 'GaudiKernel.Configurable.postConfigActions'.

Definition at line 1376 of file Configurable.py.

 def appendPostConfigAction(function):
     """
     Add a new callable ('function') to the list of post-configuration actions.
     If the callable is already in the list, it is moved to the end of the list.
     The list is directly accessible as 'GaudiKernel.Configurable.postConfigActions'.
     """
     try:
         postConfigActions.remove(function)
     except:
         pass
     postConfigActions.append(function)

def GaudiKernel.Configurable.applyConfigurableUsers ( )

Call the apply method of all the ConfigurableUser instances respecting the
dependencies. First the C.U.s that are not used by anybody, then the used
ones, when they are not used anymore.

Definition at line 1395 of file Configurable.py.

 def applyConfigurableUsers():
     """
     Call the apply method of all the ConfigurableUser instances respecting the
     dependencies. First the C.U.s that are not used by anybody, then the used
     ones, when they are not used anymore.
     """
     # Avoid double calls
     global _appliedConfigurableUsers_, postConfigActions
     if _appliedConfigurableUsers_:
         return
     _appliedConfigurableUsers_ = True
 
     def applicableConfUsers():
         '''
         Generator returning all the configurables that can be applied in the
         order in which they can be applied.
         '''
         # This is tricky...
         # We keep on looking for the first configurable that can be applied.
         # When we cannot find any, 'next()' raises a StopIteration that is
         # propagated outside of the infinite loop and the function, then handled
         # correctly from outside (it is the exception that is raised when you
         # exit from a generator).
         # Checking every time the full list is inefficient, but it is the
         # easiest way to fix bug #103803.
         # <https://savannah.cern.ch/bugs/?103803>
         while True:
             yield (c for c in Configurable.allConfigurables.values()
                    if c.isApplicable()).next()
 
     debugApplyOrder = 'GAUDI_DUBUG_CONF_USER' in os.environ
     for c in applicableConfUsers():
         if c._enabled:
             log.info("applying configuration of %s", c.name())
             if debugApplyOrder:
                 sys.stderr.write('applying %r' % c)
             c.__apply_configuration__()
             log.info(c)
         else:
             log.info("skipping configuration of %s", c.name())
         c._applied = True # flag the instance as already applied
         if hasattr(c, "__detach_used__"):
             # tells the used configurables that they are not needed anymore
             c.__detach_used__()
 
     # check for dependency loops
     leftConfUsers = [c for c in Configurable.allConfigurables.values()
                      if hasattr(c, '__apply_configuration__') and
                         c._enabled and not c._applied]
     # if an enabled configurable has not been applied, there must be a dependency loop
     if leftConfUsers:
         raise Error("Detected loop in the ConfigurableUser"
                     " dependencies: %r" % [ c.name()
                                             for c in leftConfUsers ])
     # ensure that all the Handles have been triggered
     known = set()
     unknown = set(Configurable.allConfigurables)
     while unknown:
         for k in unknown:
             if not known: # do not print during the first iteration
                 log.debug('new configurable created automatically: %s', k)
             # this trigger the instantiation from handles
             Configurable.allConfigurables[k].properties()
             known.add(k)
         unknown -= known
     # Call post-config actions
     for action in postConfigActions:
         action()
 

def GaudiKernel.Configurable.applyConfigurableUsers_old ( )

Obsolete (buggy) implementation of applyConfigurableUsers(), kept to provide
backward compatibility for configurations that where relying (implicitly) on
bug #103803, or on a specific (non guaranteed) order of execution.

@see applyConfigurableUsers()

Definition at line 1464 of file Configurable.py.

 def applyConfigurableUsers_old():
     """
     Obsolete (buggy) implementation of applyConfigurableUsers(), kept to provide
     backward compatibility for configurations that where relying (implicitly) on
     bug #103803, or on a specific (non guaranteed) order of execution.
 
     @see applyConfigurableUsers()
     """
     # Avoid double calls
     global _appliedConfigurableUsers_, postConfigActions
     if _appliedConfigurableUsers_:
         return
     _appliedConfigurableUsers_ = True
 
     debugApplyOrder = 'GAUDI_DUBUG_CONF_USER' in os.environ
     confUsers = [ c
                   for c in Configurable.allConfigurables.values()
                   if hasattr(c,"__apply_configuration__") ]
     applied = True # needed to detect dependency loops
     while applied and confUsers:
         newConfUsers = [] # list of conf users that cannot be applied yet
         applied = False
         for c in confUsers:
             if hasattr(c,"__users__") and c.__users__:
                 newConfUsers.append(c) # cannot use this one yet
             else: # it does not have users or the list is empty
                 applied = True
                 # the ConfigurableUser is enabled if it doesn't have an _enabled
                 # property or its value is True
                 enabled = (not hasattr(c, "_enabled")) or c._enabled
                 if enabled:
                     log.info("applying configuration of %s", c.name())
                     if debugApplyOrder:
                         sys.stderr.write('applying %r' % c)
                     c.__apply_configuration__()
                     log.info(c)
                 else:
                     log.info("skipping configuration of %s", c.name())
                 if hasattr(c, "__detach_used__"):
                     # tells the used configurables that they are not needed anymore
                     c.__detach_used__()
         confUsers = newConfUsers # list of C.U.s still to go
     if confUsers:
         # this means that some C.U.s could not be applied because of a dependency loop
         raise Error("Detected loop in the ConfigurableUser "
                     " dependencies: %r" % [ c.name()
                                             for c in confUsers ])
     # ensure that all the Handles have been triggered
     known = set()
     unknown = set(Configurable.allConfigurables)
     while unknown:
         for k in unknown:
             if not known: # do not print during the first iteration
                 log.debug('new configurable created automatically: %s', k)
             # this trigger the instantiation from handles
             Configurable.allConfigurables[k].properties()
             known.add(k)
         unknown -= known
     # Call post-config actions
     for action in postConfigActions:
         action()
 

def GaudiKernel.Configurable.expandvars ( data )

Expand environment variables "data".
Data can be string, list, tuple and dictionary. For collection, all the
contained strings will be manipulated (recursively).

Definition at line 34 of file Configurable.py.

 def expandvars(data):
     """
     Expand environment variables "data".
     Data can be string, list, tuple and dictionary. For collection, all the
     contained strings will be manipulated (recursively).
     """
     import os.path
     typ = type(data)
     if typ is str:
         return os.path.expandvars(data)
     elif typ in [list, tuple]:
         collect = []
         for i in data:
             collect.append(expandvars(i))
         return typ(collect)
     elif typ is dict:
         collect = {}
         for k in data:
             collect[expandvars(k)] = expandvars(data[k])
         return collect
     return data
 

def GaudiKernel.Configurable.getNeededConfigurables ( )

Function to select all and only the configurables that have to be used in
GaudiPython.AppMgr constructor.
This is needed because in Athena the implementation have to be different (the
configuration is used in a different moment).

Definition at line 1526 of file Configurable.py.

 def getNeededConfigurables():
     """
     Function to select all and only the configurables that have to be used in
     GaudiPython.AppMgr constructor.
     This is needed because in Athena the implementation have to be different (the
     configuration is used in a different moment).
     """
     return [ k
              for k, v in Configurable.allConfigurables.items()
              if v.getGaudiType() != "User" ] # Exclude ConfigurableUser instances
 

def GaudiKernel.Configurable.isApplicable ( self )

if isinstance(v,Configurable) and not v.isPublic(): rep += v.__str__( indent + 1 ) + os.linesep elif isinstance(v,GaudiHandleArray): for vi in v: if isinstance(vi,Configurable) and not vi.isPublic(): rep += vi.__str__( indent + 1 ) + os.linesep

for cfg in self.__children:

Return True is the instance can be "applied".
Always False for plain Configurable instances
(i.e. not ConfigurableUser).

Definition at line 930 of file Configurable.py.

     def isApplicable(self):
         '''
         Return True is the instance can be "applied".
         Always False for plain Configurable instances
         (i.e. not ConfigurableUser).
         '''
         return False
 

def GaudiKernel.Configurable.makeSequences ( expression )

Convert a control flow expression to nested GaudiSequencers.

Definition at line 1609 of file Configurable.py.

 def makeSequences(expression):
     '''
     Convert a control flow expression to nested GaudiSequencers.
     '''
     if not isinstance(expression, ControlFlowNode):
         raise ValueError('ControlFlowNode instance expected, got %s' %
                          type(expression).__name__)
     visitor = CreateSequencesVisitor()
     expression.visitNode(visitor)
     return visitor.sequence
 
 

def GaudiKernel.Configurable.purge ( )

Clean up all configurations and configurables.

Definition at line 1537 of file Configurable.py.

 def purge():
     """
     Clean up all configurations and configurables.
     """
     for c in Configurable.allConfigurables.values():
         c.__class__.configurables.clear()
     Configurable.allConfigurables.clear()
     # FIXME: (MCl) this is needed because instances of ConfigurableGeneric are not
     #        migrated to the correct class when this is known.
     ConfigurableGeneric.configurables.clear()
     from ProcessJobOptions import _included_files
     import os.path, sys
     for file in _included_files:
         dirname, basname = os.path.split(file)
         basname, ext = os.path.splitext(basname)
         if basname in sys.modules:
             del sys.modules[basname]
     _included_files.clear()
 
 

def GaudiKernel.Configurable.removePostConfigAction ( function )

Remove a callable from the list of post-config actions.
The list is directly accessible as 'GaudiKernel.Configurable.postConfigActions'.

Definition at line 1387 of file Configurable.py.

 def removePostConfigAction(function):
     """
     Remove a callable from the list of post-config actions.
     The list is directly accessible as 'GaudiKernel.Configurable.postConfigActions'.
     """
     postConfigActions.remove(function)
 

Variable Documentation

list GaudiKernel.Configurable.__all__

private

Initial value:

 = [ 'Configurable',
             'ConfigurableAlgorithm',
             'ConfigurableAlgTool',
             'ConfigurableAuditor',
             'ConfigurableService',
             'ConfigurableUser',
             'VERBOSE','DEBUG','INFO', 'WARNING', 'ERROR', 'FATAL',
             'appendPostConfigAction', 'removePostConfigAction' ]

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

Definition at line 21 of file Configurable.py.

bool GaudiKernel.Configurable._appliedConfigurableUsers_ = False

private

Definition at line 1394 of file Configurable.py.

GaudiKernel.Configurable.log = logging.getLogger( 'Configurable' )

Definition at line 32 of file Configurable.py.

list GaudiKernel.Configurable.postConfigActions = []

Definition at line 1375 of file Configurable.py.

Classes

Functions

Variables

Function Documentation

Variable Documentation