Inheritance diagram for GaudiKernel.Configurable.Configurable:

[legend]

Collaboration diagram for GaudiKernel.Configurable.Configurable:

[legend]

Classes
class	DefaultName

Public Member Functions
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)

Static Public Attributes
	propertyNoValue

string	indentUnit = '\| '

int	printHeaderWidth = 100

int	printHeaderPre = 5

dictionary	allConfigurables

dictionary	configurableServices

Static Public Attributes inherited from GaudiKernel.ConfigurableMeta.ConfigurableMeta
def	newclass = type.__new__(self, name, bases, dct)

	configurables

dictionary	properties = {}

	slots = dct.get('__slots__')

list	props = [x for x in slots if x[0] != '_']

	propDict = dct.get('_propertyDocDct')

	docString = propDict and propDict.get(prop)

	default = slots[prop]

	proxy

	bprops = base._properties.copy()

	properties = bprops

Private Member Functions
def	_isInSetDefaults (self)

def	__setupServices (self)

def	__setupDlls (self)

def	__setupDefaults (self)

Static Private Member Functions
def	_printHeader (indentStr, title)

def	_printFooter (indentStr, title)

Private Attributes
	__children

	__tools

	_name

	_inSetDefaults

	_initok

	_setupok

	_unpickling

Static Private Attributes
tuple	__slots__

bool	_configurationLocked = False

def	__nonzero__ = __bool__

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 109 of file Configurable.py.

Constructor & Destructor Documentation

◆ init()

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

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

Definition at line 288 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(
                 "%s is an ABC and can not be instantiated" % str(Configurable))
 
         # 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 = six.get_unbound_function(getattr(klass, meth))
             except AttributeError:
                 raise NotImplementedError(
                     "%s is missing in class %s" % (meth, str(klass)))
 
             # in addition, verify the number of arguments w/o defaults
             nargcount = six.get_function_code(f).co_argcount
             fdefaults = six.get_function_defaults(f)
             ndefaults = fdefaults and len(fdefaults) or 0
             if not nargcount - ndefaults <= nArgs <= nargcount:
                 raise TypeError("%s.%s requires exactly %d arguments" %
                                 (klass, meth, nArgs))
 
         # 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()

def GaudiKernel.Configurable.Configurable.__bool__ ( self )

Definition at line 490 of file Configurable.py.

     def __bool__(self):
         return True
 

◆ deepcopy()

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

Reimplemented in GaudiKernel.Configurable.ConfigurableService, GaudiKernel.Configurable.ConfigurableAlgorithm, and GaudiKernel.Configurable.ConfigurableGeneric.

Definition at line 387 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()

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

Definition at line 465 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()

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

Definition at line 436 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),
                           DataObjectHandleBase):
                 return self._properties[attr].__get__(self)
 
         for c in self.__children:
             if c.getName() == attr:
                 return c
 
         raise AttributeError(
             "'%s' object has no attribute '%s'" % (self.__class__, attr))
 

◆ getnewargs()

def GaudiKernel.Configurable.Configurable.__getnewargs__ ( self )

Definition at line 360 of file Configurable.py.

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

◆ getstate()

def GaudiKernel.Configurable.Configurable.__getstate__ ( self )

Definition at line 347 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()

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

Definition at line 403 of file Configurable.py.

     def __iadd__(self, configs, descr=None):
         if not type(configs) in (list, tuple):
             configs = (configs, )
 
         joname = self.getJobOptName()
 
         for cfg in configs:
             # prevent type mismatches
             if not isinstance(cfg, Configurable):
                 raise TypeError("'%s' is not a Configurable" % str(cfg))
 
             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()

def GaudiKernel.Configurable.Configurable.__iter__ ( self )

Definition at line 383 of file Configurable.py.

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

◆ len()

def GaudiKernel.Configurable.Configurable.__len__ ( self )

Definition at line 380 of file Configurable.py.

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

◆ new()

