Inheritance diagram for python.ComponentAccumulator.ComponentAccumulator:

Collaboration diagram for python.ComponentAccumulator.ComponentAccumulator:

Public Member Functions
def	__init__ (self, sequence='AthAlgSeq')

def	setAsTopLevel (self)

def	empty (self)

def	__del__ (self)

def	__getstate__ (self)

def	__setstate__ (self, state)

def	printCondAlgs (self, summariseProps=False, onlyComponents=[], printDefaults=False, printComponentsOnly=False)

def	printConfig (self, withDetails=False, summariseProps=False, onlyComponents=[], printDefaults=False, printComponentsOnly=False, printSequenceTreeOnly=False, prefix=None)

def	getIO (self)

def	addSequence (self, newseq, primary=False, parentName=None)

def	getSequence (self, sequenceName=None)

def	setPrivateTools (self, privTool)

def	popPrivateTools (self, quiet=False)

def	popToolsAndMerge (self, other)

def	getCurrentPerfmonDomain (self)

def	flagPerfmonDomain (self, name)

def	getInvertedPerfmonDomains (self)

def	getAlgPerfmonDomain (self, name)

def	addAlgToPerfmonDomains (self, name, domain, overwrite=False)

def	printPerfmonDomains (self)

def	addEventAlgo (self, algorithms, sequenceName=None, primary=False, domain=None)

def	getEventAlgo (self, name=None)

def	getEventAlgos (self, seqName=None)

def	addCondAlgo (self, algo, primary=False, domain=None)

def	getCondAlgos (self)

def	getCondAlgo (self, name)

def	addService (self, newSvc, primary=False, create=False)

def	addAuditor (self, auditor)

def	addPublicTool (self, newTool, primary=False)

def	getPrimary (self)

def	getPrimaryAndMerge (self, other)

def	getPublicTools (self)

def	getPublicTool (self, name=None)

def	getServices (self)

def	getService (self, name=None)

def	getAuditor (self, name)

def	dropEventAlgo (self, name, sequence="AthAlgSeq")

def	popEventAlgo (self, name, sequence="AthAlgSeq")

def	dropCondAlgo (self, name)

def	dropService (self, name)

def	dropPublicTool (self, name)

def	dropAuditor (self, name)

def	getAppProps (self)

def	setAppProperty (self, key, value, overwrite=False)

def	setDebugStage (self, stage)

def	merge (self, other, sequenceName=None)

def	wasMerged (self)

def	store (self, outfile, withDefaultHandles=False)

def	createApp (self)

def	gatherProps (self)

def	run (self, maxEvents=None)

def	foreach_component (self, path)

Public Attributes
	interactive

Static Public Attributes
	debugMode

Private Member Functions
def	_inspect (self)

def	_cleanup (self)

def	_cacheEvict (self)

def	__getOne (self, allcomps, name=None, typename="???")

def	__verifyFinalSequencesStructure (self)

def	_allComponents (self)

Static Private Attributes
	_checkUnmerged

Detailed Description

Definition at line 89 of file ComponentAccumulator.py.

Constructor & Destructor Documentation

◆ init()

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

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

def python.ComponentAccumulator.ComponentAccumulator.__del__ ( self )

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

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

private

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

def python.ComponentAccumulator.ComponentAccumulator.__getstate__ ( self )

Definition at line 203 of file ComponentAccumulator.py.

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

◆ setstate()

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

Definition at line 209 of file ComponentAccumulator.py.

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

◆ __verifyFinalSequencesStructure()

def python.ComponentAccumulator.ComponentAccumulator.__verifyFinalSequencesStructure ( self )

private

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

def python.ComponentAccumulator.ComponentAccumulator._allComponents ( self )

private

returns iterable over all components

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

def python.ComponentAccumulator.ComponentAccumulator._cacheEvict ( self )

private

Called by AccumulatorCache when deleting item from cache

Definition at line 198 of file ComponentAccumulator.py.

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

◆ _cleanup()

def python.ComponentAccumulator.ComponentAccumulator._cleanup ( self )

private

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

def python.ComponentAccumulator.ComponentAccumulator._inspect ( self )

private

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

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

Add the algorithm to the domains registry.

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

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

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

Add Conditions algorithm

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

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

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

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

Add public tool and return the deduplicated instance.

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

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

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

Add service and return the deduplicated instance

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

def python.ComponentAccumulator.ComponentAccumulator.createApp ( self )

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

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

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

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

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

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

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

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

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

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

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

def python.ComponentAccumulator.ComponentAccumulator.empty ( self )

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

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

Mark the beginning of a new PerfMon domain.

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

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

Utility to set properties of components using wildcards

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

