Inheritance diagram for GaudiKernel.Configurable.Configurable:

Collaboration diagram for GaudiKernel.Configurable.Configurable:

Classes
class	DefaultName

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

Public Attributes
	configurables

Static Public Attributes
	propertyNoValue
str	indentUnit = "\| "
int	printHeaderWidth = 100
int	printHeaderPre = 5
dict	allConfigurables = {}
dict	configurableServices = {}

Protected Member Functions
	_isInSetDefaults (self)

Static Protected Member Functions
	_printHeader (indentStr, title)
	_printFooter (indentStr, title)

Protected Attributes
	_name = self.__class__.DefaultedName
bool	_inSetDefaults = False
bool	_initok = True
bool	_setupok = False
bool	_unpickling = False
	_properties

Static Protected Attributes
bool	_configurationLocked = False

Private Member Functions
	__setupServices (self)
	__setupDlls (self)
	__setupDefaults (self)

Private Attributes
	__name__
	__bases__
list	__children = []
dict	__tools = {}
	__class__

Static Private Attributes
tuple	__slots__

Detailed Description

Base class for Gaudi components that implement the IProperty interface.
Provides most of the boilerplate code, but the actual useful classes
are its derived ConfigurableAlgorithm, ConfigurableService, and
ConfigurableAlgTool.

Definition at line 154 of file Configurable.py.

Constructor & Destructor Documentation

◆ init()

GaudiKernel.Configurable.Configurable.__init__	(		self,
			name = DefaultName )

Definition at line 343 of file Configurable.py.

    def __init__(self, name=DefaultName):
        # check class readiness, all required overloads should be there now
        klass = self.__class__
 
        # this is an abstract class
        if klass == Configurable:
            raise TypeError(f"{Configurable} is an ABC and can not be instantiated")
 
        # the following methods require overloading
        # NOT YET  meths = { 'getServices'   : 1,    # retrieve list of services to configure
        meths = {
            "getDlls": 1,  # provide list of Dlls to load
            "getGaudiType": 1,  # return string describing component class
            "getHandle": 1,
        }  # provide access to C++ side component instance
        #                'getType'       : 1 }   # return the type of the actual C++ component
 
        for meth, nArgs in meths.items():
            try:
                f = getattr(klass, meth)
            except AttributeError:
                raise NotImplementedError(f"{meth} is missing in class {klass}")
 
            # in addition, verify the number of arguments w/o defaults
            nargcount = f.__code__.co_argcount
            fdefaults = f.__defaults__
            ndefaults = fdefaults and len(fdefaults) or 0
            if not nargcount - ndefaults <= nArgs <= nargcount:
                raise TypeError(f"{klass}.{meth} requires exactly {nArgs} arguments")
 
        # for using this Configurable as a (Gaudi) sequence
        self.__children = []
        self.__tools = {}
 
        # know who we are
        if name == Configurable.DefaultName:
            if hasattr(self.__class__, "DefaultedName"):
                self._name = self.__class__.DefaultedName
            else:
                self._name = self.getType()
        else:
            self._name = name
 
        # set to True when collecting defaults, False otherwise
        self._inSetDefaults = False
 
        # for later, in case __init__ itself is overridden
        self._initok = True
 
        # for debugging purposes (temporary)
        self._setupok = False
 
        # used to prevent spurious deprecation warnings when unpickling
        self._unpickling = False
 

Member Function Documentation

◆ bool()

GaudiKernel.Configurable.Configurable.__bool__ ( self )

Definition at line 544 of file Configurable.py.

    def __bool__(self):
        return True
 

◆ deepcopy()

GaudiKernel.Configurable.Configurable.__deepcopy__	(		self,
			memo )

Definition at line 439 of file Configurable.py.

    def __deepcopy__(self, memo):
        newconf = object.__new__(self.__class__)
        self.__class__.__init__(newconf, self.getName())
 
        for proxy in self._properties.values():
            try:
                proxy.__set__(newconf, proxy.__get__(self))
            except AttributeError:
                pass  # means property was not set for self
 
        for c in self.__children:
            newconf += c  # processes proper copy semantics
 
        return newconf
 

◆ delattr()

GaudiKernel.Configurable.Configurable.__delattr__	(		self,
			attr )

Definition at line 519 of file Configurable.py.

    def __delattr__(self, attr):
        # remove as property, otherwise try as child
        try:
            # remove history etc., then reset to default (in case set before)
            prop = self._properties[attr]
            prop.__delete__(self)
            prop.__set__(self, prop.default)
            return  # reaches here? was property: done now
        except KeyError:
            pass
        # otherwise, remove the private tool
        if attr in self.__tools:
            del self.__tools[attr]
 
        # otherwise, remove child, if one is so named
        for c in self.__children:
            if c.getName() == attr:
                self.__children.remove(c)
 
        # potentially, there are left over caches (certain user derived classes)
        try:
            del self.__dict__[attr]
        except (AttributeError, KeyError):
            pass
 

◆ getattr()

GaudiKernel.Configurable.Configurable.__getattr__	(		self,
			attr )

