python.ConfigBlock.ConfigBlock Class Reference

Collaboration diagram for python.ConfigBlock.ConfigBlock:

Public Member Functions
def	__init__ (self)
def	setBlockName (self, name)
def	getBlockName (self, name)
def	addDependency (self, dependencyName, required=True)
def	hasDependencies (self)
def	getDependencies (self)
def	addOption (self, name, defaultValue, *type, info='', noneAction='ignore', required=False)
def	setOptionValue (self, name, value)
def	getOptionValue (self, name)
def	getOptions (self)
def	printOptions (self, verbose=False, width=60, indent=" ")
def	hasOption (self, name)
def	__eq__ (self, blockName)
def	__str__ (self)

Private Attributes
	_blockName
	_dependencies
	_options

Detailed Description

the base class for classes implementing individual blocks of
configuration

A configuration block is a sequence of one or more algorithms that
should always be scheduled together, e.g. the muon four momentum
corrections could be a single block, muon selection could then be
another block.  The blocks themselves generally have their own
configuration options/properties specific to the block, and will
perform a dynamic configuration based on those options as well as
the overall job.

The actual configuration of the algorithms in the block will
depend on what other blocks are scheduled before and afterwards,
most importantly some algorithms will introduce shallow copies
that subsequent algorithms will need to run on, and some
algorithms will add selection decorations that subquent algorithms
should use as preselections.

The algorithms get created in a multi-step process (that may be
extended in the future): As a first step each block retrieves
references to the containers it uses (essentially marking its spot
in the processing chain) and also registering any shallow copies
that will be made.  In the second/last step each block then
creates the fully configured algorithms.

One goal is that when the algorithms get created they will have
their final configuration and there needs to be no
meta-configuration data attached to the algorithms, essentially an
inversion of the approach in AnaAlgSequence in which the
algorithms got created first with associated meta-configuration
and then get modified in susequent configuration steps.

For now this is mostly an empty base class, but another goal of
this approach is to make it easier to build another configuration
layer on top of this one, and this class will likely be extended
and get data members at that point.

The child class needs to implement two methods,
`collectReferences` and `makeAlgs` which are each given a single
`ConfigAccumulator` type argument.  The first is for the first
configuration step, and should only collect references to the
containers to be used.  The second is for the second configuration
step, and should create the actual algorithms.

Definition at line 42 of file ConfigBlock.py.

Constructor & Destructor Documentation

__init__()

def python.ConfigBlock.ConfigBlock.__init__

(

self

)

Definition at line 89 of file ConfigBlock.py.

    def __init__ (self) :
        self._blockName = ''
        self._dependencies = []
        self._options = {}
        # used with block configuration to set arbitrary option
        self.addOption('groupName', '', type=str,
            info=('Used to specify this block when setting an'
                ' option at an arbitrary location.'))
        self.addOption('skipOnData', False, type=bool,
            info=('User option to prevent the block from running'
                  ' on data. This only affects blocks that are'
                  ' intended to run on data.'))
        self.addOption('skipOnMC', False, type=bool,
            info=('User option to prevent the block from running'
                  ' on MC. This only affects blocks that are'
                  ' intended to run on MC.'))
        self.addOption('onlyForDSIDs', [], type=list,
            info=('Used to specify which MC DSIDs to allow this'
                  ' block to run on. Each element of the list'
                  ' can be a full DSID (e.g. 410470), or a regex'
                  ' (e.g. 410.* to select all 410xxx DSIDs, or'
                  ' ^(?!410) to veto them). An empty list means no'
                  ' DSID restriction.'))
 
 

Member Function Documentation

__eq__()

def python.ConfigBlock.ConfigBlock.__eq__	(		self,
			blockName
	)

Implementation of == operator. Used for seaching configSeque.
E.g. if blockName in configSeq:

Definition at line 238 of file ConfigBlock.py.

    def __eq__(self, blockName):
        """
        Implementation of == operator. Used for seaching configSeque.
        E.g. if blockName in configSeq:
        """
        return self._blockName == blockName
 
 

