Inheritance diagram for python.ComponentAccumulator.ComponentAccumulator:

Collaboration diagram for python.ComponentAccumulator.ComponentAccumulator:

Public Member Functions
	__init__ (self, sequence='AthAlgSeq')
	setAsTopLevel (self)
	empty (self)
	__del__ (self)
	__getstate__ (self)
	__setstate__ (self, state)
	printCondAlgs (self, summariseProps=False, onlyComponents=[], printDefaults=False)
	printConfig (self, withDetails=False, summariseProps=False, onlyComponents=[], printDefaults=False, printSequenceTreeOnly=False, prefix=None)
	getIO (self)
	addSequence (self, newseq, primary=False, parentName=None)
	getSequence (self, sequenceName=None)
	setPrivateTools (self, privTool)
	popPrivateTools (self, quiet=False)
	popToolsAndMerge (self, other)
	getCurrentPerfmonDomain (self)
	flagPerfmonDomain (self, name)
	getInvertedPerfmonDomains (self)
	getAlgPerfmonDomain (self, name)
	addAlgToPerfmonDomains (self, name, domain, overwrite=False)
	printPerfmonDomains (self)
	addEventAlgo (self, algorithms, sequenceName=None, primary=False, domain=None)
	getEventAlgo (self, name=None)
	getEventAlgos (self, seqName=None)
	addCondAlgo (self, algo, primary=False, domain=None)
	getCondAlgos (self)
	getCondAlgo (self, name)
	addService (self, newSvc, primary=False, create=False)
	addAuditor (self, auditor)
	addPublicTool (self, newTool, primary=False)
	getPrimary (self)
	getPrimaryAndMerge (self, other)
	getPublicTools (self)
	getPublicTool (self, name=None)
	getServices (self)
	getService (self, name=None)
	getAuditor (self, name)
	dropEventAlgo (self, name, sequence="AthAlgSeq")
	popEventAlgo (self, name, sequence="AthAlgSeq")
	dropCondAlgo (self, name)
	dropService (self, name)
	dropPublicTool (self, name)
	dropAuditor (self, name)
	getAppProps (self)
	setAppProperty (self, key, value, overwrite=False)
	setDebugStage (self, stage)
	merge (self, other, sequenceName=None)
	wasMerged (self)
	store (self, outfile, withDefaultHandles=False)
	createApp (self)
	gatherProps (self)
	run (self, maxEvents=None)
	foreach_component (self, path)

Public Attributes
str	interactive = ""

Static Public Attributes
str	debugMode = ""

Protected Member Functions
	_inspect (self)
	_cleanup (self)
	_cacheEvict (self)
	_allComponents (self)

Protected Attributes
	_msg = logging.getLogger('ComponentAccumulator')
	_sequence = sequence
list	_allSequences = [self._sequence]
dict	_algorithms = {}
list	_conditionsAlgs = []
list	_services = []
list	_servicesToCreate = []
list	_auditors = []
	_privateTools = None
	_primaryComp = None
	_currentDomain = None
dict	_domainsRegistry = {}
	_theAppProps = dict()
list	_publicTools = []
bool	_wasMerged = False
bool	_isMergable = True
str	_lastAddedComponent = "Unknown"
str	_creationCallStack = Context.hint if "trackCA" not in ComponentAccumulator.debugMode else shortCallStack()
	_componentsContext = dict()
	_debugStage = DbgStage()

Static Protected Attributes
bool	_checkUnmerged = True

Private Member Functions
	__getOne (self, allcomps, name=None, typename="???")
	__verifyFinalSequencesStructure (self)

Detailed Description

Definition at line 73 of file ComponentAccumulator.py.

Constructor & Destructor Documentation

◆ init()

python.ComponentAccumulator.ComponentAccumulator.__init__	(		self,
			sequence = 'AthAlgSeq' )

Definition at line 80 of file ComponentAccumulator.py.

    def __init__(self,sequence='AthAlgSeq'):
        # Ensure that we are not operating in the legacy Athena Configurable mode
        # where only a single global instance exists
        if not isComponentAccumulatorCfg():
            raise ConfigurationError(
                """
                ComponentAccumulator initialised with legacy (global) Configurable behavior!
                CA Deduplication is impossible in this mode.
                Create the CA using the AthenaCommon.Configurable.ConfigurableCABehavior context manager.
                """
            )
        self._msg=logging.getLogger('ComponentAccumulator')
        if isinstance(sequence, str):
            kwargs={'IgnoreFilterPassed' : True,
                    'StopOverride'       : True }
            if sequence == 'AthAlgSeq' :
                kwargs.setdefault('ProcessDynamicDataDependencies',True)
                kwargs.setdefault('ExtraDataForDynamicConsumers',[])
 
            # (Nested) default sequence of event processing algorithms per sequence + their private tools
            sequence = CompFactory.AthSequencer(sequence, **kwargs)
 
        self._sequence = sequence
        self._allSequences = [self._sequence]
        self._algorithms = {}            #Dictionary of algorithm instances keyed by name
        self._conditionsAlgs = []        #Unordered list of conditions algorithms + their private tools
        self._services = []              #List of service, not yet sure if the order matters here in the MT age
        self._servicesToCreate = []
        self._auditors = []              #List of auditors
        self._privateTools = None        #A placeholder to carry a private tool(s) not yet attached to its parent
        self._primaryComp = None         #A placeholder to designate the primary service
        self._currentDomain = None       #Currently marked PerfMon domain
        self._domainsRegistry = {}       #PerfMon domains registry
 
        self._theAppProps = dict()        #Properties of the ApplicationMgr
 
        #Backward compatibility hack: Allow also public tools:
        self._publicTools = []
 
        #To check if this accumulator was merged:
        self._wasMerged = False
        self._isMergable = True
        self._lastAddedComponent = "Unknown"
        self._creationCallStack = Context.hint if "trackCA" not in ComponentAccumulator.debugMode else shortCallStack()
        self._componentsContext = dict()
        self._debugStage = DbgStage()
        self.interactive = ""
 

◆ del()

python.ComponentAccumulator.ComponentAccumulator.__del__ ( self )

Definition at line 171 of file ComponentAccumulator.py.

    def __del__(self):
         if self._checkUnmerged and not getattr(self,'_wasMerged',True) and not self.empty():
             log = logging.getLogger("ComponentAccumulator")
             log.error("ComponentAccumulator was never merged. %s\n", self._inspect())
             import traceback
             traceback.print_stack()
         if getattr(self,'_privateTools',None) is not None:
             log = logging.getLogger("ComponentAccumulator")
             log.error("Deleting a ComponentAccumulator with dangling private tool(s): %s", 
                        " ".join([t.name for t in self._privateTools]) if isinstance(self._privateTools, Sequence) else self._privateTools.name)
 

Member Function Documentation

◆ __getOne()

python.ComponentAccumulator.ComponentAccumulator.__getOne	(	self,
		allcomps,
		name = None,
		typename = "???" )

private

Definition at line 654 of file ComponentAccumulator.py.

    def __getOne(self, allcomps, name=None, typename="???"):
        selcomps = allcomps if name is None else [ t for t in allcomps if t.name == name ]
        if len( selcomps ) == 0:
            raise ConfigurationError(f"Requested component of name {name} but is missing" )
 
        if len( selcomps ) == 1:
            return selcomps[0]
        nmstr = f'with name {name} ' if name else ''
        raise ConfigurationError("Number of {} available {}{} which is != 1 expected by this API".format(typename, nmstr, len(selcomps)) )
 

◆ getstate()

python.ComponentAccumulator.ComponentAccumulator.__getstate__ ( self )

Definition at line 187 of file ComponentAccumulator.py.

    def __getstate__(self):
        state = self.__dict__.copy()
        # Remove the unpicklable entries.
        del state['_msg']
        return state
 

◆ setstate()

python.ComponentAccumulator.ComponentAccumulator.__setstate__	(		self,
			state )

Definition at line 193 of file ComponentAccumulator.py.

    def __setstate__(self,state):
        self.__dict__.update(state)
        #Re-enstate logger
        self._msg=logging.getLogger('ComponentAccumulator')
 
 

◆ __verifyFinalSequencesStructure()

python.ComponentAccumulator.ComponentAccumulator.__verifyFinalSequencesStructure ( self )

private

Definition at line 928 of file ComponentAccumulator.py.

    def __verifyFinalSequencesStructure(self):
        if len(self._allSequences) != 1:
            raiseWithCurrentContext(ConfigurationError('It is not allowed for the storable CA to have more than one top sequence, now it has: {}'
                                         .format(','.join([ s.name for s in self._allSequences]))))
 
 

◆ _allComponents()

python.ComponentAccumulator.ComponentAccumulator._allComponents ( self )

