python.ConfigText.TextConfig Class Reference

Inheritance diagram for python.ConfigText.TextConfig:

Collaboration diagram for python.ConfigText.TextConfig:

Public Member Functions
def	__init__ (self, yamlPath=None, *addDefaultBlocks=True)
def	setConfig (self, config)
def	loadConfig (self, yamlPath)
def	printConfig (self, sort=False, jsonFormat=False)
def	saveYaml (self, filePath='config.yaml', default_flow_style=False, **kwargs)
def	addBlock (self, name, **kwargs)
def	setOptions (self, **kwargs)
def	configure (self)

Private Member Functions
def	_addNewConfigBlocks (self, modulePath, functionName, algName, defaults=None, pos=None, superBlocks=None)
def	_configureAlg (self, block, blockConfig, configSeq=None, containerName=None)

Private Attributes
	_config
	__loadedYaml
	_last

Detailed Description

Definition at line 33 of file ConfigText.py.

Constructor & Destructor Documentation

__init__()

def python.ConfigText.TextConfig.__init__	(		self,
			yamlPath = None,
		*	addDefaultBlocks = True
	)

Definition at line 34 of file ConfigText.py.

    def __init__(self, yamlPath=None, *, addDefaultBlocks=True):
        super().__init__(addDefaultBlocks=False)
 
        # Block to add new blocks to this object
        self.addAlgConfigBlock(algName="AddConfigBlocks", alg=self._addNewConfigBlocks,
            defaults={'self': self})
        # add default blocks
        if addDefaultBlocks:
            self.addDefaultAlgs()
        # load yaml
        self._config = {}
        # do not allow for loading multiple yaml files
        self.__loadedYaml = False
        if yamlPath is not None:
            self.loadConfig(yamlPath)
        # last is used for setOptionValue when using addBlock
        self._last = None
 
 

Member Function Documentation

_addNewConfigBlocks()

def python.ConfigText.TextConfig._addNewConfigBlocks (   self,   modulePath,   functionName,   algName,   defaults = None,   pos = None,   superBlocks = None  )

private

Load <functionName> from <modulePath>

Definition at line 183 of file ConfigText.py.

    def _addNewConfigBlocks(self, modulePath, functionName,
        algName, defaults=None, pos=None, superBlocks=None):
        """
        Load <functionName> from <modulePath>
        """
        try:
            module = importlib.import_module(modulePath)
            fxn = getattr(module, functionName)
        except ModuleNotFoundError as e:
            raise ModuleNotFoundError(f"{e}\nFailed to load {functionName} from {modulePath}")
        else:
            sys.modules[functionName] = fxn
        # add new algorithm to available algorithms
        self.addAlgConfigBlock(algName=algName, alg=fxn,
            defaults=defaults,
            superBlocks=superBlocks,
            pos=pos)
        return
 
 

_configureAlg()

def python.ConfigText.TextConfig._configureAlg (   self,   block,   blockConfig,   configSeq = None,   containerName = None  )

private

Definition at line 203 of file ConfigText.py.

    def _configureAlg(self, block, blockConfig, configSeq=None, containerName=None):
        if not isinstance(blockConfig, list):
            blockConfig = [blockConfig]
 
        for options in blockConfig:
            # Special case: propogate containerName down to subAlgs
            if 'containerName' in options:
                containerName = options['containerName']
            elif containerName is not None and 'containerName' not in options:
                options['containerName'] = containerName
            # will check which options are associated alg and not options
            logCPAlgTextCfg.info(f"Configuring {block.algName}")
            seq, funcOpts = block.makeConfig(options)
            if not seq._blocks:
                continue
            algOpts = seq.setOptions(options)
            if configSeq is not None:
                configSeq += seq
 
            # check to see if there are unused parameters
            algOpts = [i['name'] for i in algOpts]
            expectedOptions = set(funcOpts)
            expectedOptions |= set(algOpts)
            expectedOptions |= set(block.subAlgs)
 
            difference = set(options.keys()) - expectedOptions
            if difference:
                difference = "\n".join(difference)
                raise ValueError(f"There are options set that are not used for "
                                 f"{block.algName}:\n{difference}\n"
                                 "Please check your configuration.")
 
            # check for sub-blocks and call this function recursively
            for alg in self._order.get(block.algName, []):
                if alg in options:
                    subAlg = block.subAlgs[alg]
                    self._configureAlg(subAlg, options[alg], configSeq, containerName)
        return configSeq
 
 

addBlock()

def python.ConfigText.TextConfig.addBlock	(		self,
			name,
		**	kwargs
	)

Create entry into dictionary representing the text configuration

Definition at line 122 of file ConfigText.py.

    def addBlock(self, name, **kwargs):
        """
        Create entry into dictionary representing the text configuration
        """
        def setEntry(name, config, opts):
            if '.' not in name:
                if name not in config:
                    config[name] = opts
                elif isinstance(config[name], list):
                    config[name].append(opts)
                else:
                    config[name] = [config[name], opts]
                # set last added block for setOptionValue
                self._last = opts
            else:
                name, rest = name[:name.index('.')], name[name.index('.') + 1:]
                config = config[name]
                if isinstance(config, list):
                    config = config[-1]
                setEntry(rest, config, opts)
            return
        setEntry(name, self._config, dict(kwargs))
        return
 
 