__str__()

def python.ConfigBlock.ConfigBlock.__str__

(

self

)

Definition at line 246 of file ConfigBlock.py.

    def __str__(self):
        return self._blockName

addDependency()

def python.ConfigBlock.ConfigBlock.addDependency	(		self,
			dependencyName,
			required = True
	)

Add a dependency for the block. Dependency is corresponds to the
blockName of another block. If required is True, will throw an
error if dependency is not present; otherwise will move this
block after the required block. If required is False, will do
nothing if required block is not present; otherwise, it will
move block after required block.

Definition at line 122 of file ConfigBlock.py.

    def addDependency(self, dependencyName, required=True):
        """
        Add a dependency for the block. Dependency is corresponds to the
        blockName of another block. If required is True, will throw an
        error if dependency is not present; otherwise will move this
        block after the required block. If required is False, will do
        nothing if required block is not present; otherwise, it will
        move block after required block.
        """
        if not self.hasDependencies():
            # add option to block ignore dependencies
            self.addOption('ignoreDependencies', [], type=list,
                           info='List of dependencies defined in the ConfigBlock to ignore.')
        self._dependencies.append(ConfigBlockDependency(dependencyName, required))
 

addOption()

def python.ConfigBlock.ConfigBlock.addOption	(		self,
			name,
			defaultValue,
		*	type,
			info = '',
			noneAction = 'ignore',
			required = False
	)

declare the given option on the configuration block

This should only be called in the constructor of the
configuration block.

NOTE: The backend to option handling is slated to be replaced
at some point.  This particular function should essentially
stay the same, but some behavior may change.

Definition at line 145 of file ConfigBlock.py.

    def addOption (self, name, defaultValue, *,
            type, info='', noneAction='ignore', required=False) :
        """declare the given option on the configuration block
 
        This should only be called in the constructor of the
        configuration block.
 
        NOTE: The backend to option handling is slated to be replaced
        at some point.  This particular function should essentially
        stay the same, but some behavior may change.
        """
        if name in self._options :
            raise KeyError (f'duplicate option: {name}')
        if type not in [str, bool, int, float, list, None] :
            raise TypeError (f'unknown option type: {type}')
        noneActions = ['error', 'set', 'ignore']
        if noneAction not in noneActions :
            raise ValueError (f'invalid noneAction: {noneAction} [allowed values: {noneActions}]')
        setattr (self, name, defaultValue)
        self._options[name] = ConfigBlockOption(type=type, info=info,
            noneAction=noneAction, required=required, default=defaultValue)
 
 

getBlockName()

def python.ConfigBlock.ConfigBlock.getBlockName	(		self,
			name
	)

Get blockName

Definition at line 118 of file ConfigBlock.py.

    def getBlockName(self, name):
        """Get blockName"""
        return self._blockName
 

getDependencies()

def python.ConfigBlock.ConfigBlock.getDependencies

(

self

)

Return the list of dependencies. 

Definition at line 141 of file ConfigBlock.py.

    def getDependencies(self):
        """Return the list of dependencies. """
        return self._dependencies
 

getOptions()

def python.ConfigBlock.ConfigBlock.getOptions

(

self

)

Return a copy of the options associated with the block

Definition at line 201 of file ConfigBlock.py.

    def getOptions(self):
        """Return a copy of the options associated with the block"""
        return self._options.copy()
 
 

getOptionValue()

def python.ConfigBlock.ConfigBlock.getOptionValue	(		self,
			name
	)

Returns config option value, if present; otherwise return None

Definition at line 195 of file ConfigBlock.py.

    def getOptionValue(self, name):
        """Returns config option value, if present; otherwise return None"""
        if name in self._options:
            return getattr(self, name)
 
 

hasDependencies()

def python.ConfigBlock.ConfigBlock.hasDependencies

(

self

)

