Inheritance diagram for python.Configurable.Configurable:

Collaboration diagram for python.Configurable.Configurable:

Classes
class	DefaultCollector

class	DefaultName

Public Member Functions
def	__new__ (cls, args, *kwargs)

def	__init__ (self, name=DefaultName)

def	__getstate__ (self)

def	__setstate__ (self, dct)

def	__getnewargs__ (self)

def	__len__ (self)

def	__iter__ (self)

def	__deepcopy__ (self, memo)

def	__iadd__ (self, configs, descr=None, index=None)

def	__getattr__ (self, attr)

def	__delattr__ (self, attr)

def	remove (self, items)

def	removeAll (self)

def	clone (self, newname)

def	copyChild (self, child)

def	setParent (self, parentName)

def	getParent (self)

def	hasParent (self, parent)

def	copyChildAndSetParent (self, cfg, parent)

def	getChildren (self)

def	overwriteChild (self, idx, newChild)

def	getAllChildren (self)

def	getSequence (self)

def	setup (self)

def	lock (self)

def	unlock (self)

def	isLocked (self)

def	isPrinting (self)

def	getProperties (self)

def	getValuedProperties (self)

def	properties (self)

def	getDefaultProperties (cls)

def	getDefaultProperty (cls, name)

def	getType (cls)

def	getName (self)

def	name (self)

def	getJobOptName (self)

def	isPublic (self)

def	getFullName (self)

def	getFullJobOptName (self)

def	getPrintTitle (self)

def	getTitleName (self)

def	setDefaults (cls, handle)

def	__repr__ (self)

def	__str__ (self, indent=0, headerLastIndentUnit=indentUnit)

def	getFlattenedProperties (self)

def	getStrDescriptor (self)

def	__eq__ (self, rhs)

def	__ne__ (self, rhs)

def	__bool__ (self)

def	__new__ (self, name, bases, dct)

def	__call__ (cls, args, *kwargs)

Static Public Attributes
	propertyNoValue

string	indentUnit = '\| '

int	printHeaderWidth = 100

int	printHeaderPre = 5

	allConfigurables = weakref.WeakValueDictionary()

Private Member Functions
def	_isInSetDefaults (self)

def	__setupDlls (self)

def	__setupDefaults (self)

Static Private Member Functions
def	_printHeader (indentStr, title)

def	_printFooter (indentStr, title)

Private Attributes
	__children

	_name

	_flags

Static Private Attributes
int	_fInSetDefaults = 0x01

int	_fIsLocked = 0x02

int	_fIsPrinting = 0x04

int	_fInitOk = 0x08

int	_fSetupOk = 0x10

tuple	__slots__

int	_printOnce = 0

bool	_useGlobalInstances = True

	__hash__ = object.__hash__

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

Constructor & Destructor Documentation

◆ init()

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

Reimplemented in python.Configurable.ConfigurableAuditor, python.Configurable.ConfigurableAlgTool, and python.Configurable.ConfigurableAlgorithm.

Definition at line 203 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))
  
     # for using this Configurable as a (Gaudi) sequence
       self.__children = []
  
     # 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
  
       self._flags = 0
  
     # set to True when collecting defaults, False otherwise
       self._flags &= ~self._fInSetDefaults
  
     # set to True when locked, False otherwise
       self._flags &= ~self._fIsLocked
  
     # set to True when inside __str__ (volatile - not stored on file)
       self._flags &= ~self._fIsPrinting
  
     # for later, in case __init__ itself is overridden
       self._flags |= self._fInitOk
  
     # for debugging purposes (temporary (?))
       self._flags &= ~self._fSetupOk
  

Member Function Documentation

◆ bool()

def python.Configurable.Configurable.__bool__ ( self )

Definition at line 809 of file Configurable.py.

    def __bool__ (self):
       return True
  

◆ call()

def python.ConfigurableMeta.ConfigurableMeta.__call__	(		cls,
		*	args,
		**	kwargs
	)