protected

returns iterable over all components

Definition at line 941 of file ComponentAccumulator.py.

    def _allComponents(self):
        """ returns iterable over all components """
        import itertools
        return itertools.chain(self._publicTools,
                               self._privateTools if self._privateTools else [],
                               self._algorithms.values(),
                               self._conditionsAlgs)
 
 

◆ _cacheEvict()

python.ComponentAccumulator.ComponentAccumulator._cacheEvict ( self )

protected

Called by AccumulatorCache when deleting item from cache

Definition at line 182 of file ComponentAccumulator.py.

    def _cacheEvict(self):
        """Called by AccumulatorCache when deleting item from cache"""
        self.popPrivateTools(quiet=True)
        self.wasMerged()
 

◆ _cleanup()

python.ComponentAccumulator.ComponentAccumulator._cleanup ( self )

protected

Definition at line 149 of file ComponentAccumulator.py.

    def _cleanup(self): 
        # Delete internal data structures, to be called after all properties are transferred to the C++ application
        del self._sequence
        del self._allSequences
        del self._algorithms
        del self._conditionsAlgs
        del self._services
        del self._publicTools
        del self._auditors
 
        # Clear all AccumulatorCaches
        from AthenaConfiguration.AccumulatorCache import AccumulatorDecorator
        AccumulatorDecorator.clearCache()
 
        # Run garbage collector
        import gc
        gc.collect()
 

◆ _inspect()

python.ComponentAccumulator.ComponentAccumulator._inspect ( self )

protected

Definition at line 131 of file ComponentAccumulator.py.

    def _inspect(self): #Create a string some basic info about this CA, useful for debugging
        summary = "This CA contains {0} service(s), {1} conditions algorithm(s), {2} event algorithm(s) and {3} public tool(s):\n"\
            .format(len(self._services),len(self._conditionsAlgs),len(self._algorithms),len(self._publicTools))
 
        if self._privateTools:
            if isinstance(self._privateTools, list):
                summary += "  Private AlgTool: " + self._privateTools[-1].getFullJobOptName() + "\n"
            else:
                summary += "  Private AlgTool: " + self._privateTools.getFullJobOptName() + "\n"
 
        if self._primaryComp:
            summary += "  Primary Component: " + self._primaryComp.getFullJobOptName() + "\n"      
 
        summary += "  Sequence(s): " + ", ".join([s.name+(" (main)" if s == self._sequence else "") for s in self._allSequences]) + "\n"
        summary += "  Last component added: " + self._lastAddedComponent+"\n"
        summary += "  Created by: " + self._creationCallStack
        return summary
 

◆ addAlgToPerfmonDomains()

python.ComponentAccumulator.ComponentAccumulator.addAlgToPerfmonDomains	(	self,
		name,
		domain,
		overwrite = False )

Add the algorithm to the domains registry.

Definition at line 436 of file ComponentAccumulator.py.

    def addAlgToPerfmonDomains(self, name, domain, overwrite=False):
        """ Add the algorithm to the domains registry. """
        if name not in self._domainsRegistry:
            if domain:
                self._domainsRegistry[name] = domain
                self._msg.debug(f"Added algorithm {name} to the PerfMon domain {domain}")
        else:
            if overwrite and domain:
                self._msg.info(f"Reassigned algorithm {name} "
                               f"from {self._domainsRegistry[name]} "
                               f"to {domain} PerfMon domain")
                self._domainsRegistry[name] = domain
            else:
                self._msg.debug(f"Algorithm {name} is already in the PerfMon "
                                 "domain, if you want to reassign do overwrite=True")
 

◆ addAuditor()

python.ComponentAccumulator.ComponentAccumulator.addAuditor	(		self,
			auditor )

Add Auditor to ComponentAccumulator and return the deduplicated instance.
This function will also create the required AuditorSvc.

Definition at line 595 of file ComponentAccumulator.py.

    def addAuditor(self, auditor):
        """Add Auditor to ComponentAccumulator and return the deduplicated instance.
        This function will also create the required AuditorSvc."""
        if not isinstance(auditor, GaudiConfig2.Configurable):
            raise TypeError(f"Attempt to add wrong type: {type(auditor).__name__} as auditor")
 
        if auditor.__component_type__ != "Auditor":
            raise TypeError(f"Attempt to add wrong type: {auditor.__component_type__} as auditor")
 
        context = createContextForDeduplication("Merging with existing auditors", auditor.name, self._componentsContext) # noqa : F841
 
        deduplicate(auditor, self._auditors)  #may raise on conflict
        newAuditor = self.addService(CompFactory.AuditorSvc(Auditors=[auditor.getFullJobOptName()]))
        self._lastAddedComponent = auditor.name
        return newAuditor
 
 

◆ addCondAlgo()

python.ComponentAccumulator.ComponentAccumulator.addCondAlgo	(	self,
		algo,
		primary = False,
		domain = None )

Add Conditions algorithm

Definition at line 530 of file ComponentAccumulator.py.

    def addCondAlgo(self,algo,primary=False,domain=None):
        """Add Conditions algorithm"""
        if not isinstance(algo, GaudiConfig2.Configurable):
            raise TypeError(f"Attempt to add wrong type: {type(algo).__name__} as conditions algorithm")
 
        if algo.__component_type__ != "Algorithm":
            raise TypeError(f"Attempt to add wrong type: {algo.__component_type__} as conditions algorithm")
 
        context = createContextForDeduplication("Merging with existing Conditions Algorithm", algo.name, self._componentsContext) # noqa : F841
 
        deduplicate(algo, self._conditionsAlgs) #will raise on conflict
        if primary:
            if self._primaryComp:
                self._msg.warning("addCondAlgo: Overwriting primary component of this CA. Was %s/%s, now %s/%s",
                                  self._primaryComp.__cpp_type__, self._primaryComp.name,
                                  algo.__cpp_type__, algo.name)
            #keep a ref of the de-duplicated conditions algorithm as primary component
            self._primaryComp = self.__getOne(self._conditionsAlgs, algo.name, "ConditionsAlgos")
 
        self._lastAddedComponent=algo.name
        if "trackCondAlgo" in ComponentAccumulator.debugMode:
            self._componentsContext[algo.name] = shortCallStack()
 
        # Assign the algorithm to a domain
        self.addAlgToPerfmonDomains(algo.name, 'Conditions' if not domain else domain)
 
        return algo
 

◆ addEventAlgo()

python.ComponentAccumulator.ComponentAccumulator.addEventAlgo	(	self,
		algorithms,
		sequenceName = None,
		primary = False,
		domain = None )

Definition at line 464 of file ComponentAccumulator.py.

    def addEventAlgo(self, algorithms,sequenceName=None,primary=False,domain=None):
        if not isinstance(algorithms, Sequence):
            #Swallow both single algorithms as well as lists or tuples of algorithms
            algorithms=[algorithms,]
 
        if sequenceName is None:
            # If there is an AthAlgSeq add the event algorithm there by default
            # See ATEAM-825 for a more detailed discussion for this choice
            seq = findSubSequence(self._sequence, 'AthAlgSeq')
            if seq is None:
                seq = self._sequence
        else:
            seq = findSubSequence(self._sequence, sequenceName)
        if seq is None:
            self.printConfig()
            raise ConfigurationError("Can not find sequence {}".format(sequenceName))
 
        for algo in algorithms:
            if not isinstance(algo, GaudiConfig2.Configurable):
                raise TypeError(f"Attempt to add wrong type: {type(algo).__name__} as event algorithm")
 
            if algo.__component_type__ != "Algorithm":
                raise TypeError(f"Attempt to add an {algo.__component_type__} as event algorithm")
 
            if algo.name in self._algorithms:
                context = createContextForDeduplication("Merging with existing Event Algorithm", algo.name, self._componentsContext) # noqa : F841
                deduplicateOne(algo, self._algorithms[algo.name])
                deduplicateOne(self._algorithms[algo.name], algo)
            else:
                self._algorithms[algo.name]=algo
 
            existingAlgInDest = findAlgorithm(seq, algo.name)
            if not existingAlgInDest:
                seq.Members.append(self._algorithms[algo.name])
                # Assign the algorithm to a domain
                self.addAlgToPerfmonDomains(algo.name, self._currentDomain if not domain else domain)
 
        if primary:
            if len(algorithms)>1:
                self._msg.warning("Called addEvenAlgo with a list of algorithms and primary==True. "
                                  "Designating the first algorithm as primary component")
            if self._primaryComp:
                self._msg.warning("addEventAlgo: Overwriting primary component of this CA. Was %s/%s, now %s/%s",
                                  self._primaryComp.__cpp_type__, self._primaryComp.name,
                                  algorithms[0].__cpp_type__, algorithms[0].name)
            #keep a ref of the algorithm as primary component
            self._primaryComp = algorithms[0]
        self._lastAddedComponent = algorithms[-1].name
 
        if "trackEventAlgo" in ComponentAccumulator.debugMode:
            for algo in algorithms:
                self._componentsContext[algo.name] = shortCallStack()
 
        return None
 

