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:
  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 1199 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()

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