Public Member Functions
def	__init__ (self)

def	addFileOverride (self, filename)

def	addValueOverride (self, field, value)

def	addPythonOverride (self, str python_snippet)

def	addInstrumentOverride (self, str instrument, str task_name)

def	applyTo (self, config)

Detailed Description

Defines a set of overrides to be applied to a task config.

Overrides for task configuration need to be applied by activator when
creating task instances. This class represents an ordered set of such
overrides which activator receives from some source (e.g. command line
or some other configuration).

Methods
----------
addFileOverride(filename)
    Add overrides from a specified file.
addValueOverride(field, value)
    Add override for a specific field.
applyTo(config)
    Apply all overrides to a `config` instance.

Notes
-----
Serialization support for this class may be needed, will add later if
necessary.

Definition at line 121 of file configOverrides.py.

Constructor & Destructor Documentation

◆ init()

def lsst.pipe.base.configOverrides.ConfigOverrides.__init__ ( self )

Definition at line 144 of file configOverrides.py.

     def __init__(self):
         self._overrides = []
  

Member Function Documentation

◆ addFileOverride()

def lsst.pipe.base.configOverrides.ConfigOverrides.addFileOverride	(	self,
		filename
	)

Add overrides from a specified file.

Parameters
----------
filename : str
    Path to the override file.

Definition at line 147 of file configOverrides.py.

     def addFileOverride(self, filename):
         """Add overrides from a specified file.
  
         Parameters
         ----------
         filename : str
             Path to the override file.
         """
         self._overrides.append((OverrideTypes.File, filename))
  

◆ addInstrumentOverride()

def lsst.pipe.base.configOverrides.ConfigOverrides.addInstrumentOverride	(		self,
		str	instrument,
		str	task_name
	)

Apply any overrides that an instrument has for a task

Parameters
----------
instrument: str
    A string containing the fully qualified name of an instrument from
    which configs should be loaded and applied
task_name: str
    The _DefaultName of a task associated with a config, used to look
    up overrides from the instrument.

Definition at line 186 of file configOverrides.py.

     def addInstrumentOverride(self, instrument: str, task_name: str):
         """Apply any overrides that an instrument has for a task
  
         Parameters
         ----------
         instrument: str
             A string containing the fully qualified name of an instrument from
             which configs should be loaded and applied
         task_name: str
             The _DefaultName of a task associated with a config, used to look
             up overrides from the instrument.
         """
         instrument_lib = doImport(instrument)()
         self._overrides.append((OverrideTypes.Instrument, (instrument_lib, task_name)))
  

◆ addPythonOverride()

def lsst.pipe.base.configOverrides.ConfigOverrides.addPythonOverride	(		self,
		str	python_snippet
	)

Add Overrides by running a snippit of python code against a config.

Parameters
----------
python_snippet: str
    A string which is valid python code to be executed. This is done
    with config as the only local accessible value.

Definition at line 175 of file configOverrides.py.

     def addPythonOverride(self, python_snippet: str):
         """Add Overrides by running a snippit of python code against a config.
  
         Parameters
         ----------
         python_snippet: str
             A string which is valid python code to be executed. This is done
             with config as the only local accessible value.
         """
         self._overrides.append((OverrideTypes.Python, python_snippet))
  

◆ addValueOverride()

def lsst.pipe.base.configOverrides.ConfigOverrides.addValueOverride	(	self,
		field,
		value
	)

Add override for a specific field.

This method is not very type-safe as it is designed to support
use cases where input is given as string, e.g. command line
activators. If `value` has a string type and setting of the field
fails with `TypeError` the we'll attempt `eval()` the value and
set the field with that value instead.

Parameters
----------
field : str
    Fully-qualified field name.
value :
    Value to be given to a filed.

Definition at line 157 of file configOverrides.py.

     def addValueOverride(self, field, value):
         """Add override for a specific field.
  
         This method is not very type-safe as it is designed to support
         use cases where input is given as string, e.g. command line
         activators. If `value` has a string type and setting of the field
         fails with `TypeError` the we'll attempt `eval()` the value and
         set the field with that value instead.
  
         Parameters
         ----------
         field : str
             Fully-qualified field name.
         value :
             Value to be given to a filed.
         """
         self._overrides.append((OverrideTypes.Value, (field, value)))
  

◆ applyTo()

def lsst.pipe.base.configOverrides.ConfigOverrides.applyTo	(	self,
		config
	)

Apply all overrides to a task configuration object.

Parameters
----------
config : `pex.Config`

Raises
------
`Exception` is raised if operations on configuration object fail.

Definition at line 213 of file configOverrides.py.

     def applyTo(self, config):
         """Apply all overrides to a task configuration object.
  
         Parameters
         ----------
         config : `pex.Config`
  
         Raises
         ------
         `Exception` is raised if operations on configuration object fail.
         """
         # Look up a stack of variables people may be using when setting
         # configs. Create a dictionary that will be used akin to a namespace
         # for the duration of this function.
         vars = {}
         # pull in the variables that are declared in module scope of the config
         mod = inspect.getmodule(config)
         vars.update({k: v for k, v in mod.__dict__.items() if not k.startswith("__")})
         # put the supplied config in the variables dictionary
         vars['config'] = config
  
         # Create a parser for config expressions that may be strings
         configParser = ConfigExpressionParser(namespace=vars)
  
         for otype, override in self._overrides:
             if otype is OverrideTypes.File:
                 config.load(override)
             elif otype is OverrideTypes.Value:
                 field, value = override
                 if isinstance(value, str):
                     value = self._parser(value, configParser)
                 # checking for dicts and lists here is needed because {} and []
                 # are valid yaml syntax so they get converted before hitting
                 # this method, so we must parse the elements.
                 #
                 # The same override would remain a string if specified on the
                 # command line, and is handled above.
                 if isinstance(value, dict):
                     new = {}
                     for k, v in value.items():
                         if isinstance(v, str):
                             new[k] = self._parser(v, configParser)
                         else:
                             new[k] = v
                     value = new
                 elif isinstance(value, list):
                     new = []
                     for v in value:
                         if isinstance(v, str):
                             new.append(self._parser(v, configParser))
                         else:
                             new.append(v)
                     value = new
                 # The field might be a string corresponding to a attribute
                 # hierarchy, attempt to split off the last field which
                 # will then be set.
                 parent, *child = field.rsplit(".", maxsplit=1)
                 if child:
                     # This branch means there was a hierarchy, get the
                     # field to set, and look up the sub config for which
                     # it is to be set
                     finalField = child[0]
                     tmpConfig = attrgetter(parent)(config)
                 else:
                     # There is no hierarchy, the config is the base config
                     # and the field is exactly what was passed in
                     finalField = parent
                     tmpConfig = config
                 # set the specified config
                 setattr(tmpConfig, finalField, value)
  
             elif otype is OverrideTypes.Python:
                 # exec python string with the context of all vars known. This
                 # both lets people use a var they know about (maybe a bit
                 # dangerous, but not really more so than arbitrary python exec,
                 # and there are so many other places to worry about security
                 # before we start changing this) and any imports that are done
                 # in a python block will be put into this scope. This means
                 # other config setting branches can make use of these
                 # variables.
                 exec(override, None, vars)
             elif otype is OverrideTypes.Instrument:
                 instrument, name = override
                 instrument.applyConfigOverrides(name, config)

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.4.3/Linux64/pipe_base/22.0.1+94e66cc9ed/python/lsst/pipe/base/configOverrides.py

Public Member Functions