inherited

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 95 of file ConfigurableMeta.py.

    def __call__( 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."""
  
     # Get the instance: `singleton' logic needs to be in __new__, not here,
     # for compatibililty with pickling.)
       cfg = cls.__new__( cls, *args, **kwargs )
  
     # Initialize the object, if not done already.
       if cfg and ( not hasattr(cfg, '_fInitOk') or not cfg._fInitOk ):
          cls.__init__( cfg, *args, **kwargs )
  
       return cfg

◆ deepcopy()

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

Reimplemented in python.Configurable.ConfigurableService, and python.Configurable.ConfigurableAlgorithm.

Definition at line 285 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 python.Configurable.Configurable.__delattr__	(	self,
		attr
	)

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

◆ eq()

def python.Configurable.Configurable.__eq__	(	self,
		rhs
	)

Definition at line 792 of file Configurable.py.

    def __eq__(self,rhs):
       # Check identity first
       if self is rhs: return True
       # Avoid comparing against None...
       if not rhs: return False
       # Class check
       if not isinstance(rhs,Configurable): return False
       # Type/Name check
       if self.getFullName() != rhs.getFullName(): return False
       # If identical types and names, then go the whole hog and test children
       # Could be sped up by testing property by property...
       return self.getStrDescriptor() == rhs.getStrDescriptor()

◆ getattr()

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

Definition at line 339 of file Configurable.py.

    def __getattr__( self, attr ):  # until ToolProperties exist ...
       if attr[0] == "_":
          return super( Configurable, self ).__getattribute__(attr)
       for c in self.__children:
          if c.getName() == attr:
             return c
  
       raise AttributeError( "'%s' object has no attribute '%s'" % (self.__class__,attr) )
  

◆ getnewargs()

def python.Configurable.Configurable.__getnewargs__ ( self )

Definition at line 274 of file Configurable.py.

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

◆ getstate()

def python.Configurable.Configurable.__getstate__ ( self )

Definition at line 241 of file Configurable.py.

    def __getstate__( self ):
       d = {}
       for name, proxy in self._properties.items():
          try:
             d[ name ] = proxy.__get__( self )
          except AttributeError:
             pass
  
       d[ '_Configurable__children' ] = self.__children
       d[ '_name' ] = self._name
       if hasattr(self, '_jobOptName'):
          d[ '_jobOptName' ] = self.getJobOptName()
       d[ '_fIsLocked' ] = self.isLocked()
  
       return d
  

◆ iadd()

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

Definition at line 301 of file Configurable.py.

    def __iadd__( self, configs, descr = None, index = None ):
       if self.isLocked():
          raise RuntimeError( f"cannot add children to locked configurable {self.getJobOptName()}" )
  
       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.debug( 'attempt to add a duplicate (%s.%s) ... dupe ignored', joname or self.name(), ccjo )
                break
          else:
             if index is None:
                self.__children.append( cc )
             else:
                self.__children.insert( index, 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 python.Configurable.Configurable.__iter__ ( self )

Definition at line 281 of file Configurable.py.

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

◆ len()

def python.Configurable.Configurable.__len__ ( self )

Definition at line 278 of file Configurable.py.

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

◆ ne()

def python.Configurable.Configurable.__ne__	(	self,
		rhs
	)

Definition at line 804 of file Configurable.py.

    def __ne__(self,rhs):
       return (not self.__eq__(rhs))
  

◆ new() [1/2]

def python.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 89 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."""
  
     # 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 cls.__init__.__code__.co_varnames:
        # either positional in args, or default
          index =  list(cls.__init__.__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 = cls.__init__.__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__ )
  
       if name == Configurable.DefaultName:
        # select either conventional name, or the type of the class
          if hasattr( cls, 'DefaultedName' ):
             name = cls.DefaultedName
          else:
             name = cls.getType()
       elif not name or type(name) is not str:
        # unnamed, highly specialized user code, etc. ... unacceptable
          raise TypeError( 'could not retrieve name from %s.__init__ arguments' % cls.__name__ )
  
     # close backdoor access to otherwise private subalgs/tools
       if 0 <= name.find( '.' ):
          raise NameError( '"%s": Gaudi name indexing with "." to private configurables not '
                           'allowed, as it leads to uncheckable backdoors' % name )
  
       if 0 <= name.find( '/' ):
          raise NameError( '"%s": type separator "/" no allowed in component name, '
                           'typename is derived from configurable instead' % name )
  
       if cls._useGlobalInstances:
          # ordinary recycle case
          try:
             conf = cls.configurables[ name ]
  
           # initialize additional properties, if any
             for n,v in kwargs.items():
                try:
                   setattr( conf, n, v )
                except AttributeError as originalAttributeError:
  
                 # now for a completely different can of worms ...
                   acceptableKeyWord = False
  
                 # little helper
                   def flat( classtree ):
                      if isinstance( classtree, list ) or isinstance( classtree, tuple ):
                         return [ j for i in classtree for j in flat( i ) ]
                      else:
                         return [ classtree ]
  
                 # the following attempts to figure out if the missing attribute
                 # is in fact an acceptable formal function argument to __init__,
                   import inspect
                   allclasses = flat( inspect.getclasstree( [ conf.__class__ ] ) )
                   for confklass in allclasses:
                      try:
                       # the following may result in the same init tried several
                       # times, but we shouldn't be in this loop too often anyway
                         if n in confklass.__init__.__code__.co_varnames:
                            acceptableKeyWord = True
                            break
                      except AttributeError:
                         pass
  
                 # raising here will break the usage of keywords in __init__, but
                 # there don't appear to be such cases in ATLAS yet ...
                   if not acceptableKeyWord:
                      raise originalAttributeError
             return conf
          except KeyError:
             pass
       else:
          #Run 3 style config
          #Uncomment this line to verify that RecExCommon doesn't use that
          #print "Run 3 style config" 
          pass #end if not new configuration approach
     # still here: create a new instance ...
       conf = object.__new__( cls )
  
     # ... python convention says to silently return, if __new__ fails ...
       if conf is None:
          return
  
     # ... initialize it
       cls.__init__( conf, *args, **kwargs )
  
     # update normal, per-class cache
       if cls._useGlobalInstances:
          cls.configurables[ name ] = conf
  
     # update generics super-cache
          if name in cls.allConfigurables  and conf.getType() != cls.allConfigurables[ name ].getType():
             raise TypeError( 'attempt to redefine type of "%s" (was: %s, new: %s)' %
                              (name,cls.allConfigurables[ name ].getType(), conf.getType()) )
          cls.allConfigurables[ name ] = conf
  
       return conf
  

◆ new() [2/2]

def python.ConfigurableMeta.ConfigurableMeta.__new__	(	self,
		name,
		bases,
		dct
	)

inherited

Definition at line 27 of file ConfigurableMeta.py.

    def __new__( self, name, bases, dct ):
     # enforce use of classmethod for getType() and setDefaults()
       if 'getType' in dct and not isinstance( dct[ 'getType' ], classmethod ):
          dct[ 'getType' ] = classmethod( dct[ 'getType' ] )
  
       if 'setDefaults' in dct and not isinstance( dct[ 'setDefaults' ], classmethod ):
          dct[ 'setDefaults' ] = classmethod( dct[ 'setDefaults' ] )
  
     # collect what are properties (basically, any public name; C++ variables
     # shouldn't start with an '_' because of portability constraints, hence
     # it is safe to assume that any such vars are python private ones)
       newclass = type.__new__( self, name, bases, dct )
  
       if 'AthenaCommon' not in newclass.__module__:
        # check for required methods and the right number of arguments
        # meths = { 'getServices'   : 1,    # retrieve list of services to configure
          meths = { 'getDlls'       : 1,    # provide list of Dlls to load
                    'getGaudiType'  : 1,    # return string describing component class
                    'getHandle'     : 1,    # provide access to C++ side component instance
                    'getType'       : 1 }   # return the type of the actual C++ component
  
          for meth, nArgs in meths.items():
             try:
                f = getattr( newclass, meth )
             except AttributeError:
                raise NotImplementedError("%s is missing in class %s" % (meth,str(newclass)))
  
           # in addition, verify the number of arguments w/o defaults
             nargcount = f.__code__.co_argcount
             dflts = f.__defaults__
             ndefaults = dflts and len(dflts) or 0
             if not nargcount - ndefaults <= nArgs <= nargcount:
                raise TypeError("%s.%s requires exactly %d arguments" % (newclass,meth,nArgs))
  
     # cache references of instances by name for duplicate removal
       newclass.configurables = weakref.WeakValueDictionary()
  
     # loop over slots, which are all assumed to be properties, create proxies, defaults
       properties = {}
       slots = dct.get( '__slots__' )
       if slots:
          props = [ x for x in slots if x[0] != '_' ]
          propDict = dct.get('_propertyDocDct')
          for prop in props:
             docString = propDict and propDict.get(prop)
             if type(slots) is dict:
                default = slots[prop]
             else:
                default = None
             proxy = PropertyProxy.PropertyProxyFactory(
                getattr( newclass, prop ), docString, default )
  
             properties[ prop ] = proxy
             setattr( newclass, prop, proxy )
  
     # complete set of properties includes those from base classes
       for base in bases:
          try:
             bprops = base._properties.copy()
             bprops.update( properties )
             properties = bprops
          except AttributeError:
             pass
  
       newclass._properties = properties
  
       return newclass
  

◆ repr()

def python.Configurable.Configurable.__repr__ ( self )

Definition at line 646 of file Configurable.py.

    def __repr__( self ):
       return '<%s at %s>' % (self.getFullJobOptName(),hex(id(self)))
  

◆ setstate()

def python.Configurable.Configurable.__setstate__	(	self,
		dct
	)

Definition at line 257 of file Configurable.py.

    def __setstate__( self, dct ):
     # flags are set to neutral, not from pickle except for lockedness
       self._flags = 0
       self._flags |= self._fInitOk
       self._flags &= ~self._fInSetDefaults
       if '_fIsLocked' in dct: 
          if dct[ '_fIsLocked' ]:
             self._flags &= self._fIsLocked
          else:
             self._flags &= ~self._fIsLocked
          del dct['_fIsLocked']
       self._flags &= ~self._fIsPrinting
       for (n, v) in dct.items():
          setattr( self, n, v )
  
       return
  

◆ __setupDefaults()

def python.Configurable.Configurable.__setupDefaults ( self )

private

Definition at line 625 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._flags |= self._fInSetDefaults
       self.setDefaults( self )
       self._flags &= ~self._fInSetDefaults
  

◆ __setupDlls()

def python.Configurable.Configurable.__setupDlls ( self )

private

Definition at line 614 of file Configurable.py.

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

◆ str()

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

Definition at line 649 of file Configurable.py.

    def __str__( self, indent = 0, headerLastIndentUnit=indentUnit ):
       global log  # to print some info depending on output level
  
       def _sorted_repr_set(value):
          """Helper to print sorted set representation"""
          return "{" + repr(sorted(value))[1:-1] + "}" if value else "set()"
  
       indentStr = indent*Configurable.indentUnit
     # print header
       title = self.getPrintTitle()
  
     # if run under WARNING and hight only, stick with title
       if logging.WARNING <= log.level:
          if not Configurable._printOnce:
             Configurable._printOnce = 1
             return "Reduced Configurable printout; change log level for more details, e.g.:\n   import AthenaCommon.Configurable as Configurable\n   Configurable.log.setLevel( INFO )\n" + title
          else:
             return title
  
     # avoid auto-setting private AlgTools while doing printout
       self._flags |= self._fIsPrinting
  
     # 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))
          propNames = sorted(props.keys())
          for p in propNames:
             v = props[p]
           # 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 not isinstance(v,MutableSequence) and v == Configurable.propertyNoValue:
                # show default value as value, and no extra 'default'
                strVal = repr(default)
                strDef = None
             else:
                # convert configurable to handle
                if isinstance(v,Configurable):
                   vv = v.getGaudiHandle()
                else:
                   vv = v
                if isinstance(vv,(GaudiHandles.GaudiHandle,
                                  GaudiHandles.GaudiHandleArray,
                                  DataHandle.DataHandle)):
                   strVal = repr(vv)
                   strDef = repr(default.toStringProperty())
                   if strDef == repr(vv.toStringProperty()):
                      strDef = None
                elif isinstance(vv, set):
                   strVal = _sorted_repr_set(vv)
                   strDef = _sorted_repr_set(default)
                else:
                   strVal = repr(vv)
                   strDef = repr(default)
           # add the value
             line = prefix + ' = ' + strVal
           # add default if present
             if strDef is not None:
                # put default on new line if too big
                if len(line) + len(strDef) > Configurable.printHeaderWidth:
                   line += os.linesep + indentStr + '| ' + (len(prefix)-len(indentStr)-3)*' '
                line += '  (default: %s)' % (strDef,)
           # add the line to the total string
             rep += line + os.linesep
  
     # print configurables + their properties, or loop over sequence
       childNotToSort = []
       childToSort    = []
       for c in self.getAllChildren():
          if isinstance(c, ConfigurableAlgorithm): childNotToSort.append(c)
          else:                                    childToSort.append(c)
     # sort the non-algs
       childToSort.sort(key=lambda x : x.getName())
       for cfg in childToSort + childNotToSort:
          rep += cfg.__str__( indent + 1, '|=' ) + os.linesep
  
     # print line to easily see end-of-configurable. Note: No linesep!
       rep += Configurable._printFooter( indentStr, title )
  
       self._flags &= ~self._fIsPrinting
       return rep
  
     # hash method for set/dict operations
     # first attempt, assuming need to recurse into child properties
     # if too much overhead, could attempt to cache with python
     # properties, but hard to propagate changes upwards to parents
  

◆ _isInSetDefaults()

def python.Configurable.Configurable._isInSetDefaults ( self )

private

Definition at line 611 of file Configurable.py.

    def _isInSetDefaults( self ):
       return self._flags & self._fInSetDefaults
  

◆ _printFooter()

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

staticprivate

Definition at line 640 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 python.Configurable.Configurable._printHeader	(	indentStr,
		title
	)

staticprivate

Definition at line 633 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*'*')
  