◆ addPublicTool()

python.ComponentAccumulator.ComponentAccumulator.addPublicTool	(	self,
		newTool,
		primary = False )

Add public tool and return the deduplicated instance.

Definition at line 612 of file ComponentAccumulator.py.

    def addPublicTool(self, newTool, primary=False):
        """Add public tool and return the deduplicated instance."""
        if not isinstance(newTool, GaudiConfig2.Configurable):
            raise TypeError(f"Attempt to add wrong type: {type(newTool).__name__} as public AlgTool")
 
        if newTool.__component_type__ != "AlgTool":
            raise TypeError(f"Attempt to add wrong type: {newTool.__component_type__} as public AlgTool")
 
        context = createContextForDeduplication("Merging with existing Public Tool", newTool.name, self._componentsContext) # noqa : F841
 
        deduplicate(newTool,self._publicTools)
        if primary:
            if self._primaryComp:
                self._msg.warning("addPublicTool: Overwriting primary component of this CA. Was %s/%s, now %s/%s",
                                  self._primaryComp.__cpp_type__, self._primaryComp.name,
                                  newTool.__cpp_type__, newTool.name)
            #keep a ref of the de-duplicated tool as primary component
            self._primaryComp=self.__getOne( self._publicTools, newTool.name, "Public Tool")
        self._lastAddedComponent=newTool.name
        if "trackPublicTool" in ComponentAccumulator.debugMode:
            self._componentsContext[newTool.name] = shortCallStack()
        # return the new public tool
        return self.__getOne(self._publicTools, newTool.name, "Public Tool")
 
 

◆ addSequence()

python.ComponentAccumulator.ComponentAccumulator.addSequence	(	self,
		newseq,
		primary = False,
		parentName = None )

Adds new sequence. If second argument is present then it is added under another sequence

Definition at line 322 of file ComponentAccumulator.py.

    def addSequence(self, newseq, primary=False, parentName = None ):
        """ Adds new sequence. If second argument is present then it is added under another sequence  """
 
        if not isSequence(newseq):
            raise TypeError('{} is not a sequence'.format(newseq.name))
 
        if not isinstance(newseq, GaudiConfig2.Configurable):
            raise ConfigurationError('{} is not the Conf2 Sequence, ComponentAccumulator handles only the former'.format(newseq.name))
 
        algorithmsInside = findAllAlgorithmsByName(newseq)
        if len(algorithmsInside) != 0:
            raise ConfigurationError('{} contains algorithms (or sub-sequences contain them). That is not supported. Construct ComponentAccumulator and merge it instead'.format(newseq.name))
 
 
        if parentName is None:
            parent=self._sequence
        else:
            parent = findSubSequence(self._sequence, parentName )
            if parent is None:
                raise ConfigurationError("Missing sequence {} to add new sequence to".format(parentName))
 
        parent.Members.append(newseq)
        if "trackSequence" in ComponentAccumulator.debugMode:
            self._componentsContext[newseq] = shortCallStack()
 
        if primary:
            if self._primaryComp:
                self._msg.warning("addEventAlgo: Overwriting primary component of this CA. Was %s/%s, now %s/%s",
                                  self._primaryComp.__cpp_type__, self._primaryComp.name,
                                  newseq.__cpp_type__, newseq.name)
            #keep a ref of the sequence as primary component
            self._primaryComp = newseq
        return newseq
 
 

◆ addService()

python.ComponentAccumulator.ComponentAccumulator.addService	(	self,
		newSvc,
		primary = False,
		create = False )

Add service and return the deduplicated instance

Definition at line 566 of file ComponentAccumulator.py.

    def addService(self, newSvc, primary=False, create=False):
        """Add service and return the deduplicated instance"""
        if not isinstance(newSvc, GaudiConfig2.Configurable):
            raise TypeError(f"Attempt to add wrong type: {type(newSvc).__name__} as service")
 
        if newSvc.__component_type__ != "Service":
            raise TypeError(f"Attempt to add wrong type: {newSvc.__component_type__} as service")
 
        context = createContextForDeduplication("Merging with existing Service", newSvc.name, self._componentsContext) # noqa : F841
 
        deduplicate(newSvc, self._services)  #may raise on conflict
        if primary:
            if self._primaryComp:
                self._msg.warning("addService: Overwriting primary component of this CA. Was %s/%s, now %s/%s",
                                  self._primaryComp.__cpp_type__, self._primaryComp.name,
                                  newSvc.__cpp_type__, newSvc.name)
            #keep a ref of the de-duplicated service as primary component
            self._primaryComp=self.__getOne( self._services, newSvc.name, "Services")
        self._lastAddedComponent=newSvc.name
 
        if create:
            sname = newSvc.getFullJobOptName()
            if sname not in self._servicesToCreate:
                self._servicesToCreate.append(sname)
        if "trackService" in  ComponentAccumulator.debugMode:
            self._componentsContext[newSvc.name] = shortCallStack()
        return self.__getOne( self._services, newSvc.name, "Services")
 
 

◆ createApp()

python.ComponentAccumulator.ComponentAccumulator.createApp ( self )

Definition at line 969 of file ComponentAccumulator.py.

    def createApp(self):
        # Create the Gaudi object early.
        # Without this here, pyroot can sometimes get confused
        # and report spurious type mismatch errors about this object.
        import ROOT
        ROOT.gROOT.SetBatch(True)
        ROOT.Gaudi
 
        appPropsToSet, mspPropsToSet, bshPropsToSet = self.gatherProps()
 
        self._wasMerged = True
        from Gaudi.Main import BootstrapHelper
 
        bsh = BootstrapHelper()
        app = bsh.createApplicationMgr()
 
        for k, v in appPropsToSet.items():
            self._msg.debug("Setting property %s : %s", k, v)
            app.setProperty(k, v)
 
        app.configure()
 
        msp = app.getService("MessageSvc")
        for k, v in mspPropsToSet.items():
            self._msg.debug("Setting property %s : %s", k, v)
            bsh.setProperty(msp, k.encode(), v.encode())
 
        # Feed the jobO service with the remaining options
        for comp, name, value in bshPropsToSet:
            self._msg.debug("Adding %s.%s = %s", comp, name, value)
            app.setOption(f"{comp}.{name}", value)
 
        sys.stdout.flush()
        return app
 

◆ dropAuditor()

python.ComponentAccumulator.ComponentAccumulator.dropAuditor	(		self,
			name )

Definition at line 745 of file ComponentAccumulator.py.

    def dropAuditor(self,name):
        lenBefore=len(self._auditors)
        self._auditors = [a for a in self._auditors if a.getName()!=name]
        lenAfter=len(self._auditors)
        if lenAfter == lenBefore:
            self._msg.warning("Auditor %s not found",name)
        else:
            self._msg.info("Removed auditor %s",name)
        return
            

◆ dropCondAlgo()

python.ComponentAccumulator.ComponentAccumulator.dropCondAlgo	(		self,
			name )

Definition at line 715 of file ComponentAccumulator.py.

    def dropCondAlgo(self,name):
        lenBefore=len(self._conditionsAlgs)
        self._conditionsAlgs = [a for a in self._conditionsAlgs if a.getName()!=name]
        lenAfter=len(self._conditionsAlgs)
        if lenAfter == lenBefore:
            self._msg.warning("Condition Algorithm %s not found",name)
        else:
            self._msg.info("Removed conditions Algorithm %s",name)
        return
 

◆ dropEventAlgo()

python.ComponentAccumulator.ComponentAccumulator.dropEventAlgo	(	self,
		name,
		sequence = "AthAlgSeq" )

Definition at line 685 of file ComponentAccumulator.py.

    def dropEventAlgo(self,name,sequence="AthAlgSeq"):
        s=self.getSequence(sequence)
        lenBefore=len(s.Members)
        s.Members = [a for a in s.Members if not a.getName()==name]
        lenAfter=len(s.Members)
        if lenAfter == lenBefore:
            self._msg.warning("Algorithm %s not found in sequence %s",name,sequence)
        else:
            self._msg.info("Removed algorithm %s from sequence %s",name,sequence)
            try:
                del self._algorithms[name]
            except KeyError:
                self._msg.warning("Algorithm %s not found in self._sequence ???",name)
        return
 

◆ dropPublicTool()

python.ComponentAccumulator.ComponentAccumulator.dropPublicTool	(		self,
			name )