The components name & locations in the CF tree are translated into the unix like path.
Components of matching path are taken under consideration in setting the property.
If the property is set successfully an INFO message is printed. Else, a warning is printed.

The convention for path of nested components is as follows:
Sequencer - only the name is used in the path
Algorithm - full name - type/instance_name (aka full name) is used
PrivateTools - the name of the property + the type/instance_name are added
PublicTools - are located under ToolSvc/ and type/instance_name is used
Services - located under SvcMgr/ and type/instance_name is used

Definition at line 1199 of file ComponentAccumulator.py.

     def foreach_component(self, path):
         """ Utility to set properties of components using wildcards
  
         Example:
         forcomps(ca, "*/HLTTop/*/*Hypo*").OutputLevel=VERBOSE
  
         The components name & locations in the CF tree are translated into the unix like path.
         Components of matching path are taken under consideration in setting the property.
         If the property is set successfully an INFO message is printed. Else, a warning is printed.
  
         The convention for path of nested components is as follows:
         Sequencer - only the name is used in the path
         Algorithm - full name - type/instance_name (aka full name) is used
         PrivateTools - the name of the property + the type/instance_name are added
         PublicTools - are located under ToolSvc/ and type/instance_name is used
         Services - located under SvcMgr/ and type/instance_name is used
         """
         from AthenaConfiguration.PropSetterProxy import PropSetterProxy
         return PropSetterProxy(self, path)
  
  

◆ gatherProps()

def python.ComponentAccumulator.ComponentAccumulator.gatherProps ( self )

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

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

Return the PerfMon domain of the given algorithm

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

def python.ComponentAccumulator.ComponentAccumulator.getAppProps ( self )

Definition at line 771 of file ComponentAccumulator.py.

     def getAppProps(self):
         return self._theAppProps
  

◆ getAuditor()

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

Retuns a single auditor, exception if not found

Definition at line 697 of file ComponentAccumulator.py.

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

◆ getCondAlgo()

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

Get conditions algorithm by name

Definition at line 578 of file ComponentAccumulator.py.

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

◆ getCondAlgos()

def python.ComponentAccumulator.ComponentAccumulator.getCondAlgos ( self )

Get all conditions algorithms

Definition at line 574 of file ComponentAccumulator.py.

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

◆ getCurrentPerfmonDomain()

def python.ComponentAccumulator.ComponentAccumulator.getCurrentPerfmonDomain ( self )

Get the current PerfMon domain.

Definition at line 426 of file ComponentAccumulator.py.

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

◆ getEventAlgo()

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

Get algorithm with `name`

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

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

Get all algorithms within sequence

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

def python.ComponentAccumulator.ComponentAccumulator.getInvertedPerfmonDomains ( self )

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

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