Definition at line 490 of file Configurable.py.

    def __getattr__(self, attr):  # until ToolProperties exist ...
        if attr in self.__tools:
            return self.__tools[attr]
 
        if attr in self._properties:
            if isinstance(
                self._properties[attr].__get__(self),
                (DataHandle, DataHandleVector),
            ):
                return self._properties[attr].__get__(self)
 
        for c in self.__children:
            if c.getName() == attr:
                return c
 
        raise AttributeError(f"'{self.__class__}' object has no attribute '{attr}'")
 

◆ getnewargs()

GaudiKernel.Configurable.Configurable.__getnewargs__ ( self )

Definition at line 412 of file Configurable.py.

    def __getnewargs__(self):
        return (self._name,)
 

◆ getstate()

GaudiKernel.Configurable.Configurable.__getstate__ ( self )

Definition at line 399 of file Configurable.py.

    def __getstate__(self):
        dict = {}
        for name, proxy in self._properties.items():
            try:
                dict[name] = proxy.__get__(self)
            except AttributeError:
                pass
 
        dict["_Configurable__children"] = self.__children
        dict["_Configurable__tools"] = self.__tools
        dict["_name"] = self._name
        return dict
 

◆ iadd()

GaudiKernel.Configurable.Configurable.__iadd__	(	self,
		configs,
		descr = None )

Definition at line 455 of file Configurable.py.

    def __iadd__(self, configs, descr=None):
        if not isinstance(configs, (list, tuple)):
            configs = (configs,)
 
        joname = self.getJobOptName()
 
        for cfg in configs:
            # prevent type mismatches
            if not isinstance(cfg, Configurable):
                raise TypeError(f"'{cfg}' is not a Configurable")
 
            cc = self.copyChildAndSetParent(cfg, joname)
 
            # filters dupes; usually "ok" (backdoor should catch them)
            ccjo = cc.getJobOptName()
            for c in self.__children:
                if c.getJobOptName() == ccjo:
                    log.error(
                        "attempt to add a duplicate ... dupe ignored%s",
                        error_explanation,
                    )
                    break
            else:
                self.__children.append(cc)
 
            try:
                if descr:  # support for tool properties
                    descr.__set__(self, cc)
                else:
                    setattr(self, cc.getName(), cc)
            except AttributeError:
                pass  # to allow free addition of tools/subalgorithms
 
        return self
 

◆ iter()

GaudiKernel.Configurable.Configurable.__iter__ ( self )

Definition at line 435 of file Configurable.py.

    def __iter__(self):
        return iter(self.__children)
 

◆ len()

GaudiKernel.Configurable.Configurable.__len__ ( self )

Definition at line 432 of file Configurable.py.

    def __len__(self):
        return len(self.__children)
 

◆ new()

GaudiKernel.Configurable.Configurable.__new__	(		cls,
		*	args,
		**	kwargs )

To Gaudi, any object with the same type/name is the same object. Hence,
this is mimicked in the configuration: instantiating a new Configurable
of a type with the same name will return the same instance.

