GaudiKernel.Configurable.ConfigurableUser Class Reference

Inheritance diagram for GaudiKernel.Configurable.ConfigurableUser:

Collaboration diagram for GaudiKernel.Configurable.ConfigurableUser:

Public Member Functions
def	__init__ (self, name=Configurable.DefaultName, _enabled=True, **kwargs)
def	getGaudiType (cls)
def	getDlls (self)
def	getHandle (self)
def	__detach_used__ (self)
def	propagateProperty (self, name, others=None, force=True)
def	propagateProperties (self, names=None, others=None, force=True)
def	__apply_configuration__ (self)
def	applyConf (self)
def	getUsedInstance (self, name)
def	isApplicable (self)
Public Member Functions inherited from GaudiKernel.Configurable.Configurable
def	__new__ (cls, *args, **kwargs)
def	__init__ (self, name=DefaultName)
def	__getstate__ (self)
def	__getnewargs__ (self)
def	__setstate__ (self, dict)
def	__len__ (self)
def	__iter__ (self)
def	__deepcopy__ (self, memo)
def	__iadd__ (self, configs, descr=None)
def	__getattr__ (self, attr)
def	__setattr__ (self, name, value)
def	__delattr__ (self, attr)
def	__bool__ (self)
def	remove (self, items)
def	removeAll (self)
def	copyChild (self, child)
def	setParent (self, parentName)
def	getParent (self)
def	hasParent (self, parent)
def	copyChildAndSetParent (self, cfg, parent)
def	getChildren (self)
def	getTools (self)
def	children (self)
def	getAllChildren (self)
def	getSequence (self)
def	setup (self)
def	getProperties (self)
def	getPropertiesWithDescription (self)
def	getValuedProperties (self)
def	properties (self)
def	getDefaultProperties (cls)
def	getDefaultProperty (cls, name)
def	getProp (self, name)
def	setProp (self, name, value)
def	isPropertySet (self, name)
def	getType (cls)
def	getName (self)
def	name (self)
def	getJobOptName (self)
def	isPublic (self)
def	jobOptName (self)
def	getFullName (self)
def	getFullJobOptName (self)
def	getPrintTitle (self)
def	getTitleName (self)
def	setDefaults (cls, handle)
def	clone (self, name=None, **kwargs)
def	splitName (self)
def	addTool (self, tool, name=None)
def	__repr__ (self)
def	__str__ (self, indent=0, headerLastIndentUnit=indentUnit)
Public Member Functions inherited from GaudiKernel.ConfigurableMeta.ConfigurableMeta
def	__new__ (self, name, bases, dct)
def	__call__ (cls, *args, **kwargs)

Private Member Functions
def	__addActiveUseOf (self, other)
def	__addPassiveUseOf (self, other)
def	_instanceName (self, cls)

Private Attributes
	_enabled
	__users__
	_applied
	__used_instances__

Static Private Attributes
dictionary	__slots__
list	__used_configurables__ = []
list	__queried_configurables__ = []

Additional Inherited Members
Static Public Attributes inherited from GaudiKernel.Configurable.Configurable
	propertyNoValue
string	indentUnit = "| "
int	printHeaderWidth = 100
int	printHeaderPre = 5
dictionary	allConfigurables = {}
dictionary	configurableServices = {}

Detailed Description

Definition at line 1347 of file Configurable.py.

Constructor & Destructor Documentation

__init__()

def GaudiKernel.Configurable.ConfigurableUser.__init__	(		self,
			name = Configurable.DefaultName,
			_enabled = True,
		**	kwargs
	)

Definition at line 1367 of file Configurable.py.

    def __init__(self, name=Configurable.DefaultName, _enabled=True, **kwargs):
        super(ConfigurableUser, self).__init__(name)
        for n, v in kwargs.items():
            setattr(self, n, v)
        self._enabled = _enabled
        self.__users__ = []
        self._applied = False
 
        # Needed to retrieve the actual class if the declaration in __used_configurables__
        # and  __queried_configurables__ is done with strings.
        from GaudiKernel.ConfigurableDb import getConfigurable as confDbGetConfigurable
 
        # Set the list of users of the used configurables
        #
        self.__used_instances__ = []
        for used in self.__used_configurables__:
            # By default we want to use the default name of the instances
            # for the used configurables
            used_name = Configurable.DefaultName
            # If the entry in the list is a tuple, we need a named instance
            if type(used) is tuple:
                used, used_name = used  # we re-set used to re-use the code below
                if not used_name:
                    used_name = self._instanceName(used)
            # Check is 'used' is a string or not
            if type(used) is str:
                used_class = confDbGetConfigurable(used)
            else:
                used_class = used
            # Instantiate the configurable that we are going to use
            try:
                inst = used_class(name=used_name, _enabled=False)
            except AttributeError:
                # This cover the case where the used configurable is not a
                # ConfigurableUser instance, i.e. id doesn't have the attribute
                # '_enabled'.
                inst = used_class(name=used_name)
            self.__addActiveUseOf(inst)
        for queried in self.__queried_configurables__:
            try:
                if type(queried) is str:
                    queried = confDbGetConfigurable(queried)
                inst = queried(_enabled=False)
            except AttributeError:
                inst = queried()
            self.__addPassiveUseOf(inst)
 

