ATLAS Offline Software
Public Member Functions | Private Attributes | List of all members
python.ConfigSequence.ConfigSequence Class Reference
Collaboration diagram for python.ConfigSequence.ConfigSequence:

Public Member Functions

def __init__ (self)
 
def append (self, block)
 
def makeAlgs (self, config)
 
def reorderAlgs (self)
 
def fullConfigure (self, config)
 
def setOptionValue (self, name, value, **kwargs)
 
def printOptions (self, verbose=False)
 
def getOptions (self)
 
def setOptions (self, options)
 
def groupBlocks (self, groupName='')
 
def __iadd__ (self, sequence, index=None)
 
def __iter__ (self)
 

Private Attributes

 _blocks
 

Detailed Description

a sequence of ConfigBlock objects

This could in principle just be a simple python list, and maybe we
change it to that at some point (10 Mar 22).  Having it as its own
class allows to implement some helper functions.

This implements an interface similar to ConfigBlock, but it
doesn't derive from it, as ConfigBlock will likely gain
functionality in the future that wouldn't work for a sequence (or
wouldn't work in the same way).

Definition at line 45 of file ConfigSequence.py.

Constructor & Destructor Documentation

◆ __init__()

def python.ConfigSequence.ConfigSequence.__init__ (   self)

Definition at line 59 of file ConfigSequence.py.

59  def __init__ (self) :
60  self._blocks = []
61 
62 

Member Function Documentation

◆ __iadd__()

def python.ConfigSequence.ConfigSequence.__iadd__ (   self,
  sequence,
  index = None 
)
Add another sequence to this one

This function is used to add another sequence to this sequence
using the '+=' operator.

Definition at line 257 of file ConfigSequence.py.

257  def __iadd__( self, sequence, index = None ):
258  """Add another sequence to this one
259 
260  This function is used to add another sequence to this sequence
261  using the '+=' operator.
262  """
263  # Check that the received object is of the right type:
264  if not isinstance( sequence, ConfigSequence ):
265  raise TypeError( 'The received object is not of type ConfigSequence' )
266 
267  for block in sequence._blocks :
268  self._blocks.append (block)
269 
270  # Return the modified object:
271  return self
272 
273 

◆ __iter__()

def python.ConfigSequence.ConfigSequence.__iter__ (   self)
Create an iterator over all the configurations in this sequence

This is to allow for a Python-like iteration over all
configuration blocks that are part of the sequence.

Definition at line 274 of file ConfigSequence.py.

274  def __iter__( self ):
275  """Create an iterator over all the configurations in this sequence
276 
277  This is to allow for a Python-like iteration over all
278  configuration blocks that are part of the sequence.
279  """
280  # Create the iterator to process the internal list of algorithms:
281  return self._blocks.__iter__()

◆ append()

def python.ConfigSequence.ConfigSequence.append (   self,
  block 
)
append a configuration block to the sequence

Definition at line 63 of file ConfigSequence.py.

63  def append (self, block) :
64  """append a configuration block to the sequence"""
65  self._blocks.append (block)
66 
67 

◆ fullConfigure()

def python.ConfigSequence.ConfigSequence.fullConfigure (   self,
  config 
)
do the full configuration on this sequence

This sequence needs to be the only sequence, i.e. it needs to
contain all the blocks that will be configured, as it will
perform all configuration steps at once.

Definition at line 129 of file ConfigSequence.py.

129  def fullConfigure (self, config) :
130  """do the full configuration on this sequence
131 
132  This sequence needs to be the only sequence, i.e. it needs to
133  contain all the blocks that will be configured, as it will
134  perform all configuration steps at once.
135  """
136  self.reorderAlgs()
137  self.makeAlgs (config)
138  config.nextPass ()
139  self.makeAlgs (config)
140 
141 

◆ getOptions()

def python.ConfigSequence.ConfigSequence.getOptions (   self)
get information on options for last block in sequence

Definition at line 199 of file ConfigSequence.py.

199  def getOptions(self):
200  """get information on options for last block in sequence"""
201  # get groupName for last added block
202  groupName = self._blocks[-1].getOptionValue('groupName')
203  blocks = [self._blocks[-1]]
204  # get all blocks with the same groupName
205  if groupName:
206  for block in self._blocks[:-1]:
207  if block.getOptionValue('groupName') == groupName:
208  blocks.append(block)
209  options = []
210  # get options for all blocks with same groupName
211  for block in blocks:
212  for name, o in block.getOptions().items():
213  val = getattr(block, name)
214  valDefault = o.default
215  valType = o.type
216  valRequired = o.required
217  noneAction = o.noneAction
218  options.append({'name': name, 'defaultValue': valDefault,
219  'type': valType, 'required': valRequired,
220  'noneAction': noneAction, 'value': val})
221  return options
222 
223 