Definition at line 185 of file Configurable.py.

    def __new__(cls, *args, **kwargs):
        """To Gaudi, any object with the same type/name is the same object. Hence,
        this is mimicked in the configuration: instantiating a new Configurable
        of a type with the same name will return the same instance."""
 
        global log
        func_code = cls.__init__.__code__
        func_defaults = cls.__init__.__defaults__
        # try to get the name of the Configurable (having a name is compulsory)
        if "name" in kwargs:
            # simple keyword (by far the easiest)
            name = kwargs["name"]
        elif "name" in func_code.co_varnames:
            # either positional in args, or default
            index = list(func_code.co_varnames).index("name")
            try:
                # var names index is offset by one as __init__ is to be called with self
                name = args[index - 1]
            except IndexError:
                # retrieve default value, then
                name = func_defaults[index - (len(args) + 1)]
        else:
            # positional index is assumed (will work most of the time)
            try:
                name = args[1]  # '0' is for self
            except (IndexError, TypeError):
                raise TypeError(
                    f'no "name" argument while instantiating "{cls.__name__}"'
                )
 
        argname = name
        if name == Configurable.DefaultName:
            if hasattr(cls, "DefaultedName"):
                name = cls.DefaultedName
            else:
                name = cls.getType()
        elif not name or not isinstance(name, str):
            # unnamed, highly specialized user code, etc. ... unacceptable
            raise TypeError(
                f"could not retrieve name from {cls.__name__}.__init__ arguments"
            )
 
        # Handle the case of global tools to prepend ToolSvc in the name.
        # This is needed for compatibility with old JobOptions files being read
        if issubclass(cls, ConfigurableAlgTool) and "." not in name:
            name = "ToolSvc." + name
 
        # close backdoor access to otherwise private subalgs/tools
        # PM if 0 <= name.find( '.' ):
        # PM # temp protection for old style types
        # PM   from OldStyleConfig import GenericConfigurable
        # PM   if not issubclass( cls, GenericConfigurable ): # except raised for new types only
        # PM      raise NameError( '"%s": backdoor access to private configurables not allowed' % name )
 
        # ordinary recycle case
        if name in cls.configurables:
            conf = cls.configurables[name]
            if name != argname:  # special case: user derived <-> real ... make same
                cls.configurables[conf.getType()] = conf
            # ---PM: Initialize additional properties
            for n, v in kwargs.items():
                if n != "name":  # it should not be confused with a normal property
                    setattr(conf, n, v)
            if (
                not cls._configurationLocked
                and "_enabled" not in kwargs
                and isinstance(conf, ConfigurableUser)
            ):
                # Ensure that the ConfigurableUser gets enabled if nothing is
                # specified in the constructor.
                setattr(conf, "_enabled", True)
            return conf
 
        # a couple of special cases (note that these cases don't mix)
        spos = name.find("/")
        ti_name = None
        if spos < 0:
            ti_name = f"{name}/{name}"
            if ti_name in cls.configurables:
                # support for old-style name as type/name lookup where name==type
                return cls.configurables[ti_name]
 
        i_name = None
        if spos > 0:
            i_name = name[:spos]
            if i_name == name[spos + 1 :] and i_name in cls.configurables:
                # this is the opposite of the above special case
                return cls.configurables[i_name]
 
        # the following is purely for debugging support and should realistically bomb
        conf = (
            cls.allConfigurables.get(name, None)
            or (spos < 0 and cls.allConfigurables.get(ti_name, None))
            or (
                spos > 0
                and i_name == name[spos + 1 :]
                and cls.allConfigurables.get(i_name, None)
            )
        )
        if conf:  # wrong type used?
            if conf.__class__ is ConfigurableGeneric:
                #  If the instance found is ConfigurableGeneric then
                #  we create a new one with the proper type and fill with
                #  the contents of the generic one
                newconf = object.__new__(cls)
                cls.__init__(newconf, *args, **kwargs)
                #  initialize with the properties of generic configurable
                #  (we map the names of the properties to lowercase versions because
                #  old options are not case sensitive)
                names = {}
                for n in newconf.__slots__:
                    names[n.lower()] = n
                for n in conf._properties:
                    if names[n.lower()] != n:
                        log.warning(
                            f"Option '{n}' was used for {name}, but the correct spelling is '{names[n.lower()]}'"
                        )
                    setattr(newconf, names[n.lower()], getattr(conf, n))
                for n, v in kwargs.items():
                    setattr(newconf, n, v)
                cls.configurables[name] = newconf
                cls.allConfigurables[name] = newconf
                return newconf
            else:
                #  will be an actual error in the future (now only report as such)
                log.error(
                    'attempt to redefine type of "%s" (was: %s, new: %s)%s',
                    name,
                    conf.__class__.__name__,
                    cls.__name__,
                    error_explanation,
                )
                #  in the future:
                #  return None             # will bomb on use (or go unharmed on non-use)
                #  for now, allow use through allConfigurables lookup
                # ---PM: Initialize additional properties
                for n, v in kwargs.items():
                    setattr(conf, n, v)
                return conf
 
        # still here: create a new instance and initialize it
        conf = object.__new__(cls)
        cls.__init__(conf, *args, **kwargs)
 
        # update normal, per-class cache
        cls.configurables[name] = conf
 
        for base in cls.__bases__:
            if base.__name__ == "ConfigurableService":
                cls.configurableServices[name] = conf
 
        # update generics super-cache, if needed
        cls.allConfigurables[name] = conf
        # -->PM#if hasattr( cls, 'getType' ) and name.find('/') < 0:
        # -->PM#   cls.allConfigurables[ cls.getType() + '/' + name ] = conf
 
        return conf
 

◆ repr()

GaudiKernel.Configurable.Configurable.__repr__ ( self )

Definition at line 964 of file Configurable.py.

    def __repr__(self):
        return f"{self.__class__.__name__}({self.name()!r})"
 

◆ setattr()

GaudiKernel.Configurable.Configurable.__setattr__	(	self,
		name,
		value )

Definition at line 507 of file Configurable.py.

    def __setattr__(self, name, value):
        if self._configurationLocked:
            raise RuntimeError(
                f"{self.name()}: Configuration cannot be modified after the ApplicationMgr has been started."
            )
        try:
            super().__setattr__(name, value)
        except AttributeError:
            raise AttributeError(
                f"Configurable '{self.__class__.__name__}' does not have property '{name}'."
            )
 

◆ setstate()

GaudiKernel.Configurable.Configurable.__setstate__	(		self,
			dict )

Definition at line 415 of file Configurable.py.

    def __setstate__(self, dict):
        self._initok = True
        from contextlib import contextmanager
 
        @contextmanager
        def unpickling():
            try:
                self._unpickling = True
                yield
            finally:
                self._unpickling = False
 
        with unpickling():
            for n, v in dict.items():
                setattr(self, n, v)
 

◆ __setupDefaults()

GaudiKernel.Configurable.Configurable.__setupDefaults ( self )

private

Definition at line 937 of file Configurable.py.

    def __setupDefaults(self):
        # set handle defaults flags to inform __setattr__ that it is being
        # called during setDefaults of the concrete Configurable
        self._inSetDefaults = True
        self.setDefaults(self)
        self._inSetDefaults = False
 

◆ __setupDlls()

GaudiKernel.Configurable.Configurable.__setupDlls ( self )

private

Definition at line 924 of file Configurable.py.

    def __setupDlls(self):
        dlls = self.getDlls()
        if not dlls:
            dlls = []
        elif isinstance(dlls, types.StringType):
            dlls = [dlls]
 
        from __main__ import theApp
 
        dlls = filter(lambda d: d not in theApp.Dlls, dlls)
        if dlls:
            theApp.Dlls += dlls
 

◆ __setupServices()