Member Function Documentation

__addActiveUseOf()

def GaudiKernel.Configurable.ConfigurableUser.__addActiveUseOf (   self,   other  )

private

Declare that we are going to modify the Configurable 'other' in our
__apply_configuration__.

Definition at line 1414 of file Configurable.py.

    def __addActiveUseOf(self, other):
        """
        Declare that we are going to modify the Configurable 'other' in our
        __apply_configuration__.
        """
        self.__used_instances__.append(other)
        if hasattr(other, "__users__"):  # allow usage of plain Configurables
            other.__users__.append(self)
 

__addPassiveUseOf()

def GaudiKernel.Configurable.ConfigurableUser.__addPassiveUseOf (   self,   other  )

private

Declare that we are going to retrieve property values from the
ConfigurableUser 'other' in our __apply_configuration__.

Definition at line 1423 of file Configurable.py.

    def __addPassiveUseOf(self, other):
        """
        Declare that we are going to retrieve property values from the
        ConfigurableUser 'other' in our __apply_configuration__.
        """
        if not isinstance(other, ConfigurableUser):
            raise Error(
                "'%s': Cannot make passive use of '%s', it is not a ConfigurableUser"
                % (self.name(), other.name())
            )
        other.__addActiveUseOf(self)
 

__apply_configuration__()

def GaudiKernel.Configurable.ConfigurableUser.__apply_configuration__

(

self

)

Function to be overridden to convert the high level configuration into a
low level one.
The default implementation calls applyConf, which is the method defined
in some ConfigurableUser implementations.

Reimplemented in ConfigurableUser.ExampleApplication, ConfigurableUser.ExampleCommon, GaudiExamples.Configuration.GaudiExamplesCommonConf, ConfigurableUser.ExampleIO, and Gaudi.ConfUser.GaudiPersistency.

Definition at line 1514 of file Configurable.py.

    def __apply_configuration__(self):
        """
        Function to be overridden to convert the high level configuration into a
        low level one.
        The default implementation calls applyConf, which is the method defined
        in some ConfigurableUser implementations.
        """
        return self.applyConf()
 

__detach_used__()

def GaudiKernel.Configurable.ConfigurableUser.__detach_used__

(

self

)

Remove this ConfigurableUser instance from the users list of the used
instances.

Definition at line 1445 of file Configurable.py.

    def __detach_used__(self):
        """
        Remove this ConfigurableUser instance from the users list of the used
        instances.
        """
        for used in self.__used_instances__:
            if hasattr(used, "__users__"):  # allow usage of plain Configurables
                used.__users__.remove(self)
 

_instanceName()

def GaudiKernel.Configurable.ConfigurableUser._instanceName (   self,   cls  )

private

Function used to define the name of the private instance of a given class
name.
This method is used when the __used_configurables_property__ declares the
need of a private used configurable without specifying the name.

Definition at line 1530 of file Configurable.py.

    def _instanceName(self, cls):
        """
        Function used to define the name of the private instance of a given class
        name.
        This method is used when the __used_configurables_property__ declares the
        need of a private used configurable without specifying the name.
        """
        if type(cls) is str:
            clName = cls
        else:
            clName = cls.__name__
        return "%s_%s" % (self.name(), clName)
 

applyConf()

def GaudiKernel.Configurable.ConfigurableUser.applyConf

(

self

)

Function to be overridden to convert the high level configuration into a
low level one.

Definition at line 1523 of file Configurable.py.

    def applyConf(self):
        """
        Function to be overridden to convert the high level configuration into a
        low level one.
        """
        pass
 

getDlls()

def GaudiKernel.Configurable.ConfigurableUser.getDlls

(

self

)

Definition at line 1439 of file Configurable.py.

    def getDlls(self):
        return None
 

getGaudiType()

def GaudiKernel.Configurable.ConfigurableUser.getGaudiType

(

cls

)

Definition at line 1436 of file Configurable.py.

    def getGaudiType(cls):
        return "User"
 

getHandle()

def GaudiKernel.Configurable.ConfigurableUser.getHandle

(

self

)

Definition at line 1442 of file Configurable.py.

    def getHandle(self):
        return None
 

getUsedInstance()

def GaudiKernel.Configurable.ConfigurableUser.getUsedInstance	(		self,
			name
	)

Return the used instance with a given name.

Definition at line 1543 of file Configurable.py.

    def getUsedInstance(self, name):
        """
        Return the used instance with a given name.
        """
        for i in self.__used_instances__:
            if i.name() == name:
                if hasattr(i, "_enabled"):
                    # ensure that the instances retrieved through the method are
                    # enabled
                    i._enabled = True
                return i
        raise KeyError(name)
 