Definition at line 735 of file ComponentAccumulator.py.

    def dropPublicTool(self,name):
        lenBefore=len(self._publicTools)
        self._publicTools = [p for p in self._publicTools if p.getName()!=name]
        lenAfter=len(self._publicTools)
        if lenAfter == lenBefore:
            self._msg.warning("Public tool %s not found",name)
        else:
            self._msg.info("Removed public tool %s",name)
        return
 

◆ dropService()

python.ComponentAccumulator.ComponentAccumulator.dropService	(		self,
			name )

Definition at line 725 of file ComponentAccumulator.py.

    def dropService(self,name):
        lenBefore=len(self._services)
        self._services = [s for s in self._services if s.getName()!=name]
        lenAfter=len(self._services)
        if lenAfter == lenBefore:
            self._msg.warning("Service %s not found",name)
        else:
            self._msg.info("Removed Service %s",name)
        return
    

◆ empty()

python.ComponentAccumulator.ComponentAccumulator.empty ( self )

Definition at line 167 of file ComponentAccumulator.py.

    def empty(self):
        return (len(self._sequence.Members)+len(self._conditionsAlgs)+len(self._services)+
                len(self._publicTools)+len(self._theAppProps) == 0)
 

◆ flagPerfmonDomain()

python.ComponentAccumulator.ComponentAccumulator.flagPerfmonDomain	(		self,
			name )

Mark the beginning of a new PerfMon domain.

Definition at line 414 of file ComponentAccumulator.py.

    def flagPerfmonDomain(self, name):
        """ Mark the beginning of a new PerfMon domain. """
        self._msg.debug(f"Toggling the current algorithm domain to {name}")
        self._currentDomain = name
 

◆ foreach_component()

python.ComponentAccumulator.ComponentAccumulator.foreach_component	(		self,
			path )

Utility to set properties of components using wildcards.

Example:
  ca.foreach_component("*/HLTTop/*/*Hypo*").OutputLevel = VERBOSE

The components name and location in the CF tree are translated into a UNIX-like path
and are matched using the `fnmatch` library. If the property is set successfully
an INFO message is printed else a WARNING.

The convention for paths of nested components is as follows:
  Sequence     : only the name is used in the path
  Algorithm    : "type/name" is used
  Private Tool : ToolHandle property name plus "type/name" is used
  Public Tool  : located under "ToolSvc/" and "type/name" is used
  Service      : located under "SvcMgr/" and "type/name" is used

Definition at line 1190 of file ComponentAccumulator.py.

    def foreach_component(self, path):
        """Utility to set properties of components using wildcards.
 
        Example:
          ca.foreach_component("*/HLTTop/*/*Hypo*").OutputLevel = VERBOSE
 
        The components name and location in the CF tree are translated into a UNIX-like path
        and are matched using the `fnmatch` library. If the property is set successfully
        an INFO message is printed else a WARNING.
 
        The convention for paths of nested components is as follows:
          Sequence     : only the name is used in the path
          Algorithm    : "type/name" is used
          Private Tool : ToolHandle property name plus "type/name" is used
          Public Tool  : located under "ToolSvc/" and "type/name" is used
          Service      : located under "SvcMgr/" and "type/name" is used
        """
        from AthenaConfiguration.PropSetterProxy import PropSetterProxy
        return PropSetterProxy(self, path)
 
 

◆ gatherProps()

python.ComponentAccumulator.ComponentAccumulator.gatherProps ( self )

Definition at line 1004 of file ComponentAccumulator.py.

    def gatherProps(self):
        appPropsToSet = {k: str(v) for k, v in self._theAppProps.items()}
        mspPropsToSet = {}
        bshPropsToSet = []
        svcToCreate = []
        extSvc = []
        for svc in self._services:
            extSvc += [
                svc.getFullJobOptName(),
            ]
            if svc.getFullJobOptName() in self._servicesToCreate:
                svcToCreate.append(svc.getFullJobOptName())
 
        # order basic services
        for bs in reversed(_basicServicesToCreateOrder):
            if bs in svcToCreate:
                svcToCreate.insert(0, svcToCreate.pop( svcToCreate.index(bs) ) )
 
        extSvc.append("PyAthena::PyComponentMgr/PyComponentMgr")
 
        appPropsToSet["ExtSvc"] = str(extSvc)
        appPropsToSet["CreateSvc"] = str(svcToCreate)
 
        def getCompsToBeAdded(comp, namePrefix=""):
            name = namePrefix + comp.getName()
            for k, v in comp._properties.items():
                # Handle special cases of properties:
                # 1.PrivateToolHandles
                if isinstance(v, GaudiConfig2.Configurable):
                    # Add the name of the tool as property to the parent
                    bshPropsToSet.append((name, k, v.getFullJobOptName()))
                    # Recursively add properties of this tool to the JobOptionSvc
                    getCompsToBeAdded(v, namePrefix=name + ".")
                # 2. PrivateToolHandleArray
                elif isinstance(v, GaudiHandles.PrivateToolHandleArray):
                    # Add names of tools as properties to the parent
                    bshPropsToSet.append(
                        (name, k, str([v1.getFullJobOptName() for v1 in v]),)
                    )
                    # Recursively add properties of tools to JobOptionsSvc
                    for v1 in v:
                        getCompsToBeAdded(v1, namePrefix=name + ".")
                else:
                    # For a list of DataHandle, we need to stringify
                    # each element individually.  Otherwise, we get the repr
                    # version of the elements, which Gaudi JO will choke on.
                    if isinstance(v, list) and v and isinstance(v[0], DataHandle):
                        v = [str(x) for x in v]
                    # For sequences, need to convert the list of algs to names
                    elif isSequence(comp) and k == "Members":
                        v = [alg.getFullJobOptName() for alg in comp.Members]
                    vstr = "" if v is None else str(v)
                    bshPropsToSet.append((name, k, vstr))
       
        try:
            from AthenaPython import PyAthenaComps
            PyAlg = PyAthenaComps.Alg
            PySvc = PyAthenaComps.Svc
        except ImportError:
            PyAlg = type(None)
            PySvc = type(None)
 
        # Services
        for svc in self._services:
            if svc.getName() != "MessageSvc":  # MessageSvc will exist already! Needs special treatment
                getCompsToBeAdded(svc)
                if isinstance(svc, PySvc):
                    svc.setup()
            else:
                mspPropsToSet.update((k,str(v)) for k,v in svc._properties.items())
 
        # Algorithms and Sequences
        for alg in iterSequences(self._sequence):
            getCompsToBeAdded(alg)
            if isinstance(alg, PyAlg):
                alg.setup()
 
        # Cond Algs
        condalgseq = []
        for alg in self._conditionsAlgs:
            getCompsToBeAdded(alg)
            condalgseq.append(alg.getFullJobOptName())
            if isinstance(alg, PyAlg):
                alg.setup()
        bshPropsToSet.append(("AthCondSeq", "Members", str(condalgseq)))
 
        # Public Tools
        for pt in self._publicTools:
            getCompsToBeAdded(pt, namePrefix="ToolSvc.")
 
        # Auditors
        for aud in self._auditors:
            getCompsToBeAdded(aud)
 
        return appPropsToSet, mspPropsToSet, bshPropsToSet
 

◆ getAlgPerfmonDomain()

python.ComponentAccumulator.ComponentAccumulator.getAlgPerfmonDomain	(		self,
			name )

Return the PerfMon domain of the given algorithm

Definition at line 428 of file ComponentAccumulator.py.

    def getAlgPerfmonDomain(self, name):
        """ Return the PerfMon domain of the given algorithm """
        if name in self._domainsRegistry:
            return self._domainsRegistry[name]
        else:
            self._msg.info(f"Algorithm {name} is not in PerfMon domains registry")
            return None
 

◆ getAppProps()

python.ComponentAccumulator.ComponentAccumulator.getAppProps ( self )

Definition at line 755 of file ComponentAccumulator.py.

    def getAppProps(self):
        return self._theAppProps
 

◆ getAuditor()

python.ComponentAccumulator.ComponentAccumulator.getAuditor	(		self,
			name )

Retuns a single auditor, exception if not found

Definition at line 681 of file ComponentAccumulator.py.

    def getAuditor(self,name):
        """Retuns a single auditor, exception if not found"""
        return self.__getOne(self._auditors,name,"Auditors")
 

◆ getCondAlgo()

python.ComponentAccumulator.ComponentAccumulator.getCondAlgo	(		self,
			name )

Get conditions algorithm by name

Definition at line 562 of file ComponentAccumulator.py.

    def getCondAlgo(self, name):
        """Get conditions algorithm by name"""
        return self.__getOne( self._conditionsAlgs, name, "conditions algorithms")
 

◆ getCondAlgos()