GaudiKernel.Configurable.Configurable.__setupServices ( self )

private

Definition at line 906 of file Configurable.py.

    def __setupServices(self):
        # svcs = self.getServices()
        # if not svcs:
        svcs = []
        # elif type(svcs) == types.StringType:
        #   svcs = [ svcs ]
 
        import __main__
 
        for svc in svcs:
            handle = __main__.Service(svc)  # noqa: F841 (used in eval below)
            # services should be configurables as well, but aren't for now
            # handle.setup()
 
            # allow Configurable to make some changes
            if hasattr(self, "configure" + svc):
                eval("self.configure" + svc + "( handle )")
 

◆ str()

GaudiKernel.Configurable.Configurable.__str__	(	self,
		indent = 0,
		headerLastIndentUnit = indentUnit )

Definition at line 967 of file Configurable.py.

    def __str__(self, indent=0, headerLastIndentUnit=indentUnit):
        global log  # to print some info depending on output level
 
        def _sorted_repr_set(value):
            """Helper to print sorted set representation"""
            return "{" + repr(sorted(value))[1:-1] + "}" if value else "set()"
 
        indentStr = indent * Configurable.indentUnit
        # print header
        title = self.getPrintTitle()
        # print line to easily see start-of-configurable
        if indent > 0:
            headerIndent = (indent - 1) * Configurable.indentUnit + headerLastIndentUnit
        else:
            headerIndent = ""
        rep = Configurable._printHeader(headerIndent, title)
        rep += os.linesep
        # print own properties
        props = self.getProperties()
        defs = self.getDefaultProperties()
        if not props:
            rep += f"{indentStr}|-<no properties>{os.linesep}"
        else:
            # get property name with
            nameWidth = 0
            for p in props.keys():
                nameWidth = max(nameWidth, len(p))
            for p, v in props.items():
                # start with indent and property name
                prefix = f"{indentStr}|-{p:<{nameWidth}}"
                # add memory address for debugging (not for defaults)
                if log.isEnabledFor(logging.DEBUG):
                    if v != Configurable.propertyNoValue:
                        address = f" @{id(v):#018x}"
                    else:
                        address = 20 * " "
                    prefix += address
                # add value and default
                default = defs.get(p)
                if v == Configurable.propertyNoValue:
                    # show default value as value, and no extra 'default'
                    strVal = repr(default)
                    strDef = None
                else:
                    # convert configurable to handle
                    if hasattr(v, "getGaudiHandle"):
                        vv = v.getGaudiHandle()
                    else:
                        vv = v
                    if isinstance(vv, (GaudiHandle, GaudiHandleArray, DataHandle)):
                        strVal = repr(vv)
                        # the default may not be a GaudiHandle (?)
                        if hasattr(default, "toStringProperty"):
                            strDef = repr(default.toStringProperty())
                        else:
                            strDef = repr(default)
                        if strDef == repr(vv.toStringProperty()):
                            strDef = None
                    elif isinstance(vv, set):
                        strVal = _sorted_repr_set(vv)
                        strDef = _sorted_repr_set(default)
                    else:
                        strVal = repr(vv)
                        strDef = repr(default)
                # add the value
                line = prefix + " = " + strVal
                # add default if present
                if strDef is not None:
                    # put default on new line if too big
                    if len(line) + len(strDef) > Configurable.printHeaderWidth:
                        line += (
                            os.linesep
                            + indentStr
                            + "| "
                            + (len(prefix) - len(indentStr) - 3) * " "
                        )
                    line += f"  (default: {strDef})"
                # add the line to the total string
                rep += line + os.linesep
                # print out full private configurables
        # if isinstance(v,Configurable) and not v.isPublic():
        
 
        # print configurables + their properties, or loop over sequence
        # for cfg in self.__children:
        for cfg in self.getAllChildren():
            rep += cfg.__str__(indent + 1, "|=") + os.linesep
 
        # print line to easily see end-of-configurable. Note: No linesep!
        rep += Configurable._printFooter(indentStr, title)
        return rep
 

◆ _isInSetDefaults()

GaudiKernel.Configurable.Configurable._isInSetDefaults ( self )

protected

Definition at line 903 of file Configurable.py.

    def _isInSetDefaults(self):
        return self._inSetDefaults
 

◆ _printFooter()

GaudiKernel.Configurable.Configurable._printFooter	(		indentStr,
			title )

staticprotected

Definition at line 954 of file Configurable.py.

    def _printFooter(indentStr, title):
        preLen = Configurable.printHeaderPre
        postLen = (
            Configurable.printHeaderWidth - preLen - 12 - len(title)
        )  # - len(indentStr)
        postLen = max(preLen, postLen)
        return indentStr + "\\{} (End of {}) {}".format(
            preLen * "-", title, postLen * "-"
        )
 

◆ _printHeader()

GaudiKernel.Configurable.Configurable._printHeader	(		indentStr,
			title )

staticprotected

Definition at line 945 of file Configurable.py.

    def _printHeader(indentStr, title):
        preLen = Configurable.printHeaderPre
        postLen = (
            Configurable.printHeaderWidth - preLen - 3 - len(title)
        )  # - len(indentStr)
        postLen = max(preLen, postLen)
        return indentStr + "/{} {} {}".format(preLen * "*", title, postLen * "*")
 