Return True if there is a dependency.

Definition at line 137 of file ConfigBlock.py.

    def hasDependencies(self):
        """Return True if there is a dependency."""
        return bool(self._dependencies)
 

hasOption()

def python.ConfigBlock.ConfigBlock.hasOption	(		self,
			name
	)

whether the configuration block has the given option

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 228 of file ConfigBlock.py.

    def hasOption (self, name) :
        """whether the configuration block has the given option
 
        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.
        """
        return name in self._options
 
 

printOptions()

def python.ConfigBlock.ConfigBlock.printOptions	(		self,
			verbose = False,
			width = 60,
			indent = "    "
	)

Prints options and their values

Definition at line 206 of file ConfigBlock.py.

    def printOptions(self, verbose=False, width=60, indent="    "):
        """
        Prints options and their values
        """
        def printWrap(text, width=60, indent="    "):
            wrapper = textwrap.TextWrapper(width=width, initial_indent=indent,
                subsequent_indent=indent)
            for line in wrapper.wrap(text=text):
                logCPAlgCfgBlock.info(line)
 
        for opt, vals in self.getOptions().items():
            if verbose:
                logCPAlgCfgBlock.info(indent + f"\033[4m{opt}\033[0m: {self.getOptionValue(opt)}")
                logCPAlgCfgBlock.info(indent*2 + f"\033[4mtype\033[0m: {vals.type}")
                logCPAlgCfgBlock.info(indent*2 + f"\033[4mdefault\033[0m: {vals.default}")
                logCPAlgCfgBlock.info(indent*2 + f"\033[4mrequired\033[0m: {vals.required}")
                logCPAlgCfgBlock.info(indent*2 + f"\033[4mnoneAction\033[0m: {vals.noneAction}")
                printWrap(f"\033[4minfo\033[0m: {vals.info}", indent=indent*2)
            else:
                logCPAlgCfgBlock.info(indent + f"{ opt}: {self.getOptionValue(opt)}")
 
 

setBlockName()

def python.ConfigBlock.ConfigBlock.setBlockName	(		self,
			name
	)

Set blockName

Definition at line 114 of file ConfigBlock.py.

    def setBlockName(self, name):
        """Set blockName"""
        self._blockName = name
 

setOptionValue()

def python.ConfigBlock.ConfigBlock.setOptionValue	(		self,
			name,
			value
	)

set the given option on the configuration block

NOTE: The backend to option handling is slated to be replaced
at some point.  This particular function should essentially
stay the same, but some behavior may change.

Definition at line 168 of file ConfigBlock.py.

    def setOptionValue (self, name, value) :
        """set the given option on the configuration block
 
        NOTE: The backend to option handling is slated to be replaced
        at some point.  This particular function should essentially
        stay the same, but some behavior may change.
        """
 
        if name not in self._options :
            raise KeyError (f'unknown option "{name}" in block "{self.__class__.__name__}"')
        noneAction = self._options[name].noneAction
        if value is not None or noneAction == 'set' :
            # check type if specified
            optType = self._options[name].type
            # convert int to float to prevent crash
            if optType is float and type(value) is int:
                value = float(value)
            if optType is not None and optType != type(value):
                raise ValueError(f'{name} for block {self.__class__.__name__} should '
                    f'be of type {optType} not {type(value)}')
            setattr (self, name, value)
        elif noneAction == 'ignore' :
            pass
        elif noneAction == 'error' :
            raise ValueError (f'passed None for setting option {name} with noneAction=error')
 
 

Member Data Documentation

_blockName

python.ConfigBlock.ConfigBlock._blockName

private

Definition at line 90 of file ConfigBlock.py.

_dependencies

python.ConfigBlock.ConfigBlock._dependencies

private

Definition at line 91 of file ConfigBlock.py.

_options

python.ConfigBlock.ConfigBlock._options

private

Definition at line 92 of file ConfigBlock.py.

---

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

• ConfigBlock.py