◆ groupBlocks()

def python.ConfigSequence.ConfigSequence.groupBlocks (   self,
  groupName = '' 
)
Assigns all blocks in configSequence groupName. If no name is
provided, the name is set to group_ plus an integer.

Blocks with the same groupName can be configured together.

Definition at line 244 of file ConfigSequence.py.

244  def groupBlocks(self, groupName=''):
245  """
246  Assigns all blocks in configSequence groupName. If no name is
247  provided, the name is set to group_ plus an integer.
248 
249  Blocks with the same groupName can be configured together.
250  """
251  if not groupName:
252  groupName = f"group_{randrange(10**8):08}"
253  for block in self._blocks:
254  block.setOptionValue('groupName', groupName)
255 
256 

◆ makeAlgs()

def python.ConfigSequence.ConfigSequence.makeAlgs (   self,
  config 
)
call makeAlgs() on all blocks

This will create the actual algorithm configurables based on
how the blocks are configured right now.

Definition at line 68 of file ConfigSequence.py.

68  def makeAlgs (self, config) :
69  """call makeAlgs() on all blocks
70 
71  This will create the actual algorithm configurables based on
72  how the blocks are configured right now.
73  """
74  for block in self._blocks:
75  if block.skipOnData and config.dataType() is DataType.Data:
76  continue
77  if block.skipOnMC and config.dataType() is not DataType.Data:
78  continue
79  if not filter_dsids(block.onlyForDSIDs, config):
80  continue
81  block.makeAlgs (config)
82 

◆ printOptions()

def python.ConfigSequence.ConfigSequence.printOptions (   self,
  verbose = False 
)
Prints options and their values for each config block in a config sequence

Definition at line 190 of file ConfigSequence.py.

190  def printOptions(self, verbose=False):
191  """
192  Prints options and their values for each config block in a config sequence
193  """
194  for config in self:
195  logCPAlgCfgSeq.info(config.__class__.__name__)
196  config.printOptions(verbose=verbose)
197 
198 

◆ reorderAlgs()

def python.ConfigSequence.ConfigSequence.reorderAlgs (   self)
Check for blocks with dependencies.

If a block required another block that is not present, will
throw an error; Otherwise, will move block immediately after
required block. If dependency is not required, will move
after other block, if it is present.

Note: this implementation can only move blocks forward.

Definition at line 83 of file ConfigSequence.py.

83  def reorderAlgs(self):
84  """
85  Check for blocks with dependencies.
86 
87  If a block required another block that is not present, will
88  throw an error; Otherwise, will move block immediately after
89  required block. If dependency is not required, will move
90  after other block, if it is present.
91 
92  Note: this implementation can only move blocks forward.
93  """
94  def moveBlock(blocks):
95  for i, block in enumerate(blocks):
96  # the 'ignoreDependencies' option is added with a dep.
97  ignore = block.getOptionValue('ignoreDependencies')
98  if block.hasDependencies():
99  depIdx = i
100  for dep in block.getDependencies():
101  if dep in ignore:
102  continue
103  # find dep with largest idx
104  if dep in blocks:
105  lastIdx = max(index for index,value in enumerate(blocks) if value == dep.blockName)
106  if lastIdx > depIdx:
107  depIdx = lastIdx
108  elif dep.required:
109  raise ValueError(f"{dep} block is required"
110  f" for {block} but was not found.")
111  # check to see if block is already infront of deps
112  if depIdx > i:
113  logCPAlgCfgSeq.info(f"Moving {block} after {blocks[depIdx]}")
114  # depIdx > i so after pop, depIdx -= 1 -> depIdx is after dep
115  blocks.insert(depIdx, blocks.pop(i))
116  return False
117  # nothing to move
118  return True
119  MAXTRIES = 1000
120  for _ in range(MAXTRIES):
121  if moveBlock(self._blocks):
122  # sorted
123  break
124  else:
125  raise Exception("Could not order blocks based on dependencies"
126  f" in {MAXTRIES} moves.")
127 
128 

◆ setOptions()