configure()

def python.ConfigText.TextConfig.configure

(

self

)

Process YAML configuration file and confgure added algorithms.

Definition at line 158 of file ConfigText.py.

    def configure(self):
        """Process YAML configuration file and confgure added algorithms."""
        # make sure all blocks in yaml file are added (otherwise they would be ignored)
        for blockName in self._config:
            if blockName not in self._order[self.ROOTNAME]:
                raise ValueError(f"Unkown block {blockName} in yaml file")
 
        # configure blocks
        configSeq = ConfigSequence()
        for blockName in self._order[self.ROOTNAME]:
            if blockName == "AddConfigBlocks":
                continue
 
            assert blockName in self._algs
 
            # order only applies to root blocks
            if blockName in self._config:
                blockConfig = self._config[blockName]
                alg = self._algs[blockName]
                self._configureAlg(alg, blockConfig, configSeq)
            else:
                continue
        return configSeq
 
 

loadConfig()

def python.ConfigText.TextConfig.loadConfig	(		self,
			yamlPath
	)

read a YAML file. Will combine with any config blocks added using python

Definition at line 61 of file ConfigText.py.

    def loadConfig(self, yamlPath):
        """
        read a YAML file. Will combine with any config blocks added using python
        """
        if self.__loadedYaml or isinstance(yamlPath, list):
            raise NotImplementedError("Mering multiple yaml files is not implemented.")
        self.__loadedYaml = True
 
        def merge(config, algs, path=''):
            """Add to config block-by-block"""
            if not isinstance(config, list):
                config = [config]
            # loop over list of blocks with same block name
            for blocks in config:
                # deal with case where empty dict is config
                if blocks == {} and path:
                    self.addBlock(path)
                    return
                # remove any subBlocks from block config
                subBlocks = {}
                for blockName in algs:
                    if blockName in blocks:
                        subBlocks[blockName] = blocks.pop(blockName)
                # anything left should be a block and it's configuration
                if blocks:
                    self.addBlock(path, **blocks)
                # add in any subBlocks
                for subName, subBlock in subBlocks.items():
                    newPath = f'{path}.{subName}' if path else subName
                    merge(subBlock, algs[subName].subAlgs, newPath)
            return
 
        logCPAlgTextCfg.info(f'loading {yamlPath}')
        config = readYaml(yamlPath)
        # check if blocks are defined in yaml file
        if "AddConfigBlocks" in config:
           self._configureAlg(self._algs["AddConfigBlocks"], config["AddConfigBlocks"])
        merge(config, self._algs)
        return
 
 

printConfig()

def python.ConfigText.TextConfig.printConfig	(		self,
			sort = False,
			jsonFormat = False
	)

Print YAML configuration file.

Definition at line 102 of file ConfigText.py.

    def printConfig(self, sort=False, jsonFormat=False):
        """Print YAML configuration file."""
        if self._config is None:
            raise ValueError("No configuration has been loaded.")
        printYaml(self._config, sort, jsonFormat)
        return
 
 

saveYaml()

def python.ConfigText.TextConfig.saveYaml	(		self,
			filePath = 'config.yaml',
			default_flow_style = False,
		**	kwargs
	)

Convert dictionary representation to yaml and save

Definition at line 110 of file ConfigText.py.

    def saveYaml(self, filePath='config.yaml', default_flow_style=False,
            **kwargs):
        """
        Convert dictionary representation to yaml and save
        """
        logCPAlgTextCfg.info(f"Saving configuration to {filePath}")
        config = self._config
        with open(filePath, 'w') as outfile:
            yaml.dump(config, outfile, default_flow_style=False, **kwargs)
        return
 
 

setConfig()

def python.ConfigText.TextConfig.setConfig	(		self,
			config
	)

Print YAML configuration file.

Definition at line 53 of file ConfigText.py.

    def setConfig(self, config):
        """Print YAML configuration file."""
        if self._config:
            raise ValueError("Configuration has already been loaded.")
        self._config = config
        return
 
 

setOptions()

def python.ConfigText.TextConfig.setOptions	(		self,
		**	kwargs
	)

Set option(s) for the lsat block that was added. If an option
was added previously, will update value

Definition at line 147 of file ConfigText.py.

    def setOptions(self, **kwargs):
        """
        Set option(s) for the lsat block that was added. If an option
        was added previously, will update value
        """
        if self._last is None:
            raise TypeError("Cannot set options before adding a block")
        # points to dict with opts for last added block
        self._last.update(**kwargs)
 
 

Member Data Documentation

__loadedYaml

python.ConfigText.TextConfig.__loadedYaml

private

Definition at line 46 of file ConfigText.py.

_config

python.ConfigText.TextConfig._config

private

Definition at line 44 of file ConfigText.py.

_last

python.ConfigText.TextConfig._last

private

Definition at line 50 of file ConfigText.py.

---

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

• ConfigText.py