◆ addTool()

GaudiKernel.Configurable.Configurable.addTool	(	self,
		tool,
		name = None )

Definition at line 880 of file Configurable.py.

    def addTool(self, tool, name=None):
        if isclass(tool) and issubclass(tool, ConfigurableAlgTool):
            if name is None:
                name = tool.__name__
            priv_tool = tool(self.getName() + "." + name)
        elif isinstance(tool, ConfigurableAlgTool):
            if name is None:
                name = tool.splitName()[1]
            priv_tool = tool.clone(self.getName() + "." + name)
        else:
            if isclass(tool):
                classname = tool.__name__
            else:
                classname = type(tool).__name__
            raise TypeError(
                f"addTool requires AlgTool configurable. Got {classname} type"
            )
        self.__tools[name] = priv_tool
        if name in self.__slots__:
            # this is to avoid that the property hides the tool
            setattr(self, name, self.__tools[name])
        return self.__tools[name]
 

◆ children()

GaudiKernel.Configurable.Configurable.children ( self )

Definition at line 595 of file Configurable.py.

    def children(self):
        log.error("children() is deprecated, use getChildren() instead for consistency")
        log.error(
            "getChildren() returns a copy; to add a child, use 'parent += child'%s",
            error_explanation,
        )
        return self.__children  # by ref, for compatibility
 

◆ clone()

GaudiKernel.Configurable.Configurable.clone	(		self,
			name = None,
		**	kwargs )

Definition at line 833 of file Configurable.py.

    def clone(self, name=None, **kwargs):
        if not name:
            if hasattr(self, "DefaultedName"):
                name = self.DefaultedName
            else:
                name = self.getType()
 
        newconf = Configurable.__new__(self.__class__, name)
        self.__class__.__init__(newconf, name)
 
        for proxy in self._properties.values():
            try:
                value = proxy.__get__(self)
                if isinstance(value, (str, list, dict, tuple, set)):
                    # clone the values of the properties for basic types
                    value = type(value)(value)
                proxy.__set__(newconf, value)
            except AttributeError:
                pass
 
        for c in self.__children:
            newconf += c  # processes proper copy semantics
 
        for n, t in self.__tools.items():
            newconf.addTool(t, n)
 
        for name, value in kwargs.items():
            setattr(newconf, name, value)
 
        return newconf
 

◆ copyChild()

GaudiKernel.Configurable.Configurable.copyChild	(		self,
			child )

Reimplemented in GaudiKernel.Configurable.ConfigurableService.

Definition at line 557 of file Configurable.py.

    def copyChild(self, child):
        return copy.deepcopy(child)
 

◆ copyChildAndSetParent()

GaudiKernel.Configurable.Configurable.copyChildAndSetParent	(	self,
		cfg,
		parent )

Definition at line 569 of file Configurable.py.

    def copyChildAndSetParent(self, cfg, parent):
        cc = self.copyChild(cfg)
 
        if hasattr(cc, "setParent") and parent:
            try:
                cc.setParent(parent)
            except RuntimeError as e:
                # temporary backdoor resolution for compatibility
                log.error(str(e) + "%s", error_explanation)
                ccbd = cc.configurables[cc.getJobOptName()]
 
                # merge properties, new over pre-existing
                for proxy in self._properties.values():
                    if cc in proxy.history:
                        proxy.__set__(ccbd, proxy.__get__(cc))
 
                # consolidate
                cc = ccbd
        return cc
 

◆ getAllChildren()

GaudiKernel.Configurable.Configurable.getAllChildren ( self )

Get all (private) configurable children, both explicit ones (added with +=)
and the ones in the private GaudiHandle properties

Definition at line 603 of file Configurable.py.

    def getAllChildren(self):
        """Get all (private) configurable children, both explicit ones (added with +=)
        and the ones in the private GaudiHandle properties"""
        childs = []
        # add private configurable properties (also inside handles)
        for proxy in self._properties.values():
            try:
                c = proxy.__get__(self)
            except AttributeError:
                pass
            else:
                if isinstance(c, Configurable) and not c.isPublic():
                    childs.append(c)
                elif isinstance(c, GaudiHandle):
                    try:
                        conf = c.configurable
                    except AttributeError:
                        pass
                    else:
                        if not conf.isPublic():
                            childs.append(conf)
                elif isinstance(c, GaudiHandleArray):
                    # only setup private arrays
                    if not c.isPublic():
                        for ci in c:
                            if isinstance(ci, Configurable):
                                childs.append(ci)
                            else:
                                try:
                                    conf = ci.configurable
                                except AttributeError:
                                    pass
                                else:
                                    childs.append(conf)
 
        # add explicit children
        childs += self.__children
        return childs
 

◆ getChildren()

GaudiKernel.Configurable.Configurable.getChildren ( self )

Definition at line 589 of file Configurable.py.

    def getChildren(self):
        return self.__children[:]  # read only
 

◆ getDefaultProperties()

GaudiKernel.Configurable.Configurable.getDefaultProperties ( cls )

Definition at line 732 of file Configurable.py.

    def getDefaultProperties(cls):
        # user provided defaults
        c = _DefaultPropertiesCollectorHelper()
        cls.setDefaults(c)
 
        # defaults from C++
        for k, v in cls._properties.items():
            if k not in c.__dict__ and hasattr(v, "default"):
                c.__dict__[k] = v.default
 
        return c.__dict__
 