python.ComponentAccumulator.ComponentAccumulator.getCondAlgos ( self )

Get all conditions algorithms

Definition at line 558 of file ComponentAccumulator.py.

    def getCondAlgos(self):
        """Get all conditions algorithms"""
        return self._conditionsAlgs
 

◆ getCurrentPerfmonDomain()

python.ComponentAccumulator.ComponentAccumulator.getCurrentPerfmonDomain ( self )

Get the current PerfMon domain.

Definition at line 410 of file ComponentAccumulator.py.

    def getCurrentPerfmonDomain(self):
        """ Get the current PerfMon domain. """
        return self._currentDomain
 

◆ getEventAlgo()

python.ComponentAccumulator.ComponentAccumulator.getEventAlgo	(		self,
			name = None )

Get algorithm with `name`

Definition at line 519 of file ComponentAccumulator.py.

    def getEventAlgo(self, name=None):
        """Get algorithm with `name`"""
        if name not in self._algorithms:
            raise ConfigurationError("Can not find an algorithm of name {} ".format(name))
        return self._algorithms[name]
 

◆ getEventAlgos()

python.ComponentAccumulator.ComponentAccumulator.getEventAlgos	(		self,
			seqName = None )

Get all algorithms within sequence

Definition at line 525 of file ComponentAccumulator.py.

    def getEventAlgos(self, seqName=None):
        """Get all algorithms within sequence"""
        seq = self._sequence if seqName is None else findSubSequence(self._sequence, seqName )
        return [s for s in iterSequences(seq) if not isSequence(s)]
 

◆ getInvertedPerfmonDomains()

python.ComponentAccumulator.ComponentAccumulator.getInvertedPerfmonDomains ( self )

 The actual registry keeps "alg":"domain".
This function inverts the registry to get "domain":["algs"].

Definition at line 419 of file ComponentAccumulator.py.

    def getInvertedPerfmonDomains(self):
        """ The actual registry keeps "alg":"domain".
        This function inverts the registry to get "domain":["algs"].
        """
        result = {}
        for i, v in self._domainsRegistry.items():
            result[v] = [i] if v not in result.keys() else result[v] + [i]
        return result
 

◆ getIO()

python.ComponentAccumulator.ComponentAccumulator.getIO ( self )

Returns information about inputs needed and outputs produced by this CA

It is a list of dictionaries containing the: type, key, R / W, the component and name of the property via which it is set

Definition at line 280 of file ComponentAccumulator.py.

    def getIO(self):
        """
        Returns information about inputs needed and outputs produced by this CA
 
        It is a list of dictionaries containing the: type, key, R / W, the component and name of the property via which it is set
        """
        def __getHandles(comp):
            io = []
            for i in comp.ExtraInputs:
                io.append({"type": i[0],
                            "key": i[1],
                            "comp": comp.getFullJobOptName(),
                            "mode":  "R",
                            "prop": "ExtraInputs"})
            for i in comp.ExtraOutputs:
                io.append({"type": i[0],
                            "key": i[1],
                            "comp": comp.getFullJobOptName(),
                            "mode":  "W",
                            "prop": "ExtraOutputs"})
 
            for prop, descr in comp._descriptors.items():
                if isinstance(descr.default, DataHandle):
                    io.append( {"type": descr.default.type(),
                                "key":  comp._properties[prop] if prop in comp._properties else  descr.default.path(),
                                "comp": comp.getFullJobOptName(),
                                "mode": descr.default.mode(),
                                "prop": prop })
                # TODO we should consider instantiating c++ defaults and fetching corresponsing props
                if "PrivateToolHandle" == descr.cpp_type and prop in comp._properties:
                    io.extend( __getHandles(comp._properties[prop]) )
                if "PrivateToolHandleArray" == descr.cpp_type and prop in comp._properties:
                    for tool in getattr(comp, prop):
                        io.extend( __getHandles(tool))
            return io
 
        ret = []
        for comp in self._allComponents():
            ret.extend(__getHandles(comp))
        return ret
 
 

◆ getPrimary()

python.ComponentAccumulator.ComponentAccumulator.getPrimary ( self )

Get designated primary component

Definition at line 637 of file ComponentAccumulator.py.

    def getPrimary(self):
        """Get designated primary component"""
        if self._privateTools:
            return self.popPrivateTools()
        elif self._primaryComp:
            return self._primaryComp
        else:
            raise ConfigurationError("Called getPrimary() but no primary component nor private AlgTool is known.\n{}".format(self._inspect()))
 

◆ getPrimaryAndMerge()

python.ComponentAccumulator.ComponentAccumulator.getPrimaryAndMerge	(		self,
			other )

Merging in the other accumulator and getting the primary component

Definition at line 646 of file ComponentAccumulator.py.

    def getPrimaryAndMerge(self, other):
        """ Merging in the other accumulator and getting the primary component"""
        if other is None:
            raise RuntimeError("merge called on object of type None: did you forget to return a CA from a config function?")
        comp = other.getPrimary()
        self.merge(other)
        return comp
 

◆ getPublicTool()

python.ComponentAccumulator.ComponentAccumulator.getPublicTool	(		self,
			name = None )

Returns single public tool, exception if either not found or to many found

Definition at line 667 of file ComponentAccumulator.py.

    def getPublicTool(self, name=None):
        """Returns single public tool, exception if either not found or to many found"""
        return self.__getOne( self._publicTools, name, "PublicTools")
 

◆ getPublicTools()

python.ComponentAccumulator.ComponentAccumulator.getPublicTools ( self )

Definition at line 664 of file ComponentAccumulator.py.

    def getPublicTools(self):
        return self._publicTools
 

◆ getSequence()

python.ComponentAccumulator.ComponentAccumulator.getSequence	(		self,
			sequenceName = None )

Definition at line 357 of file ComponentAccumulator.py.

    def getSequence(self,sequenceName=None):
        if sequenceName is None:
            return self._sequence
        else:
            return findSubSequence(self._sequence,sequenceName)
 

◆ getService()

python.ComponentAccumulator.ComponentAccumulator.getService	(		self,
			name = None )

Returns single service, exception if either not found or to many found

Definition at line 674 of file ComponentAccumulator.py.

    def getService(self, name=None):
        """Returns single service, exception if either not found or to many found"""
        if name is None:
            return self._primarySvc
        else:
            return self.__getOne( self._services, name, "Services")
 

◆ getServices()

python.ComponentAccumulator.ComponentAccumulator.getServices ( self )

Definition at line 671 of file ComponentAccumulator.py.

    def getServices(self):
        return self._services
 

◆ merge()

python.ComponentAccumulator.ComponentAccumulator.merge	(	self,
		other,
		sequenceName = None )

Merging in the other accumulator