def python.ConfigSequence.ConfigSequence.setOptions (   self,
  options 
)
Set options for a ConfigBlock

Definition at line 224 of file ConfigSequence.py.

224  def setOptions(self, options):
225  """Set options for a ConfigBlock"""
226  algOptions = self.getOptions()
227  for opt in algOptions:
228  name = opt['name']
229  if name in options:
230  self.setOptionValue (f'.{name}', options[name])
231  logCPAlgCfgSeq.info(f" {name}: {options[name]}")
232  else:
233  if opt['required']:
234  raise ValueError(f'{name} is required but not included in config')
235  # add default used to config
236  defaultVal = opt['defaultValue']
237  # do not overwright groupName unless set by user
238  if name != 'groupName':
239  options[name] = defaultVal
240  logCPAlgCfgSeq.info(f" {name}: {defaultVal}")
241  return algOptions
242 
243 

◆ setOptionValue()

def python.ConfigSequence.ConfigSequence.setOptionValue (   self,
  name,
  value,
**  kwargs 
)
set the given option on the sequence

The name should generally be of the form
"groupName.optionName" to identify what group the option
belongs to.

For simplicity I also allow a ".optionName" here, which will
then set the property in the last group added.  That makes it
fairly straightforward to add new blocks, set options on them,
and then move on to the next blocks.  Please note that this
mechanism ought to be viewed as strictly as a temporary
convenience, and this short cut may go away once better
alternatives are available.

WARNING: The backend to option handling is slated to be
replaced at some point.  This particular function may change
behavior, interface or be removed/replaced entirely.

Definition at line 142 of file ConfigSequence.py.

142  def setOptionValue (self, name, value, **kwargs) :
143  """set the given option on the sequence
144 
145  The name should generally be of the form
146  "groupName.optionName" to identify what group the option
147  belongs to.
148 
149  For simplicity I also allow a ".optionName" here, which will
150  then set the property in the last group added. That makes it
151  fairly straightforward to add new blocks, set options on them,
152  and then move on to the next blocks. Please note that this
153  mechanism ought to be viewed as strictly as a temporary
154  convenience, and this short cut may go away once better
155  alternatives are available.
156 
157  WARNING: The backend to option handling is slated to be
158  replaced at some point. This particular function may change
159  behavior, interface or be removed/replaced entirely.
160  """
161  names = name.split('.')
162  # <optionName>
163  optionName = names.pop(-1)
164  # <groupName>.<optionName>, or
165  # .<optionName> (backwards compatability)
166  groupName = names.pop(0) if names else ''
167  if names:
168  raise ValueError(f'Option name can be either <groupName>.<optionName>'
169  f' or <optionName> not {name}')
170  blocks = self._blocks
171  # check if last block added has an instance name
172  if not groupName:
173  groupName = blocks[-1].getOptionValue('groupName')
174  if groupName:
175  used = False
176  # set optionName for all blocks with groupName
177  for block in blocks:
178  if ( block.getOptionValue('groupName') == groupName
179  and block.hasOption(optionName) ):
180  block.setOptionValue (optionName, value, **kwargs)
181  used = True
182  if not used:
183  raise ValueError(f'{optionName} not found in blocks with '
184  f'group name {groupName}')
185  else:
186  # set opyion for last added block
187  blocks[-1].setOptionValue (optionName, value, **kwargs)
188 
189 

Member Data Documentation

◆ _blocks

python.ConfigSequence.ConfigSequence._blocks
private

Definition at line 60 of file ConfigSequence.py.


The documentation for this class was generated from the following file:
python.ConfigSequence.filter_dsids
def filter_dsids(filterList, config)
Definition: ConfigSequence.py:28
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
python.Bindings.__iter__
__iter__
Definition: Control/AthenaPython/python/Bindings.py:791
dumpHVPathFromNtuple.append
bool append
Definition: dumpHVPathFromNtuple.py:91
python.ConfigSequence.groupBlocks
def groupBlocks(func)
Definition: ConfigSequence.py:10
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:195
TrigJetMonitorAlgorithm.items
items
Definition: TrigJetMonitorAlgorithm.py:79
python.processes.powheg.ZZ.ZZ.__init__
def __init__(self, base_directory, **kwargs)
Constructor: all process options are set here.
Definition: ZZ.py:18
FlavorTagDiscriminants::getOptions
GNNOptions getOptions(const GNNToolProperties &)
Definition: GNNToolifiers.cxx:24