◆ getDefaultProperty()

GaudiKernel.Configurable.Configurable.getDefaultProperty	(		cls,
			name )

Definition at line 745 of file Configurable.py.

    def getDefaultProperty(cls, name):
        # user provided defaults
        c = _DefaultPropertiesCollectorHelper()
        cls.setDefaults(c)
 
        if name in c.__dict__:
            return c.__dict__[name]
 
        # defaults from C++
        try:
            v = cls._properties[name]
            if hasattr(v, "default"):
                return v.default
        except KeyError:
            pass
 
        return None
 

◆ getFullJobOptName()

GaudiKernel.Configurable.Configurable.getFullJobOptName ( self )

Definition at line 818 of file Configurable.py.

    def getFullJobOptName(self):
        return f"{self.getType()}/{self.getJobOptName() or self.getName()}"
 

◆ getFullName()

GaudiKernel.Configurable.Configurable.getFullName ( self )

Reimplemented in GaudiKernel.Configurable.ConfigurableAlgTool.

Definition at line 815 of file Configurable.py.

    def getFullName(self):
        return str(self.getType() + "/" + self.getName())
 

◆ getJobOptName()

GaudiKernel.Configurable.Configurable.getJobOptName ( self )

Reimplemented in GaudiKernel.Configurable.ConfigurableAlgorithm, GaudiKernel.Configurable.ConfigurableAlgTool, GaudiKernel.Configurable.ConfigurableAuditor, and GaudiKernel.Configurable.ConfigurableGeneric.

Definition at line 801 of file Configurable.py.

    def getJobOptName(self):  # full hierachical name
        return self.getName()
 

◆ getName()

GaudiKernel.Configurable.Configurable.getName ( self )

Definition at line 795 of file Configurable.py.

    def getName(self):
        return self._name
 

◆ getParent()

GaudiKernel.Configurable.Configurable.getParent ( self )

Reimplemented in GaudiKernel.Configurable.ConfigurableAlgTool.

Definition at line 563 of file Configurable.py.

    def getParent(self):
        return ""
 

◆ getPrintTitle()

GaudiKernel.Configurable.Configurable.getPrintTitle ( self )

Reimplemented in GaudiKernel.Configurable.ConfigurableAlgTool.

Definition at line 821 of file Configurable.py.

    def getPrintTitle(self):
        return self.getGaudiType() + " " + self.getTitleName()
 

◆ getProp()

GaudiKernel.Configurable.Configurable.getProp	(		self,
			name )

Returns the value of the given property.

Definition at line 763 of file Configurable.py.

    def getProp(self, name):
        """Returns the value of the given property."""
        if hasattr(self, name):
            return getattr(self, name)
        else:
            return self.getDefaultProperties()[name]
 

◆ getProperties()

GaudiKernel.Configurable.Configurable.getProperties ( self )

Definition at line 681 of file Configurable.py.

    def getProperties(self):
        props = {}
        for name, proxy in self._properties.items():
            try:
                props[name] = proxy.__get__(self)
            except AttributeError:
                props[name] = Configurable.propertyNoValue
 
        return props
 

◆ getPropertiesWithDescription()

GaudiKernel.Configurable.Configurable.getPropertiesWithDescription ( self )

Get all properties with their description string as { name : (value, desc) }.

Definition at line 691 of file Configurable.py.

    def getPropertiesWithDescription(self):
        """Get all properties with their description string as { name : (value, desc) }."""
        props = {}
        for name, proxy in self._properties.items():
            try:
                props[name] = (proxy.__get__(self), proxy.__doc__)
            except AttributeError:
                props[name] = (Configurable.propertyNoValue, proxy.__doc__)
        return props
 

◆ getSequence()

GaudiKernel.Configurable.Configurable.getSequence ( self )

Definition at line 642 of file Configurable.py.

    def getSequence(self):
        elems = []
        for c in self.__children:
            elems.append(c.getFullName())
        return elems
 

◆ getTitleName()

GaudiKernel.Configurable.Configurable.getTitleName ( self )

Definition at line 824 of file Configurable.py.

    def getTitleName(self):
        if log.isEnabledFor(logging.DEBUG):
            return self.getFullJobOptName()
        else:
            return self.getFullName()
 

◆ getTools()

GaudiKernel.Configurable.Configurable.getTools ( self )

Definition at line 592 of file Configurable.py.

    def getTools(self):
        return self.__tools.values()  # read only
 

◆ getType()

GaudiKernel.Configurable.Configurable.getType ( cls )

Definition at line 792 of file Configurable.py.

    def getType(cls):
        return cls.__name__
 

◆ getValuedProperties()

GaudiKernel.Configurable.Configurable.getValuedProperties ( self )

Definition at line 701 of file Configurable.py.

    def getValuedProperties(self):
        props = {}
        for name, proxy in self._properties.items():
            if self.isPropertySet(name):
                value = proxy.__get__(self)
                if hasattr(value, "getFullName"):
                    value = value.getFullName()
                elif isinstance(value, (list, set, tuple)):
                    new_value = []
                    for i in value:
                        if hasattr(i, "getFullName"):
                            new_value.append(i.getFullName())
                        else:
                            new_value.append(i)
                    value = type(value)(new_value)
                elif isinstance(value, dict):
                    new_value = {}
                    for i in value:
                        if hasattr(value[i], "getFullName"):
                            new_value[i] = value[i].getFullName()
                        else:
                            new_value[i] = value[i]
                    value = new_value
                props[name] = value
 
        return props
 