def 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 142 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 = six.get_function_code(cls.__init__)
         func_defaults = six.get_function_defaults(cls.__init__)
         # 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('no "name" argument while instantiating "%s"' %
                                 cls.__name__)
 
         argname = name
         if name == Configurable.DefaultName:
             if hasattr(cls, 'DefaultedName'):
                 name = cls.DefaultedName
             else:
                 name = cls.getType()
         elif not name or type(name) != str:
             # unnamed, highly specialized user code, etc. ... unacceptable
             raise TypeError(
                 'could not retrieve name from %s.__init__ arguments' %
                 cls.__name__)
 
         # 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 not "_enabled" 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 = "%s/%s" % (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(
                             "Option '%s' was used for %s, but the correct spelling is '%s'"
                             % (n, name, 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()

def GaudiKernel.Configurable.Configurable.__repr__ ( self )

Definition at line 915 of file Configurable.py.

     def __repr__(self):
         return '{0}({1!r})'.format(self.__class__.__name__, self.name())
 

◆ setattr()

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

Reimplemented in GaudiKernel.Configurable.ConfigurableGeneric.

Definition at line 453 of file Configurable.py.

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

◆ setstate()

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

Definition at line 363 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()

def GaudiKernel.Configurable.Configurable.__setupDefaults ( self )

private

Definition at line 891 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()

def GaudiKernel.Configurable.Configurable.__setupDlls ( self )

private

Definition at line 879 of file Configurable.py.

     def __setupDlls(self):
         dlls = self.getDlls()
         if not dlls:
             dlls = []
         elif type(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()

def GaudiKernel.Configurable.Configurable.__setupServices ( self )

private

Definition at line 862 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)
             # 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()

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

Definition at line 918 of file Configurable.py.

     def __str__(self, indent=0, headerLastIndentUnit=indentUnit):
         global log  # to print some info depending on output level
         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 += 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 = indentStr + '|-%-*s' % (nameWidth, p)
                 # add memory address for debugging (not for defaults)
                 if log.isEnabledFor(logging.DEBUG):
                     if v != Configurable.propertyNoValue:
                         address = ' @%11s' % hex(id(v))
                     else:
                         address = 13 * ' '
                     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) or isinstance(
                             vv, GaudiHandleArray):
                         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
                     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 += '  (default: %s)' % (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():

◆ _isInSetDefaults()

def GaudiKernel.Configurable.Configurable._isInSetDefaults ( self )

private

Definition at line 859 of file Configurable.py.

     def _isInSetDefaults(self):
         return self._inSetDefaults
 

◆ _printFooter()

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

staticprivate

Definition at line 907 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 + '\\%s (End of %s) %s' % (preLen * '-', title,
                                                     postLen * '-')
 

◆ _printHeader()

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

staticprivate

Definition at line 899 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 + '/%s %s %s' % (preLen * '*', title, postLen * '*')
 

◆ addTool()

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

Definition at line 836 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(
                 "addTool requires AlgTool configurable. Got %s type" %
                 classname)
         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()

def GaudiKernel.Configurable.Configurable.children ( self )

Definition at line 544 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()

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

Definition at line 789 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 type(value) in [str, list, dict, tuple]:
                     # 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()

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

Reimplemented in GaudiKernel.Configurable.ConfigurableService.

Definition at line 506 of file Configurable.py.

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

◆ copyChildAndSetParent()

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

Definition at line 518 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()

def 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 553 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()

def GaudiKernel.Configurable.Configurable.getChildren ( self )

Definition at line 538 of file Configurable.py.

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

◆ getDefaultProperties()

def GaudiKernel.Configurable.Configurable.getDefaultProperties ( cls )

Definition at line 683 of file Configurable.py.

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

◆ getDefaultProperty()

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

Definition at line 699 of file Configurable.py.

     def getDefaultProperty(cls, name):
         class collector:
             pass
 
         # user provided defaults
         c = collector()
         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()

def GaudiKernel.Configurable.Configurable.getFullJobOptName ( self )

Definition at line 773 of file Configurable.py.

     def getFullJobOptName(self):
         return "%s/%s" % (self.getType(), self.getJobOptName()
                           or self.getName())
 

◆ getFullName()

def GaudiKernel.Configurable.Configurable.getFullName ( self )

Reimplemented in GaudiKernel.Configurable.ConfigurableAlgTool.

Definition at line 770 of file Configurable.py.

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

◆ getJobOptName()

def GaudiKernel.Configurable.Configurable.getJobOptName ( self )

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

Definition at line 757 of file Configurable.py.

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

◆ getName()

def GaudiKernel.Configurable.Configurable.getName ( self )

Definition at line 751 of file Configurable.py.

     def getName(self):
         return self._name
 

◆ getParent()

def GaudiKernel.Configurable.Configurable.getParent ( self )

Reimplemented in GaudiKernel.Configurable.ConfigurableAlgTool.

Definition at line 512 of file Configurable.py.

     def getParent(self):
         return ""
 

◆ getPrintTitle()

def GaudiKernel.Configurable.Configurable.getPrintTitle ( self )

Reimplemented in GaudiKernel.Configurable.ConfigurableAlgTool.

Definition at line 777 of file Configurable.py.

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

◆ getProp()

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

Returns the value of the given property.

Definition at line 720 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()

def GaudiKernel.Configurable.Configurable.getProperties ( self )

Definition at line 632 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()

def GaudiKernel.Configurable.Configurable.getPropertiesWithDescription ( self )

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

Definition at line 642 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()

def GaudiKernel.Configurable.Configurable.getSequence ( self )

Definition at line 592 of file Configurable.py.

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

◆ getTitleName()

def GaudiKernel.Configurable.Configurable.getTitleName ( self )

Definition at line 780 of file Configurable.py.

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

◆ getTools()

def GaudiKernel.Configurable.Configurable.getTools ( self )

Definition at line 541 of file Configurable.py.

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

◆ getType()

def GaudiKernel.Configurable.Configurable.getType ( cls )

Definition at line 748 of file Configurable.py.

     def getType(cls):
         return cls.__name__
 

◆ getValuedProperties()

def GaudiKernel.Configurable.Configurable.getValuedProperties ( self )

Definition at line 652 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 type(value) in [list, 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 type(value) is 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()

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

Reimplemented in GaudiKernel.Configurable.ConfigurableAlgTool.

Definition at line 515 of file Configurable.py.

     def hasParent(self, parent):
         return False
 

◆ isPropertySet()

def 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 733 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, DataObjectHandleBase)):
             value = getattr(self, name)
             return value != default
         return True
 

