GaudiKernel.Configurable Namespace Reference

Classes
class	Configurable
class	ConfigurableAlgorithm
class	ConfigurableAlgTool
class	ConfigurableAuditor
class	ConfigurableGeneric
class	ConfigurableService
class	ConfigurableUser
class	CreateSequencesVisitor
class	DummyDescriptor
class	Error
class	PropertyReference
class	SuperAlgorithm

Functions
def	expandvars (data)
def	appendPostConfigAction (function)
def	removePostConfigAction (function)
def	applyConfigurableUsers ()
def	applyConfigurableUsers_old ()
def	getNeededConfigurables ()
def	purge ()
def	makeSequences (expression)

Variables
	__all__
	log
	postConfigActions
	_appliedConfigurableUsers_

Function Documentation

appendPostConfigAction()

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 1581 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 Exception:
        pass
    postConfigActions.append(function)
 
 

applyConfigurableUsers()

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 1605 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:
            try:
                yield next(
                    c
                    for c in Configurable.allConfigurables.values()
                    if c.isApplicable()
                )
            except StopIteration:
                break
 
    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()
 
 

applyConfigurableUsers_old()

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 1684 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()
 
 

expandvars()

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 77 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
 
 

getNeededConfigurables()

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 1750 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 sorted(
        k
        for k, v in Configurable.allConfigurables.items()
        if v.getGaudiType() != "User"
    )  # Exclude ConfigurableUser instances
 
 

makeSequences()

def GaudiKernel.Configurable.makeSequences

(

expression

)

Convert a control flow expression to nested GaudiSequencers.

Definition at line 1842 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
 
 

purge()

def GaudiKernel.Configurable.purge

(

)

Clean up all configurations and configurables.

Definition at line 1764 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()
    import os.path
    import sys
 
    from .ProcessJobOptions import _included_files
 
    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()
 
 

removePostConfigAction()

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 1594 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

__all__

GaudiKernel.Configurable.__all__

private

Definition at line 54 of file Configurable.py.

_appliedConfigurableUsers_

GaudiKernel.Configurable._appliedConfigurableUsers_

private

Definition at line 1602 of file Configurable.py.

log

GaudiKernel.Configurable.log

Definition at line 74 of file Configurable.py.

postConfigActions

GaudiKernel.Configurable.postConfigActions

Definition at line 1578 of file Configurable.py.