isApplicable()

def GaudiKernel.Configurable.ConfigurableUser.isApplicable

(

self

)

Return True is the instance can be "applied".

Reimplemented from GaudiKernel.Configurable.Configurable.

Definition at line 1556 of file Configurable.py.

    def isApplicable(self):
        """
        Return True is the instance can be "applied".
        """
        return (not self.__users__) and (not self._applied)
 
 
# list of callables to be called after all the __apply_configuration__ are called.

propagateProperties()

def GaudiKernel.Configurable.ConfigurableUser.propagateProperties	(		self,
			names = None,
			others = None,
			force = True
	)

Call propagateProperty for each property listed in 'names'.
If 'names' is None, all the properties are propagated.

Definition at line 1503 of file Configurable.py.

    def propagateProperties(self, names=None, others=None, force=True):
        """
        Call propagateProperty for each property listed in 'names'.
        If 'names' is None, all the properties are propagated.
        """
        if names is None:
            # use all the non-private slots
            names = [p for p in self.__slots__ if not p.startswith("_")]
        for n in names:
            self.propagateProperty(n, others, force)
 

propagateProperty()

def GaudiKernel.Configurable.ConfigurableUser.propagateProperty	(		self,
			name,
			others = None,
			force = True
	)

Propagate the property 'name' (if set) to other configurables (if possible).
'others' can be:
    None:
propagate to all the entries in __used_configurables__
    a configurable instance:
propagate only to it
    list of configurable instances:
propagate to all of them.


The logic is:
- if the local property is set, the other property will be overwritten
- local property not set and other set => keep other
- local property not set and other not set => overwrite the default for
    ConfigurableUser instances and set the property for Configurables

Definition at line 1454 of file Configurable.py.

    def propagateProperty(self, name, others=None, force=True):
        """
        Propagate the property 'name' (if set) to other configurables (if possible).
        'others' can be:
            None:
                propagate to all the entries in __used_configurables__
            a configurable instance:
                propagate only to it
            list of configurable instances:
                propagate to all of them.
 
 
        The logic is:
        - if the local property is set, the other property will be overwritten
        - local property not set and other set => keep other
        - local property not set and other not set => overwrite the default for
            ConfigurableUser instances and set the property for Configurables
        """
        # transform 'others' to a list of configurable instances
        if others is None:
            others = self.__used_instances__
        elif type(others) not in [list, tuple]:
            others = [others]
        # these can be computed before the loop
        local_is_set = self.isPropertySet(name)
        value = self.getProp(name)
        # loop over the others that do have 'name' in their slots
        for other in [o for o in others if name in o.__slots__]:
            # If self property is set, use it
            if local_is_set:
                if other.isPropertySet(name):
                    log.warning(
                        "Property '%(prop)s' is set in both '%(self)s' and '%(other)s', using '%(self)s.%(prop)s'"
                        % {"self": self.name(), "other": other.name(), "prop": name}
                    )
                other.setProp(name, value)
            # If not, and other property also not set, propagate the default
            elif not other.isPropertySet(name):
                if isinstance(other, ConfigurableUser):
                    otherType = type(other._properties[name].getDefault())
                    other._properties[name].setDefault(value)
                    if otherType in [list, dict]:
                        # Special case for list and dictionaries:
                        # also set the property to the same value of the default (copy)
                        other.setProp(name, otherType(value))
                else:
                    other.setProp(name, value)
            # If not set and other set, do nothing
 

Member Data Documentation

__queried_configurables__

list GaudiKernel.Configurable.ConfigurableUser.__queried_configurables__ = []

staticprivate

Definition at line 1365 of file Configurable.py.

__slots__

dictionary GaudiKernel.Configurable.ConfigurableUser.__slots__

staticprivate

Initial value:

=  {
        "__users__": [],
        "__used_instances__": [],
        "_enabled": True,
        "_applied": False,
    }

Definition at line 1348 of file Configurable.py.

__used_configurables__

list GaudiKernel.Configurable.ConfigurableUser.__used_configurables__ = []

staticprivate

Definition at line 1362 of file Configurable.py.

__used_instances__

GaudiKernel.Configurable.ConfigurableUser.__used_instances__

private

Definition at line 1381 of file Configurable.py.

__users__

GaudiKernel.Configurable.ConfigurableUser.__users__

private

Definition at line 1372 of file Configurable.py.

_applied

GaudiKernel.Configurable.ConfigurableUser._applied

private

Definition at line 1373 of file Configurable.py.

_enabled

GaudiKernel.Configurable.ConfigurableUser._enabled

private

Definition at line 1371 of file Configurable.py.

---

The documentation for this class was generated from the following file:

• GaudiKernel/python/GaudiKernel/Configurable.py