◆ isPublic()

def GaudiKernel.Configurable.Configurable.isPublic ( self )

Reimplemented in GaudiKernel.Configurable.ConfigurableAlgTool.

Definition at line 760 of file Configurable.py.

     def isPublic(self):
         return True
 

◆ jobOptName()

def GaudiKernel.Configurable.Configurable.jobOptName ( self )

Definition at line 764 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()

def GaudiKernel.Configurable.Configurable.name ( self )

Definition at line 754 of file Configurable.py.

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

◆ properties()

def GaudiKernel.Configurable.Configurable.properties ( self )

Definition at line 679 of file Configurable.py.

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

◆ remove()

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

Definition at line 496 of file Configurable.py.

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

◆ removeAll()

def GaudiKernel.Configurable.Configurable.removeAll ( self )

Definition at line 502 of file Configurable.py.

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

◆ setDefaults()

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

Definition at line 786 of file Configurable.py.

     def setDefaults(cls, handle):
         pass
 

◆ setParent()

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

Reimplemented in GaudiKernel.Configurable.ConfigurableAlgTool.

Definition at line 509 of file Configurable.py.

     def setParent(self, parentName):
         pass
 

◆ setProp()

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

Set the value of a given property

Definition at line 728 of file Configurable.py.

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

◆ setup()

def GaudiKernel.Configurable.Configurable.setup ( self )

Definition at line 598 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("Configurable.__init__ not called in %s override" %
                             self.__class__.__name__)
 
 #      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()

def GaudiKernel.Configurable.Configurable.splitName ( self )

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

◆ __children

GaudiKernel.Configurable.Configurable.__children

private

Definition at line 322 of file Configurable.py.

◆ nonzero

def GaudiKernel.Configurable.Configurable.__nonzero__ = __bool__

staticprivate

Definition at line 494 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 124 of file Configurable.py.

◆ __tools

GaudiKernel.Configurable.Configurable.__tools

private

Definition at line 323 of file Configurable.py.

◆ _configurationLocked

bool GaudiKernel.Configurable.Configurable._configurationLocked = False

staticprivate

Definition at line 140 of file Configurable.py.

◆ _initok

GaudiKernel.Configurable.Configurable._initok

private

Definition at line 338 of file Configurable.py.

◆ _inSetDefaults

GaudiKernel.Configurable.Configurable._inSetDefaults

private

Definition at line 335 of file Configurable.py.

◆ _name

GaudiKernel.Configurable.Configurable._name

private

Definition at line 328 of file Configurable.py.

◆ _setupok

GaudiKernel.Configurable.Configurable._setupok

private

Definition at line 341 of file Configurable.py.

◆ _unpickling

GaudiKernel.Configurable.Configurable._unpickling

private

Definition at line 344 of file Configurable.py.

◆ allConfigurables

dictionary GaudiKernel.Configurable.Configurable.allConfigurables

static

Initial value:

= {

}

Definition at line 134 of file Configurable.py.

◆ configurableServices

dictionary GaudiKernel.Configurable.Configurable.configurableServices

static

Initial value:

= {

}

Definition at line 136 of file Configurable.py.

◆ indentUnit

string GaudiKernel.Configurable.Configurable.indentUnit = '| '

static

Definition at line 120 of file Configurable.py.

◆ printHeaderPre

int GaudiKernel.Configurable.Configurable.printHeaderPre = 5

static

Definition at line 122 of file Configurable.py.

◆ printHeaderWidth

int GaudiKernel.Configurable.Configurable.printHeaderWidth = 100

static

Definition at line 121 of file Configurable.py.

◆ propertyNoValue

GaudiKernel.Configurable.Configurable.propertyNoValue

static

Definition at line 119 of file Configurable.py.

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

GaudiKernel/python/GaudiKernel/Configurable.py

Classes

Public Member Functions

Static Public Attributes

Private Member Functions

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

◆ isPropertySet()

◆ isPublic()

◆ jobOptName()

◆ name()

◆ properties()

◆ remove()

◆ removeAll()

◆ setDefaults()

◆ setParent()

◆ setProp()

◆ setup()

◆ splitName()

Member Data Documentation

◆ __children

◆ __nonzero__

◆ __slots__

◆ __tools

◆ _configurationLocked

◆ _initok

◆ _inSetDefaults

◆ _name

◆ _setupok

◆ _unpickling

◆ allConfigurables

◆ configurableServices

◆ init()

◆ bool()

◆ deepcopy()

◆ delattr()

◆ getattr()

◆ getnewargs()

◆ getstate()

◆ iadd()

◆ iter()

◆ len()

◆ new()

◆ repr()

◆ setattr()

◆ setstate()

◆ str()

◆ nonzero

◆ slots