◆ hasParent()

GaudiKernel.Configurable.Configurable.hasParent	(		self,
			parent )

Reimplemented in GaudiKernel.Configurable.ConfigurableAlgTool.

Definition at line 566 of file Configurable.py.

    def hasParent(self, parent):
        return False
 

◆ isApplicable()

GaudiKernel.Configurable.Configurable.isApplicable ( self )

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

Reimplemented in GaudiKernel.Configurable.ConfigurableUser.

Definition at line 1063 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
 
 
# classes for generic Gaudi component ===========
 
 

◆ isPropertySet()

GaudiKernel.Configurable.Configurable.isPropertySet	(		self,
			name )

Tell if the property 'name' has been set or not.

Because of a problem with list and dictionary properties, in those cases
if the value is equal to the default, the property is considered as not
set.

Definition at line 774 of file Configurable.py.

    def isPropertySet(self, name):
        """Tell if the property 'name' has been set or not.
 
        Because of a problem with list and dictionary properties, in those cases
        if the value is equal to the default, the property is considered as not
        set.
        """
        if not hasattr(self, name):
            return False
        default = self.getDefaultProperty(name)
        if isinstance(
            default,
            (list, dict, set, DataHandle, DataHandleVector, GaudiHandleArray),
        ):
            value = getattr(self, name)
            return value != default
        return True
 

◆ isPublic()

GaudiKernel.Configurable.Configurable.isPublic ( self )

Reimplemented in GaudiKernel.Configurable.ConfigurableAlgTool.

Definition at line 804 of file Configurable.py.

    def isPublic(self):
        return True
 

◆ jobOptName()

GaudiKernel.Configurable.Configurable.jobOptName ( self )

Definition at line 808 of file Configurable.py.

    def jobOptName(self):
        log.error(
            "jobOptName() is deprecated, use getJobOptName() instead for consistency%s",
            error_explanation,
        )
        return self.getJobOptName()  # compatibility
 

◆ name()

GaudiKernel.Configurable.Configurable.name ( self )

Definition at line 798 of file Configurable.py.

    def name(self):
        return self.getName()
 

◆ properties()

GaudiKernel.Configurable.Configurable.properties ( self )

Definition at line 728 of file Configurable.py.

    def properties(self):
        return self.getProperties()  # compatibility
 

◆ remove()

GaudiKernel.Configurable.Configurable.remove	(		self,
			items )

Definition at line 547 of file Configurable.py.

    def remove(self, items):
        if not isinstance(items, (list, tuple)):
            items = [items]
 
        self.__children = [e for e in self.__children if e not in items]
 

◆ removeAll()

GaudiKernel.Configurable.Configurable.removeAll ( self )

Definition at line 553 of file Configurable.py.

    def removeAll(self):
        self.remove(self.__children)
 

◆ setDefaults()

GaudiKernel.Configurable.Configurable.setDefaults	(		cls,
			handle )

Definition at line 830 of file Configurable.py.

    def setDefaults(cls, handle):
        pass
 

◆ setParent()

GaudiKernel.Configurable.Configurable.setParent	(		self,
			parentName )

Reimplemented in GaudiKernel.Configurable.ConfigurableAlgTool.

Definition at line 560 of file Configurable.py.

    def setParent(self, parentName):
        pass
 

◆ setProp()

GaudiKernel.Configurable.Configurable.setProp	(	self,
		name,
		value )

Set the value of a given property

Definition at line 770 of file Configurable.py.

    def setProp(self, name, value):
        """Set the value of a given property"""
        return setattr(self, name, value)
 

◆ setup()

GaudiKernel.Configurable.Configurable.setup ( self )

Definition at line 648 of file Configurable.py.

    def setup(self):
        # make sure base class init has been called
        if not hasattr(self, "_initok") or not self._initok:
            # could check more, but this is the only explanation
            raise TypeError(
                f"Configurable.__init__ not called in {self.__class__.__name__} override"
            )
 
        #      log.debug("calling setup() on " + self.getFullJobOptName())
 
        # setup self: this collects all values on the python side
        self.__setupServices()
        self.__setupDlls()
        self.__setupDefaults()
 
        # setup children
        for c in self.getAllChildren():
            c.setup()
 
        # now get handle to work with for moving properties into the catalogue
        handle = self.getHandle()
        if not handle:
            log.debug("no handle for %s: not transporting properties", self._name)
            return  # allowed, done early
 
        # pass final set of properties on to handle on the C++ side or JobOptSvc
        for name in self._properties.keys():
            if hasattr(self, name):  # means property has python-side value/default
                setattr(handle, name, getattr(self, name))
 
        # for debugging purposes
        self._setupok = True
 

◆ splitName()

GaudiKernel.Configurable.Configurable.splitName ( self )

Definition at line 864 of file Configurable.py.

    def splitName(self):
        fullname = self.getName()
        dot = fullname.find(".")
        if dot != -1:
            parentname = fullname[:dot]
            longname = fullname[dot + 1 :]
        else:
            parentname = ""
            longname = fullname
        dot = longname.find(".")
        if dot != -1:
            name = longname[:dot]
        else:
            name = longname
        return parentname, name, longname
 