Definition at line 778 of file ComponentAccumulator.py.

    def merge(self,other, sequenceName=None):
        """Merging in the other accumulator"""
        if other is None:
            raise RuntimeError("merge called on object of type None: "
                               "did you forget to return a CA from a config function?")
 
        if not isinstance(other,ComponentAccumulator):
            raise TypeError(f"Attempt to merge wrong type {type(other).__name__}. "
                            "Only instances of ComponentAccumulator can be added")
 
        context = (Context.hint if not ComponentAccumulator.debugMode else   # noqa: F841
                   Context("When merging the ComponentAccumulator:\n{} \nto:\n{}".format(other._inspect(), self._inspect())))
 
        if other._privateTools is not None:
            if isinstance(other._privateTools, Sequence):
                raiseWithCurrentContext(RuntimeError(
                    "merge called on ComponentAccumulator with a dangling (array of) private tools\n"))
            else:
                raiseWithCurrentContext(RuntimeError(
                    "merge called on ComponentAccumulator with a dangling private tool "
                    f"{other._privateTools.__cpp_type__}/{other._privateTools.name}"))
 
        if not other._isMergable:
            raiseWithCurrentContext(ConfigurationError(
                "Attempted to merge a top level ComponentAccumulator. Revert the order of merging\n"))
 
        def mergeSequences( dest, src ):
 
            # Ensure sequences of same name have same properties. This is called many times
            # and is highly optimized. Make sure you profile before modifying this code.
            if dest.name == src.name:
                # Compare all set properties ignoring 'Members'
                props = (dest._properties.keys() | src._properties.keys()) - {'Members'}
                for seqProp in props:
                    try:
                        if dest._properties[seqProp] != src._properties[seqProp]:
                            raise RuntimeError(
                                f"Merging two sequences with name '{dest.name}' but property '{seqProp}' "
                                f"has different values: {getattr(dest, seqProp)} vs {getattr(src, seqProp)}")
                    except KeyError as e:
                        raise RuntimeError(
                            f"Merging two sequences with name '{dest.name}' but property '{e}' is not "
                            f"set in one of them")
 
            for childIdx, c in enumerate(src.Members):
                if isSequence( c ):
                    sub = findSubSequence( dest, c.name ) #depth=1 ???
                    if sub:
                        mergeSequences(sub, c )
                    else:
                        self._msg.debug("  Merging sequence %s to a destination sequence %s", c.name, dest.name )
                        algorithmsByName = findAllAlgorithmsByName(c) # dictionary: algName (alg, parentSeq, indexInParentSeq)                        
                        for name, existingAlgs in algorithmsByName.items():
                            # all algorithms from incoming CA are already deduplicated, so we can only handle the fist one
                            algInstance, _, _ = existingAlgs[0]
                            if name not in self._algorithms:
                                self._algorithms[name] = algInstance
                            else:
                                dedupContext1 = createContextForDeduplication("While merging sequences adding incoming algorithm", c.name, other._componentsContext) # noqa : F841
                                dedupContext2 = createContextForDeduplication("While merging sequences adding to existing algorithm", c.name, self._componentsContext) # noqa : F841
                                deduplicateOne(self._algorithms[name], algInstance)
                                deduplicateOne(algInstance, self._algorithms[name])
                            for _, parent, idx in existingAlgs: # put the deduplicated algo back into original sequences
                                parent.Members[idx] = self._algorithms[name]
                            # Add the algorithm to the PerfMon domains
                            self.addAlgToPerfmonDomains(name, other._domainsRegistry[name] if name in other._domainsRegistry else self._currentDomain)
                        dest.Members.append(c)
 
                else: # an algorithm
                    if c.name in self._algorithms:
                        dedupContext1 = createContextForDeduplication("While merging sequences adding incoming algorithm", c.name, other._componentsContext) # noqa : F841
                        dedupContext2 = createContextForDeduplication("While merging sequences adding to existing algorithm", c.name, self._componentsContext) # noqa : F841
 
                        deduplicateOne(self._algorithms[c.name], c)
                        deduplicateOne(c, self._algorithms[c.name])
                        src.Members[childIdx] = self._algorithms[c.name]
                    else:
                        self._algorithms[c.name] = c
 
                    existingAlgInDest = findAlgorithm( dest, c.name, depth=1 )
                    if not existingAlgInDest:
                        self._msg.debug("   Adding algorithm %s to a sequence %s", c.name, dest.name )
                        dest.Members.append(c)
 
                    # Add the algorithm to the PerfMon domains
                    self.addAlgToPerfmonDomains(c.name, other._domainsRegistry[c.name] if c.name in other._domainsRegistry else self._currentDomain)
 
        # Merge sequences:
        # mergeSequences(destSeq, other._sequence)
        # if sequenceName is provided it means we should be ignoring the actual MAIN seq name there and use the sequenceName
        # that means the first search in the destination sequence needs to be cheated
        # the sequenceName argument is only relevant for the MAIN sequence, 
        # secondary top sequences are treated as if the sequenceName argument would not be provided
 
        for otherSeq in other._allSequences:
            found=False
            for ourSeq in self._allSequences:
                destSeqName = otherSeq.name
                if sequenceName and otherSeq == other._sequence: # if sequence moving is requested (sequenceName != None) it concerns only the main sequence
                    destSeqName = sequenceName
                    self._msg.verbose("   Will move sequence %s to %s", otherSeq.name, destSeqName )
 
                ourSeq = findSubSequence(ourSeq, destSeqName) # try to add sequence to the main structure first, to each seq in parent?
                if ourSeq:
                    mergeSequences(ourSeq, otherSeq)
                    found=True
                    self._msg.verbose("   Succeeded to merge sequence %s to %s", otherSeq.name, ourSeq.name )
                else:
                    self._msg.verbose("   Failed to merge sequence %s to any existing one, destination CA will have several top/dangling sequences", otherSeq.name )
            if not found: # just copy the sequence as a dangling one
                self._allSequences.append( otherSeq )
                mergeSequences( self._allSequences[-1], otherSeq )
 
 
 
 
 
        # Additional checking and updating other accumulator's algorithms list
        for name in other._algorithms:
            if name not in self._algorithms:
                raiseWithCurrentContext(ConfigurationError('Error in merging. Algorithm {} missing in destination accumulator\n'.format(name)))
            other._algorithms[name] = self._algorithms[name]
 
            #self._conditionsAlgs+=other._conditionsAlgs
        for condAlg in other._conditionsAlgs:
            addContext = createContextForDeduplication("Merging incoming Conditions Algorithm", condAlg.name, other._componentsContext) # noqa : F841
            self.addCondAlgo(condAlg) #Profit from deduplicaton here
 
        for svc in other._services:
            addContext = createContextForDeduplication("Merging incoming Service", svc.name, other._componentsContext) # noqa : F841
            self.addService(svc, create = svc.getFullJobOptName() in other._servicesToCreate) #Profit from deduplicaton here
 
        for pt in other._publicTools:
            addContext = createContextForDeduplication("Merging incoming Public Tool", pt.name, other._componentsContext) # noqa : F841
            self.addPublicTool(pt) #Profit from deduplicaton here
 
 
        for aud in other._auditors:
            addContext = createContextForDeduplication("Merging incoming Auditor", aud.name, other._componentsContext) # noqa : F841
            self.addAuditor(aud) #Profit from deduplicaton here
 
        #Merge AppMgr properties:
        for (k,v) in other._theAppProps.items():
            self.setAppProperty(k,v)  #Will warn about overrides
            pass
        other._wasMerged=True
 
        self._lastAddedComponent = other._lastAddedComponent #+ ' (Merged)'
        self._componentsContext.update(other._componentsContext) # update the context so it contains an information about the new components (and refreshed old components)
 

◆ popEventAlgo()

python.ComponentAccumulator.ComponentAccumulator.popEventAlgo	(	self,
		name,
		sequence = "AthAlgSeq" )

Definition at line 700 of file ComponentAccumulator.py.

    def popEventAlgo(self,name,sequence="AthAlgSeq"):
        s=self.getSequence(sequence)
        lenBefore=len(s.Members)
        s.Members = [a for a in s.Members if not a.getName()==name]
        lenAfter=len(s.Members)
        if lenAfter == lenBefore:
            self._msg.warning("Algorithm %s not found in sequence %s",name,sequence)
        else:
            self._msg.info("Removed algorithm %s from sequence %s",name,sequence)
            try:
                return self._algorithms.pop(name)
            except KeyError:
                self._msg.warning("Algorithm %s not found in self._sequence ??? Returning 'None'",name)
        return None
 

◆ popPrivateTools()

python.ComponentAccumulator.ComponentAccumulator.popPrivateTools	(		self,
			quiet = False )

Get the (list of) private AlgTools from this ComponentAccumulator.
The CA will not keep any reference to the AlgTool. Throw an exception if
no tools are available unless quiet=True.

Definition at line 388 of file ComponentAccumulator.py.

    def popPrivateTools(self, quiet=False):
        """Get the (list of) private AlgTools from this ComponentAccumulator.
        The CA will not keep any reference to the AlgTool. Throw an exception if
        no tools are available unless quiet=True.
        """
        tool = self._privateTools
        if not quiet and tool is None:
            raise ConfigurationError("Private tool(s) requested, but none are present")
        self._privateTools=None
        return tool
 

◆ popToolsAndMerge()

python.ComponentAccumulator.ComponentAccumulator.popToolsAndMerge	(		self,
			other )

 Merging in the other accumulator and getting the (list of) private AlgTools
from this ComponentAccumulator.

Definition at line 399 of file ComponentAccumulator.py.

    def popToolsAndMerge(self, other):
        """ Merging in the other accumulator and getting the (list of) private AlgTools
        from this ComponentAccumulator.
        """
        if other is None:
            raise RuntimeError("popToolsAndMerge called on object of type None: "
                               "did you forget to return a CA from a config function?")
        tool = other.popPrivateTools()
        self.merge(other)
        return tool
 

◆ printCondAlgs()

python.ComponentAccumulator.ComponentAccumulator.printCondAlgs	(	self,
		summariseProps = False,
		onlyComponents = [],
		printDefaults = False )

Definition at line 199 of file ComponentAccumulator.py.

    def printCondAlgs(self, summariseProps=False, onlyComponents=[], printDefaults=False):
        self._msg.info( "Condition Algorithms" )
        for (c, flag) in filterComponents (self._conditionsAlgs, onlyComponents):
            self._msg.info( " \\__ %s (cond alg)%s", c.name, self._componentsContext.get(c.name,""))
            if summariseProps and flag:
                printProperties(self._msg, c, 1, printDefaults)
        return
 
 

◆ printConfig()