def 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 296 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.split("#")[0],
                             "key": i.split("#")[1],
                             "comp": comp.getFullJobOptName(),
                             "mode":  "R",
                             "prop": "ExtraInputs"})
             for i in comp.ExtraOutputs:
                 io.append({"type": i.split("#")[0],
                             "key": i.split("#")[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()

def python.ComponentAccumulator.ComponentAccumulator.getPrimary ( self )

Get designated primary component

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

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

Merging in the other accumulator and getting the primary component

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

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

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

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

def python.ComponentAccumulator.ComponentAccumulator.getPublicTools ( self )

Definition at line 680 of file ComponentAccumulator.py.

     def getPublicTools(self):
         return self._publicTools
  

◆ getSequence()

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

Definition at line 373 of file ComponentAccumulator.py.

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

◆ getService()

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

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

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

def python.ComponentAccumulator.ComponentAccumulator.getServices ( self )

Definition at line 687 of file ComponentAccumulator.py.

     def getServices(self):
         return self._services
  

◆ merge()

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

Merging in the other accumulator

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

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

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

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

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

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

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

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

Definition at line 215 of file ComponentAccumulator.py.

     def printCondAlgs(self, summariseProps=False, onlyComponents=[], printDefaults=False, printComponentsOnly=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, printComponentsOnly)
         return
  
  

◆ printConfig()

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

Definition at line 228 of file ComponentAccumulator.py.

     def printConfig(self, withDetails=False, summariseProps=False,
                     onlyComponents = [], printDefaults=False, printComponentsOnly=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, printComponentsOnly)
  
  
         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, printComponentsOnly)
         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, printComponentsOnly)
         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()

def python.ComponentAccumulator.ComponentAccumulator.printPerfmonDomains ( self )

Print the PerfMon domains.

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

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

Definition at line 1116 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
  
         app.stop().ignore()
  
         if (self._debugStage.value == "fini"):
             hookDebugger()
         app.finalize().ignore()
  
         sc1 = app.terminate()
         return sc1
  

◆ setAppProperty()

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

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

def python.ComponentAccumulator.ComponentAccumulator.setAsTopLevel ( self )

Definition at line 144 of file ComponentAccumulator.py.

     def setAsTopLevel(self):
         self._isMergable = False
  

◆ setDebugStage()

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

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

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

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

def python.ComponentAccumulator.ComponentAccumulator.wasMerged ( self )

Declares CA as merged

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

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

python.ComponentAccumulator.ComponentAccumulator._algorithms

private

Definition at line 120 of file ComponentAccumulator.py.

◆ _allSequences

python.ComponentAccumulator.ComponentAccumulator._allSequences

private

Definition at line 119 of file ComponentAccumulator.py.

◆ _auditors

python.ComponentAccumulator.ComponentAccumulator._auditors

private

Definition at line 124 of file ComponentAccumulator.py.

◆ _checkUnmerged

python.ComponentAccumulator.ComponentAccumulator._checkUnmerged

staticprivate

Definition at line 94 of file ComponentAccumulator.py.

◆ _componentsContext

python.ComponentAccumulator.ComponentAccumulator._componentsContext

private

Definition at line 140 of file ComponentAccumulator.py.

◆ _conditionsAlgs

python.ComponentAccumulator.ComponentAccumulator._conditionsAlgs

private

Definition at line 121 of file ComponentAccumulator.py.

◆ _creationCallStack

python.ComponentAccumulator.ComponentAccumulator._creationCallStack

private

Definition at line 139 of file ComponentAccumulator.py.

◆ _currentDomain

python.ComponentAccumulator.ComponentAccumulator._currentDomain

private

Definition at line 127 of file ComponentAccumulator.py.

◆ _debugStage

python.ComponentAccumulator.ComponentAccumulator._debugStage

private

Definition at line 141 of file ComponentAccumulator.py.

◆ _domainsRegistry

python.ComponentAccumulator.ComponentAccumulator._domainsRegistry

private

Definition at line 128 of file ComponentAccumulator.py.

◆ _isMergable

python.ComponentAccumulator.ComponentAccumulator._isMergable

private

Definition at line 137 of file ComponentAccumulator.py.

◆ _lastAddedComponent

python.ComponentAccumulator.ComponentAccumulator._lastAddedComponent

private

Definition at line 138 of file ComponentAccumulator.py.

◆ _msg

python.ComponentAccumulator.ComponentAccumulator._msg

private

Definition at line 107 of file ComponentAccumulator.py.

◆ _primaryComp

python.ComponentAccumulator.ComponentAccumulator._primaryComp

private

Definition at line 126 of file ComponentAccumulator.py.

◆ _privateTools

python.ComponentAccumulator.ComponentAccumulator._privateTools

private

Definition at line 125 of file ComponentAccumulator.py.

◆ _publicTools

python.ComponentAccumulator.ComponentAccumulator._publicTools

private

Definition at line 133 of file ComponentAccumulator.py.

◆ _sequence

python.ComponentAccumulator.ComponentAccumulator._sequence

private

Definition at line 118 of file ComponentAccumulator.py.

◆ _services

python.ComponentAccumulator.ComponentAccumulator._services

private

Definition at line 122 of file ComponentAccumulator.py.

◆ _servicesToCreate

python.ComponentAccumulator.ComponentAccumulator._servicesToCreate

private

Definition at line 123 of file ComponentAccumulator.py.

◆ _theAppProps

python.ComponentAccumulator.ComponentAccumulator._theAppProps

private

Definition at line 130 of file ComponentAccumulator.py.

◆ _wasMerged

python.ComponentAccumulator.ComponentAccumulator._wasMerged

private

Definition at line 136 of file ComponentAccumulator.py.

◆ debugMode

python.ComponentAccumulator.ComponentAccumulator.debugMode

static

Definition at line 93 of file ComponentAccumulator.py.

◆ interactive

python.ComponentAccumulator.ComponentAccumulator.interactive

Definition at line 142 of file ComponentAccumulator.py.

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

ComponentAccumulator.py

Private Attributes
	_msg

	_sequence

	_allSequences

	_algorithms

	_conditionsAlgs

	_services

	_servicesToCreate

	_auditors

	_privateTools

	_primaryComp

	_currentDomain

	_domainsRegistry

	_theAppProps

	_publicTools

	_wasMerged

	_isMergable

	_lastAddedComponent

	_creationCallStack

	_componentsContext

	_debugStage

Public Member Functions

Public Attributes

Static Public Attributes

Private Member Functions

Private Attributes

Static Private Attributes

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

◆ _lastAddedComponent

◆ init()

◆ del()

◆ getstate()

◆ setstate()