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)

def	isApplicable (self)

Public Member Functions inherited from GaudiKernel.ConfigurableMeta.ConfigurableMeta
def	__new__ (self, name, bases, dct)

def	__call__ (cls, args, *kwargs)

Static Public Attributes
	propertyNoValue

	indentUnit

	printHeaderWidth

	printHeaderPre

	allConfigurables

	configurableServices

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
	__slots__

	_configurationLocked

	__nonzero__

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 150 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 340 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 548 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 442 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 523 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 493 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):
                 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 415 of file Configurable.py.

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

◆ getstate()

def GaudiKernel.Configurable.Configurable.__getstate__ ( self )

Definition at line 402 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 458 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 438 of file Configurable.py.

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

◆ len()

def GaudiKernel.Configurable.Configurable.__len__ ( self )

Definition at line 435 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 181 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 not isinstance(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 "_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 = "%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 973 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 509 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 418 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 948 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 935 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()

def GaudiKernel.Configurable.Configurable.__setupServices ( self )

private

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

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

Definition at line 976 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, 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
                     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():
         
  
         # 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()

def GaudiKernel.Configurable.Configurable._isInSetDefaults ( self )

private

Definition at line 914 of file Configurable.py.

     def _isInSetDefaults(self):
         return self._inSetDefaults
  

◆ _printFooter()

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

staticprivate

Definition at line 965 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 956 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 891 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 602 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 844 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 564 of file Configurable.py.

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

◆ copyChildAndSetParent()

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

Definition at line 576 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 610 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 596 of file Configurable.py.

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

◆ getDefaultProperties()

def GaudiKernel.Configurable.Configurable.getDefaultProperties ( cls )

Definition at line 740 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 k not 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 756 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 829 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 826 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 812 of file Configurable.py.

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

◆ getName()

def GaudiKernel.Configurable.Configurable.getName ( self )

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

     def getParent(self):
         return ""
  

◆ getPrintTitle()

def GaudiKernel.Configurable.Configurable.getPrintTitle ( self )

Reimplemented in GaudiKernel.Configurable.ConfigurableAlgTool.

Definition at line 832 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 777 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 689 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 699 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 649 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 835 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 599 of file Configurable.py.

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

◆ getType()

def GaudiKernel.Configurable.Configurable.getType ( cls )

Definition at line 803 of file Configurable.py.

     def getType(cls):
         return cls.__name__
  

◆ getValuedProperties()

def GaudiKernel.Configurable.Configurable.getValuedProperties ( self )

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

     def hasParent(self, parent):
         return False
  

◆ isApplicable()

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

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

◆ isPublic()

def GaudiKernel.Configurable.Configurable.isPublic ( self )

Reimplemented in GaudiKernel.Configurable.ConfigurableAlgTool.

Definition at line 815 of file Configurable.py.

     def isPublic(self):
         return True
  

◆ jobOptName()

def GaudiKernel.Configurable.Configurable.jobOptName ( self )

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

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

◆ properties()

def GaudiKernel.Configurable.Configurable.properties ( self )

Definition at line 736 of file Configurable.py.

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

◆ remove()

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

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

def GaudiKernel.Configurable.Configurable.removeAll ( self )

Definition at line 560 of file Configurable.py.

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

◆ setDefaults()

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

Definition at line 841 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 567 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 784 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 655 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 875 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
  

Definition at line 162 of file Configurable.py.

◆ propertyNoValue

GaudiKernel.Configurable.Configurable.propertyNoValue

static

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

◆ isApplicable()

◆ 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

◆ init()

◆ bool()

◆ deepcopy()

◆ delattr()

◆ getattr()

◆ getnewargs()

◆ getstate()

◆ iadd()

◆ iter()

◆ len()

◆ new()

◆ repr()

◆ setattr()

◆ setstate()

◆ str()

◆ nonzero

◆ slots