python.ComponentAccumulator.ComponentAccumulator.printConfig	(	self,
		withDetails = False,
		summariseProps = False,
		onlyComponents = [],
		printDefaults = False,
		printSequenceTreeOnly = False,
		prefix = None )

Definition at line 212 of file ComponentAccumulator.py.

                    onlyComponents = [], printDefaults=False, printSequenceTreeOnly=False, prefix=None):
        msg = logging.getLogger(prefix) if prefix else self._msg
 
        msg.info( "Event Algorithm Sequences" )
 
        def printSeqAndAlgs(seq, nestLevel = 0,
                            onlyComponents = []):
            def __prop(name):
                if name in seq._properties:
                    return seq._properties[name]
                return seq._descriptors[name].default
            if withDetails:
                msg.info( "%s\\__ %s (seq: %s %s)", " "*nestLevel, seq.name,
                                "SEQ" if __prop("Sequential") else "PAR",
                                "OR" if __prop("ModeOR") else "AND" + self._componentsContext.get(seq.name, "") )
            else:
                msg.info( "%s\\__ %s", " "*nestLevel, seq.name)
 
            nestLevel += 3
            for (c, flag) in filterComponents(seq.Members, onlyComponents):
                if isSequence(c):
                    printSeqAndAlgs(c, nestLevel, onlyComponents = onlyComponents )
                else:
                    if withDetails:
                        msg.info( "%s\\__ %s (alg) %s", " "*nestLevel, c.getFullJobOptName(), self._componentsContext.get(c.name, ""))
                    else:
                        msg.info( "%s\\__ %s", " "*nestLevel, c.name )
                    if summariseProps and flag:
                        printProperties(msg, c, nestLevel, printDefaults)
 
 
        for n,s in enumerate(self._allSequences):
            msg.info( "Top sequence %d", n )
            printSeqAndAlgs(s, onlyComponents = onlyComponents)
 
        if printSequenceTreeOnly:
            return
 
        self.printCondAlgs (summariseProps = summariseProps,
                            onlyComponents = onlyComponents)
        msg.info( "Services" )
        msg.info( [ s[0].name + (" (created) " if s[0].name in self._servicesToCreate else "")
                              for s in filterComponents (self._services, onlyComponents) ] )
        msg.info( "Public Tools" )
        msg.info( "[" )
        for (t, flag) in filterComponents (self._publicTools, onlyComponents):
            msg.info( "  %s,", t.getFullJobOptName() + self._componentsContext.get(t.name,""))
            # Not nested, for now
            if summariseProps and flag:
                printProperties(msg, t, printDefaults)
        msg.info( "]" )
        msg.info( "Private Tools")
        msg.info( "[" )
        if self._privateTools:
            for tool in self._privateTools if isinstance(self._privateTools, Sequence) else [self._privateTools]:
                msg.info( "  %s,", tool.getFullJobOptName() + self._componentsContext.get(tool.name,""))
                if summariseProps:
                    printProperties(msg, tool, printDefaults)
        msg.info( "]" )
        if self._auditors:
            msg.info( "Auditors" )
            msg.info( [ a[0].name for a in filterComponents(self._auditors, onlyComponents) ] )
 
        msg.info( "theApp properties" )
        for k, v in self._theAppProps.items():
            msg.info("  %s : %s", k, v)
 

◆ printPerfmonDomains()

python.ComponentAccumulator.ComponentAccumulator.printPerfmonDomains ( self )

Print the PerfMon domains.

Definition at line 452 of file ComponentAccumulator.py.

    def printPerfmonDomains(self):
        """ Print the PerfMon domains. """
        invertedDomains = self.getInvertedPerfmonDomains()
        self._msg.info(":: This CA contains the following PerfMon domains ::")
        self._msg.info(f":: There are a total of {len(self._domainsRegistry)} "
                       f"registered algorithms in {len(invertedDomains)} domains  ::")
        for domain, algs in invertedDomains.items():
            self._msg.info(f"+ Domain : {domain}")
            for alg in algs:
                self._msg.info("\\_ %s", alg)
        self._msg.info(":: End of PerfMon domains ::")
 

◆ run()

python.ComponentAccumulator.ComponentAccumulator.run	(		self,
			maxEvents = None )

Definition at line 1100 of file ComponentAccumulator.py.

    def run(self,maxEvents=None):
        from os import environ
        outpklfile = environ.get("PICKLECAFILE", None)
        if outpklfile is not None:
            if outpklfile:  # non-empty string
                self._msg.info("Storing configuration in pickle file %s",outpklfile)
                with open(outpklfile, "wb") as f:
                    self.store(f)
            else:           # empty string, just exit
                self.wasMerged()
                self._msg.info("Exiting after configuration stage")
            from Gaudi.Main import BootstrapHelper
            return BootstrapHelper.StatusCode(True)
 
        # Make sure python output is flushed before triggering output from Gaudi.
        # Otherwise, observed output ordering may differ between py2/py3.
        sys.stdout.flush()
 
 
        #Set TDAQ_ERS_NO_SIGNAL_HANDLERS to avoid interference with 
        #TDAQ signal handling
        environ['TDAQ_ERS_NO_SIGNAL_HANDLERS']='1'
        from AthenaCommon.Debugging import allowPtrace, hookDebugger
        allowPtrace()
 
        checkSequenceConsistency(self._sequence)
        
        app = self.createApp()
        self.__verifyFinalSequencesStructure()
 
        #Determine maxEvents
        if maxEvents is None:
            if "EvtMax" in self._theAppProps:
                maxEvents=self._theAppProps["EvtMax"]
            else:
                maxEvents=-1
 
        if self.interactive == 'init':
            printInteractiveMsg_init()
            from sys import exit # noqa: F401
            startInteractive(locals())
 
        #At this point, we don't need the internal structures of this CA any more, clean them up
        self._cleanup()
        
        self._msg.info(f"Athena job with pid {os.getpid()}")
 
        if (self._debugStage.value == "init"):
            hookDebugger()
        sc = app.initialize()
        if not sc.isSuccess():
            self._msg.error("Failed to initialize AppMgr")
            return sc
 
        sc = app.start()
        if not sc.isSuccess():
            self._msg.error("Failed to start AppMgr")
            return sc
 
        if (self._debugStage.value=="exec"):
            hookDebugger()
 
 
        if self.interactive == 'run':
            printInteractiveMsg_run()
            from AthenaPython.PyAthena import py_svc
            sg=py_svc("StoreGateSvc/StoreGateSvc")
            startInteractive(locals())
        else:
            sc = app.run(maxEvents)
            if not sc.isSuccess():
                self._msg.error("Failure running application")
                return sc
 
        scStop=app.stop()
        if not scStop.isSuccess():
            self._msg.error("Failed to stop AppMgr")
            return scStop
 
        if (self._debugStage.value == "fini"):
            hookDebugger()
            
        scFin=app.finalize()
        if not scFin.isSuccess():
            self._msg.error("Failed to finalize AppMgr")
            return scFin
 
        sc1 = app.terminate()
        return sc1
 

◆ setAppProperty()

python.ComponentAccumulator.ComponentAccumulator.setAppProperty	(	self,
		key,
		value,
		overwrite = False )

Definition at line 758 of file ComponentAccumulator.py.

    def setAppProperty(self,key,value,overwrite=False):
        if (overwrite or key not in (self._theAppProps)):
            self._theAppProps[key]=value
        else:
            if self._theAppProps[key] == value:
                self._msg.debug("ApplicationMgr property '%s' already set to '%s'.", key, value)
            elif isinstance(self._theAppProps[key], Sequence) and not isinstance(self._theAppProps[key],str):
                value=self._theAppProps[key] + [el for el in value if el not in self._theAppProps[key]]
                self._msg.info("ApplicationMgr property '%s' already set to '%s'. Overwriting with %s", key, self._theAppProps[key], value)
                self._theAppProps[key]=value
            else:
                raise DeduplicationFailed("AppMgr property {} set twice: {} and {}".format(key, self._theAppProps[key], value))
 
 

◆ setAsTopLevel()

python.ComponentAccumulator.ComponentAccumulator.setAsTopLevel ( self )

Definition at line 128 of file ComponentAccumulator.py.

    def setAsTopLevel(self):
        self._isMergable = False
 

◆ setDebugStage()

python.ComponentAccumulator.ComponentAccumulator.setDebugStage	(		self,
			stage )

Definition at line 772 of file ComponentAccumulator.py.

    def setDebugStage(self,stage):
        if stage not in DbgStage.allowed_values:
            raise RuntimeError("Allowed arguments for setDebugStage are [{}]".format(",".join(DbgStage.allowed_values)))
        self._debugStage.value = stage
 
 

◆ setPrivateTools()

python.ComponentAccumulator.ComponentAccumulator.setPrivateTools	(		self,
			privTool )