◆ clone()

def python.Configurable.Configurable.clone	(	self,
		newname
	)

Definition at line 380 of file Configurable.py.

    def clone( self, newname ):
       if newname == self.getName():
          log.error( 'not cloning %s, because new name given is same as old name', self.getName() )
          return None
  
       return self.__class__( newname, **self.getValuedProperties() )
  

◆ copyChild()

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

Reimplemented in python.Configurable.ConfigurableService.

Definition at line 388 of file Configurable.py.

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

◆ copyChildAndSetParent()

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

Definition at line 400 of file Configurable.py.

    def copyChildAndSetParent(self,cfg,parent):
       cc = self.copyChild( cfg )
  
       if hasattr( cc, 'setParent' ) and parent:
          cc.setParent( parent )
  
       return cc
  

◆ getAllChildren()

def python.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 414 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,GaudiHandles.GaudiHandle):
                try:
                   conf = c.configurable
                except AttributeError:
                   pass
                else:
                   if not conf.isPublic():
                      childs.append(conf)
             elif isinstance(c,GaudiHandles.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 python.Configurable.Configurable.getChildren ( self )

Definition at line 408 of file Configurable.py.

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

◆ getDefaultProperties()

def python.Configurable.Configurable.getDefaultProperties ( cls )

Definition at line 544 of file Configurable.py.

    def getDefaultProperties( cls ):
  
     # user provided defaults
       c = Configurable.DefaultCollector()
       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 python.Configurable.Configurable.getDefaultProperty	(	cls,
		name
	)

Definition at line 558 of file Configurable.py.

    def getDefaultProperty( cls, name ):
  
     # user provided defaults
       c = Configurable.DefaultCollector()
       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
  

◆ getFlattenedProperties()

def python.Configurable.Configurable.getFlattenedProperties ( self )

Definition at line 759 of file Configurable.py.

    def getFlattenedProperties(self):
       self._flags |= self._fIsPrinting
       properties = self.getValuedProperties()
       propstr = ""
       for key,val in sorted(properties.items()):
          if isinstance(val,GaudiHandles.PublicToolHandle) or isinstance(val,GaudiHandles.PrivateToolHandle):
             propstr += val.getFullName()
          elif isinstance(val,Configurable):
             propstr += "({0}:{1})".format(key,val.getFlattenedProperties())
          elif isinstance(val,GaudiHandles.PublicToolHandleArray) or isinstance(val,GaudiHandles.PrivateToolHandleArray):
             for th in val:
                # Handle ToolHandles that have just been set as strings(?)
                if isinstance(th,Configurable):
                   propstr += "({0}:{1}".format(th.getFullName(), th.getFlattenedProperties())
                else:
                   propstr += th.getFullName()
          else:
             propstr += "({0}:{1})".format(key,str(val))
       self._flags &= ~self._fIsPrinting
       return propstr
  

◆ getFullJobOptName()

def python.Configurable.Configurable.getFullJobOptName ( self )

Definition at line 596 of file Configurable.py.

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

◆ getFullName()

def python.Configurable.Configurable.getFullName ( self )

Definition at line 593 of file Configurable.py.

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

◆ getJobOptName()

def python.Configurable.Configurable.getJobOptName ( self )

Reimplemented in python.Configurable.ConfigurableAuditor, python.Configurable.ConfigurableAlgTool, and python.Configurable.ConfigurableAlgorithm.

Definition at line 586 of file Configurable.py.

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

◆ getName()

def python.Configurable.Configurable.getName ( self )

Definition at line 580 of file Configurable.py.

    def getName( self ):
       return self._name
  

◆ getParent()

def python.Configurable.Configurable.getParent ( self )

Reimplemented in python.Configurable.ConfigurableAlgTool.

Definition at line 394 of file Configurable.py.

    def getParent( self ):
       return ""
  

◆ getPrintTitle()

def python.Configurable.Configurable.getPrintTitle ( self )

Reimplemented in python.Configurable.ConfigurableAlgTool.

Definition at line 599 of file Configurable.py.

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

◆ getProperties()

def python.Configurable.Configurable.getProperties ( self )

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

◆ getSequence()

def python.Configurable.Configurable.getSequence ( self )

Definition at line 453 of file Configurable.py.

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

◆ getStrDescriptor()

def python.Configurable.Configurable.getStrDescriptor ( self )

Definition at line 780 of file Configurable.py.

    def getStrDescriptor(self):
  
       descr = ""
       if hasattr( self,"_name" ):
          propstr = self.getFlattenedProperties()
          descr = (self.getFullName(), propstr)
       else: # Not yet initialised?
          descr = self.getType()
       
       return descr
  

◆ getTitleName()

def python.Configurable.Configurable.getTitleName ( self )

Definition at line 602 of file Configurable.py.

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

◆ getType()

def python.Configurable.Configurable.getType ( cls )

Reimplemented in python.AppMgr.AthServiceManager.

Definition at line 577 of file Configurable.py.

    def getType( cls ):
       return cls.__name__
  

◆ getValuedProperties()

def python.Configurable.Configurable.getValuedProperties ( self )

Definition at line 525 of file Configurable.py.

    def getValuedProperties( self ):
       props = {}
       for name, proxy in self._properties.items():
          try:
             value = proxy.__get__( self )
             if hasattr(value, 'getFullName') :
                value = value.getFullName()
             elif type(value) is list and len(value) > 0 and hasattr(value[0], 'getFullName'):
                value = [ i.getFullName() for i in value ]
             props[ name ] = value               
          except AttributeError:
             pass
  
       return props
  

◆ hasParent()

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

Reimplemented in python.Configurable.ConfigurableAlgTool.

Definition at line 397 of file Configurable.py.

    def hasParent( self, parent ):
       return False
  

◆ isLocked()

def python.Configurable.Configurable.isLocked ( self )

Definition at line 507 of file Configurable.py.

    def isLocked( self ):
     # check whether this configurable is currently locked
       return self._flags & self._fIsLocked
  

◆ isPrinting()

def python.Configurable.Configurable.isPrinting ( self )

Definition at line 511 of file Configurable.py.

    def isPrinting( self ):
     # check whether this configurable is currently being printed (see PropertyProxy.py)
       return self._flags & self._fIsPrinting
  

◆ isPublic()

def python.Configurable.Configurable.isPublic ( self )

Reimplemented in python.Configurable.ConfigurableAlgTool.

Definition at line 589 of file Configurable.py.

    def isPublic( self ):
       return True
  

◆ lock()

def python.Configurable.Configurable.lock ( self )

Definition at line 487 of file Configurable.py.

    def lock( self ):
     # prevent any further changes, unless unlocked
       self._flags |= self._fIsLocked
  
     # same for any of its private ToolHandle properties
       for k, v in self.getProperties().items():
          if isinstance( v, Configurable ):
             v.lock()
  
     # leave children alone ... most likely are public (and can't check otherwise)
  

◆ name()

def python.Configurable.Configurable.name ( self )

Definition at line 583 of file Configurable.py.

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

◆ overwriteChild()

def python.Configurable.Configurable.overwriteChild	(	self,
		idx,
		newChild
	)

Definition at line 411 of file Configurable.py.

    def overwriteChild( self, idx, newChild ):
       self.__children[idx] = newChild
  

◆ properties()

def python.Configurable.Configurable.properties ( self )

Definition at line 540 of file Configurable.py.

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

◆ remove()

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

Definition at line 370 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 python.Configurable.Configurable.removeAll ( self )

Definition at line 376 of file Configurable.py.

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

◆ setDefaults()

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

Definition at line 608 of file Configurable.py.

    def setDefaults( cls, handle ):
       pass
  

◆ setParent()

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

Reimplemented in python.Configurable.ConfigurableAlgTool.

Definition at line 391 of file Configurable.py.

    def setParent( self, parentName ):
       pass
  

◆ setup()

def python.Configurable.Configurable.setup ( self )

Reimplemented in python.AppMgr.AthServiceManager.

Definition at line 459 of file Configurable.py.

    def setup( self ):
     # make sure base class init has been called
       if not hasattr(self,'_fInitOk') or not self._fInitOk:
        # could check more, but this is the only explanation
          raise TypeError("Configurable.__init__ not called in %s override" % self.__class__.__name__)
  
     # setup self: this collects all values on the python side
       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._flags |= self._fSetupOk
  

◆ unlock()

def python.Configurable.Configurable.unlock ( self )

Definition at line 498 of file Configurable.py.

    def unlock( self ):
     # allow again changes to be made
       import sys, traceback
       stack = traceback.extract_stack( sys._getframe(1), 1 )
       log.warning( 'unlock() called on configurable "%s" in %s', self.getJobOptName(), stack[0][0] )
       self._flags &= ~self._fIsLocked
  
     # note that unlock() does not unlock the children; do that individually
  

Member Data Documentation

◆ __children

python.Configurable.Configurable.__children

private

Definition at line 212 of file Configurable.py.

◆ hash

python.Configurable.Configurable.__hash__ = object.__hash__

staticprivate

Definition at line 807 of file Configurable.py.

◆ slots

tuple python.Configurable.Configurable.__slots__

staticprivate

Initial value:

=  (
      '__weakref__',          # required for dealing with weak references
      '__children',           # controlled components, e.g. private AlgTools
      '_name',                # the (unqualified) component name
      '_flags',               # see list of flags above
   )

Definition at line 72 of file Configurable.py.

◆ _fInitOk

int python.Configurable.Configurable._fInitOk = 0x08

staticprivate

Definition at line 69 of file Configurable.py.

◆ _fInSetDefaults

int python.Configurable.Configurable._fInSetDefaults = 0x01

staticprivate

Definition at line 66 of file Configurable.py.

◆ _fIsLocked

int python.Configurable.Configurable._fIsLocked = 0x02

staticprivate

Definition at line 67 of file Configurable.py.

◆ _fIsPrinting

int python.Configurable.Configurable._fIsPrinting = 0x04

staticprivate

Definition at line 68 of file Configurable.py.

◆ _flags

python.Configurable.Configurable._flags

private

Definition at line 223 of file Configurable.py.

◆ _fSetupOk

int python.Configurable.Configurable._fSetupOk = 0x10

staticprivate

Definition at line 70 of file Configurable.py.

◆ _name

python.Configurable.Configurable._name

private

Definition at line 217 of file Configurable.py.

◆ _printOnce

int python.Configurable.Configurable._printOnce = 0

staticprivate

Definition at line 83 of file Configurable.py.

◆ _useGlobalInstances

bool python.Configurable.Configurable._useGlobalInstances = True

staticprivate

Definition at line 87 of file Configurable.py.

◆ allConfigurables

python.Configurable.Configurable.allConfigurables = weakref.WeakValueDictionary()

static

Definition at line 79 of file Configurable.py.

◆ indentUnit

string python.Configurable.Configurable.indentUnit = '| '

static

Definition at line 62 of file Configurable.py.

◆ printHeaderPre

int python.Configurable.Configurable.printHeaderPre = 5

static

Definition at line 64 of file Configurable.py.

◆ printHeaderWidth

int python.Configurable.Configurable.printHeaderWidth = 100

static

Definition at line 63 of file Configurable.py.

◆ propertyNoValue

python.Configurable.Configurable.propertyNoValue

static

Definition at line 61 of file Configurable.py.

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

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

◆ __call__()

◆ __deepcopy__()

◆ __delattr__()

◆ __eq__()

◆ __getattr__()

◆ __getnewargs__()

◆ __getstate__()

◆ __iadd__()

◆ __iter__()

◆ __len__()

◆ __ne__()

◆ __new__() [1/2]

◆ __new__() [2/2]

◆ __repr__()

◆ __setstate__()

◆ __setupDefaults()

◆ __setupDlls()

◆ __str__()

◆ _isInSetDefaults()

◆ _printFooter()

◆ _printHeader()

◆ clone()

◆ copyChild()

◆ copyChildAndSetParent()

◆ getAllChildren()

◆ getChildren()

◆ getDefaultProperties()

◆ getDefaultProperty()

◆ getFlattenedProperties()

◆ getFullJobOptName()

◆ getFullName()

◆ getJobOptName()

◆ getName()

◆ getParent()

◆ getPrintTitle()

◆ getProperties()

◆ getSequence()

◆ getStrDescriptor()

◆ getTitleName()

◆ getType()

◆ getValuedProperties()

◆ hasParent()

◆ isLocked()

◆ isPrinting()

◆ isPublic()

◆ lock()

◆ name()

◆ overwriteChild()

◆ properties()

◆ remove()

◆ removeAll()

◆ setDefaults()

◆ setParent()

◆ setup()

◆ unlock()

Member Data Documentation

◆ __children

◆ __hash__

◆ __slots__

◆ _fInitOk

◆ _fInSetDefaults

◆ _fIsLocked

◆ _fIsPrinting

◆ _flags

◆ _fSetupOk

◆ _name

◆ _printOnce

◆ _useGlobalInstances

◆ init()

◆ bool()

◆ call()

◆ deepcopy()

◆ delattr()

◆ eq()

◆ getattr()

◆ getnewargs()

◆ getstate()

◆ iadd()

◆ iter()

◆ len()

◆ ne()

◆ new() [1/2]

◆ new() [2/2]

◆ repr()

◆ setstate()

◆ str()

◆ hash

◆ slots