Member Data Documentation

◆ bases

GaudiKernel.Configurable.Configurable.__bases__

private

Definition at line 332 of file Configurable.py.

◆ __children

GaudiKernel.Configurable.Configurable.__children = []

private

Definition at line 374 of file Configurable.py.

◆ class

GaudiKernel.Configurable.Configurable.__class__

private

Definition at line 379 of file Configurable.py.

◆ name

GaudiKernel.Configurable.Configurable.__name__

private

Definition at line 314 of file Configurable.py.

◆ slots

tuple GaudiKernel.Configurable.Configurable.__slots__

staticprivate

Initial value:

=  (
        "__children",  # controlled components, e.g. private AlgTools
        "__tools",  # private AlgTools  (#PM-->)
        "_name",  # the (unqualified) component name
        "_inSetDefaults",  # currently setting default values
        "_initok",  # used to enforce base class init
        "_setupok",  # for debugging purposes (temporary)
        "_unpickling",  # flag for actions done during unpickling
    )

Definition at line 169 of file Configurable.py.

◆ __tools

dict GaudiKernel.Configurable.Configurable.__tools = {}

private

Definition at line 375 of file Configurable.py.

◆ _configurationLocked

bool GaudiKernel.Configurable.Configurable._configurationLocked = False

staticprotected

Definition at line 183 of file Configurable.py.

◆ _initok

bool GaudiKernel.Configurable.Configurable._initok = True

protected

Definition at line 390 of file Configurable.py.

◆ _inSetDefaults

bool GaudiKernel.Configurable.Configurable._inSetDefaults = False

protected

Definition at line 387 of file Configurable.py.

◆ _name

GaudiKernel.Configurable.Configurable._name = self.__class__.DefaultedName

protected

Definition at line 380 of file Configurable.py.

◆ _properties

GaudiKernel.Configurable.Configurable._properties

protected

Definition at line 494 of file Configurable.py.

◆ _setupok

bool GaudiKernel.Configurable.Configurable._setupok = False

protected

Definition at line 393 of file Configurable.py.

◆ _unpickling

bool GaudiKernel.Configurable.Configurable._unpickling = False

protected

Definition at line 396 of file Configurable.py.

◆ allConfigurables

dict GaudiKernel.Configurable.Configurable.allConfigurables = {}

static

Definition at line 179 of file Configurable.py.

◆ configurables

GaudiKernel.Configurable.Configurable.configurables

Definition at line 240 of file Configurable.py.

◆ configurableServices

dict GaudiKernel.Configurable.Configurable.configurableServices = {}

static

Definition at line 180 of file Configurable.py.

◆ indentUnit

str GaudiKernel.Configurable.Configurable.indentUnit = "| "

static

Definition at line 165 of file Configurable.py.

◆ printHeaderPre

int GaudiKernel.Configurable.Configurable.printHeaderPre = 5

static

Definition at line 167 of file Configurable.py.

◆ printHeaderWidth

int GaudiKernel.Configurable.Configurable.printHeaderWidth = 100

static

Definition at line 166 of file Configurable.py.

◆ propertyNoValue

GaudiKernel.Configurable.Configurable.propertyNoValue

static

Definition at line 164 of file Configurable.py.

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

GaudiKernel/python/GaudiKernel/Configurable.py

Classes

Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __bool__()

◆ __deepcopy__()

◆ __delattr__()

◆ __getattr__()

◆ __getnewargs__()

◆ __getstate__()

◆ __iadd__()

◆ __iter__()

◆ __len__()

◆ __new__()

◆ __repr__()

◆ __setattr__()

◆ __setstate__()

◆ __setupDefaults()

◆ __setupDlls()

◆ __setupServices()

◆ __str__()

◆ _isInSetDefaults()

◆ _printFooter()

◆ _printHeader()

◆ addTool()

◆ children()

◆ clone()

◆ copyChild()

◆ copyChildAndSetParent()

◆ getAllChildren()

◆ getChildren()

◆ getDefaultProperties()

◆ getDefaultProperty()

◆ getFullJobOptName()

◆ getFullName()

◆ getJobOptName()

◆ getName()

◆ getParent()

◆ getPrintTitle()

◆ getProp()

◆ getProperties()

◆ getPropertiesWithDescription()

◆ getSequence()

◆ getTitleName()

◆ getTools()

◆ getType()

◆ getValuedProperties()

◆ hasParent()

◆ isApplicable()

◆ isPropertySet()

◆ isPublic()

◆ jobOptName()

◆ name()

◆ properties()

◆ remove()

◆ removeAll()

◆ setDefaults()

◆ setParent()

◆ setProp()

◆ setup()

◆ splitName()

Member Data Documentation

◆ __bases__

◆ __children

◆ __class__

◆ __name__

◆ __slots__

◆ __tools

◆ _configurationLocked

◆ init()

◆ bool()

◆ deepcopy()

◆ delattr()

◆ getattr()

◆ getnewargs()

◆ getstate()

◆ iadd()

◆ iter()

◆ len()

◆ new()

◆ repr()

◆ setattr()

◆ setstate()

◆ str()

◆ bases

◆ class

◆ name

◆ slots