Use this method to carry private AlgTool(s) to the caller when returning this ComponentAccumulator.
The method accepts either a single private AlgTool or a list of private AlgTools (typically assigned to ToolHandleArray)

Definition at line 363 of file ComponentAccumulator.py.

    def setPrivateTools(self,privTool):
        """Use this method to carry private AlgTool(s) to the caller when returning this ComponentAccumulator.
        The method accepts either a single private AlgTool or a list of private AlgTools (typically assigned to ToolHandleArray)
        """
        if self._privateTools is not None:
            raise ConfigurationError("This ComponentAccumulator holds already a (list of) private tool(s). "
                                     "Only one (list of) private tool(s) is allowed")
 
        if isinstance(privTool, Sequence):
            for t in privTool:
                if t.__component_type__ != 'AlgTool':
                    raise ConfigurationError("ComponentAccumulator.setPrivateTools accepts only ConfigurableAlgTools "
                                             f"or lists of ConfigurableAlgTools. Encountered {type(t)} in a list")
        else:
            if privTool.__component_type__ != "AlgTool":
                raise ConfigurationError("ComponentAccumulator.setPrivateTools accepts only ConfigurableAlgTools "
                                          f"or lists of ConfigurableAlgTools. Encountered {type(privTool)}")
 
        self._privateTools=privTool
        if "trackPrivateTool" in ComponentAccumulator.debugMode:
            for tool in self._privateTools if isinstance(privTool, Sequence) else [self._privateTools]:
                self._componentsContext[tool.name] = shortCallStack()
 
        return
 

◆ store()

python.ComponentAccumulator.ComponentAccumulator.store	(	self,
		outfile,
		withDefaultHandles = False )

Saves CA in pickle form

when withDefaultHandles is True, also the handles that are not set are saved

Definition at line 950 of file ComponentAccumulator.py.

    def store(self,outfile, withDefaultHandles=False):
        """
        Saves CA in pickle form
 
        when withDefaultHandles is True, also the handles that are not set are saved
        """
 
        checkSequenceConsistency(self._sequence)
        
        self.wasMerged()
        if withDefaultHandles:
            from AthenaConfiguration.Utils import loadDefaultComps, exposeHandles
            loadDefaultComps(self._allComponents())
            exposeHandles(self._allComponents())
        import pickle
        pickle.dump(self,outfile)
        return
 
 

◆ wasMerged()

python.ComponentAccumulator.ComponentAccumulator.wasMerged ( self )

 Declares CA as merged

This is temporarily needed by HLT and should not be used elsewhere

Definition at line 934 of file ComponentAccumulator.py.

    def wasMerged(self):
        """ Declares CA as merged
 
        This is temporarily needed by HLT and should not be used elsewhere
        """
        self._wasMerged=True
 

Member Data Documentation

◆ _algorithms

dict python.ComponentAccumulator.ComponentAccumulator._algorithms = {}

protected

Definition at line 104 of file ComponentAccumulator.py.

◆ _allSequences

python.ComponentAccumulator.ComponentAccumulator._allSequences = [self._sequence]

protected

Definition at line 103 of file ComponentAccumulator.py.

◆ _auditors

python.ComponentAccumulator.ComponentAccumulator._auditors = []

protected

Definition at line 108 of file ComponentAccumulator.py.

◆ _checkUnmerged

bool python.ComponentAccumulator.ComponentAccumulator._checkUnmerged = True

staticprotected

Definition at line 78 of file ComponentAccumulator.py.

◆ _componentsContext

python.ComponentAccumulator.ComponentAccumulator._componentsContext = dict()

protected

Definition at line 124 of file ComponentAccumulator.py.

◆ _conditionsAlgs

python.ComponentAccumulator.ComponentAccumulator._conditionsAlgs = []

protected

Definition at line 105 of file ComponentAccumulator.py.

◆ _creationCallStack

str python.ComponentAccumulator.ComponentAccumulator._creationCallStack = Context.hint if "trackCA" not in ComponentAccumulator.debugMode else shortCallStack()

protected

Definition at line 123 of file ComponentAccumulator.py.

◆ _currentDomain

python.ComponentAccumulator.ComponentAccumulator._currentDomain = None

protected

Definition at line 111 of file ComponentAccumulator.py.

◆ _debugStage

python.ComponentAccumulator.ComponentAccumulator._debugStage = DbgStage()

protected

Definition at line 125 of file ComponentAccumulator.py.

◆ _domainsRegistry

dict python.ComponentAccumulator.ComponentAccumulator._domainsRegistry = {}

protected

Definition at line 112 of file ComponentAccumulator.py.

◆ _isMergable

bool python.ComponentAccumulator.ComponentAccumulator._isMergable = True

protected

Definition at line 121 of file ComponentAccumulator.py.

◆ _lastAddedComponent

str python.ComponentAccumulator.ComponentAccumulator._lastAddedComponent = "Unknown"

protected

Definition at line 122 of file ComponentAccumulator.py.

◆ _msg

python.ComponentAccumulator.ComponentAccumulator._msg = logging.getLogger('ComponentAccumulator')

protected

Definition at line 91 of file ComponentAccumulator.py.

◆ _primaryComp

python.ComponentAccumulator.ComponentAccumulator._primaryComp = None

protected

Definition at line 110 of file ComponentAccumulator.py.

◆ _privateTools

python.ComponentAccumulator.ComponentAccumulator._privateTools = None

protected

Definition at line 109 of file ComponentAccumulator.py.

◆ _publicTools

python.ComponentAccumulator.ComponentAccumulator._publicTools = []

protected

Definition at line 117 of file ComponentAccumulator.py.

◆ _sequence

python.ComponentAccumulator.ComponentAccumulator._sequence = sequence

protected

Definition at line 102 of file ComponentAccumulator.py.

◆ _services

python.ComponentAccumulator.ComponentAccumulator._services = []

protected

Definition at line 106 of file ComponentAccumulator.py.

◆ _servicesToCreate

list python.ComponentAccumulator.ComponentAccumulator._servicesToCreate = []

protected

Definition at line 107 of file ComponentAccumulator.py.

◆ _theAppProps

python.ComponentAccumulator.ComponentAccumulator._theAppProps = dict()

protected

Definition at line 114 of file ComponentAccumulator.py.

◆ _wasMerged

bool python.ComponentAccumulator.ComponentAccumulator._wasMerged = False

protected

Definition at line 120 of file ComponentAccumulator.py.

◆ debugMode

str python.ComponentAccumulator.ComponentAccumulator.debugMode = ""

static

Definition at line 77 of file ComponentAccumulator.py.

◆ interactive

str python.ComponentAccumulator.ComponentAccumulator.interactive = ""

Definition at line 126 of file ComponentAccumulator.py.

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

ComponentAccumulator.py

Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

◆ __del__()

Member Function Documentation

◆ __getOne()

◆ __getstate__()

◆ __setstate__()

◆ __verifyFinalSequencesStructure()

◆ _allComponents()

◆ _cacheEvict()

◆ _cleanup()

◆ _inspect()

◆ addAlgToPerfmonDomains()

◆ addAuditor()

◆ addCondAlgo()

◆ addEventAlgo()

◆ addPublicTool()

◆ addSequence()

◆ addService()

◆ createApp()

◆ dropAuditor()

◆ dropCondAlgo()

◆ dropEventAlgo()

◆ dropPublicTool()

◆ dropService()

◆ empty()

◆ flagPerfmonDomain()

◆ foreach_component()

◆ gatherProps()

◆ getAlgPerfmonDomain()

◆ getAppProps()

◆ getAuditor()

◆ getCondAlgo()

◆ getCondAlgos()

◆ getCurrentPerfmonDomain()

◆ getEventAlgo()

◆ getEventAlgos()

◆ getInvertedPerfmonDomains()

◆ getIO()

◆ getPrimary()

◆ getPrimaryAndMerge()

◆ getPublicTool()

◆ getPublicTools()

◆ getSequence()

◆ getService()

◆ getServices()

◆ merge()

◆ popEventAlgo()

◆ popPrivateTools()

◆ popToolsAndMerge()

◆ printCondAlgs()

◆ printConfig()

◆ printPerfmonDomains()

◆ run()

◆ setAppProperty()

◆ setAsTopLevel()

◆ setDebugStage()

◆ setPrivateTools()

◆ store()

◆ wasMerged()

Member Data Documentation

◆ _algorithms

◆ _allSequences

◆ _auditors

◆ _checkUnmerged

◆ _componentsContext

◆ _conditionsAlgs

◆ _creationCallStack

◆ _currentDomain

◆ _debugStage

◆ _domainsRegistry

◆ _isMergable

◆ init()

◆ del()

◆ getstate()

◆ setstate()