python.ConfigText Namespace Reference

Classes
class	TextConfig

Functions
def	readYaml (yamlPath)
def	printYaml (d, sort=False, jsonFormat=False)
def	makeSequence (configPath, dataType, algSeq, geometry=None, autoconfigFromFlags=None, isPhyslite=False, noPhysliteBroken=False, noSystematics=None)
def	combineConfigFiles (local, config_path, fragment_key="include")
def	_find_fragment (fragment_path, config_path)
def	_merge_dicts (local, fragment)

Variables
	logCPAlgTextCfg = logging.getLogger('CPAlgTextCfg')

Function Documentation

_find_fragment()

def python.ConfigText._find_fragment (   fragment_path,   config_path  )

private

Definition at line 331 of file ConfigText.py.

def _find_fragment(fragment_path, config_path):
    paths_to_check = [
        fragment_path,
        config_path / fragment_path,
        *[x / fragment_path for x in os.environ["DATAPATH"].split(":")]
    ]
    for path in paths_to_check:
        if path.exists():
            return path
 
    raise FileNotFoundError(fragment_path)
 
 

_merge_dicts()

def python.ConfigText._merge_dicts (   local,   fragment  )

private

Definition at line 344 of file ConfigText.py.

def _merge_dicts(local, fragment):
    # in the list case append the fragment to the local list
    if isinstance(local, list):
        local += fragment
        return
    # In the dict case, append only missing values to local: the local
    # values take precidence over the fragment ones.
    if isinstance(local, dict):
        for key, value in fragment.items():
            if key in local:
                _merge_dicts(local[key], value)
            else:
                local[key] = value
        return

combineConfigFiles()

def python.ConfigText.combineConfigFiles	(		local,
			config_path,
			fragment_key = "include"
	)

Definition at line 284 of file ConfigText.py.

def combineConfigFiles(local, config_path, fragment_key="include"):
 
    # if this isn't an iterable there's nothing to combine
    if isinstance(local, dict):
        to_combine = local.values()
    elif isinstance(local, list):
        to_combine = local
    else:
        return
 
    # otherwise descend into all the entries here
    for sub in to_combine:
        combineConfigFiles(sub, config_path, fragment_key=fragment_key)
 
    # if there are no fragments to include we're done
    if fragment_key not in local:
        return
 
    fragment_path = _find_fragment(
        pathlib.Path(local[fragment_key]),
        config_path)
 
    with open(fragment_path) as fragment_file:
        # once https://github.com/yaml/pyyaml/issues/173 is resolved
        # pyyaml will support the yaml 1.2 spec, which is compatable
        # with json. Until then yaml and json behave differently, so
        # we have this override.
        if fragment_path.suffix == '.json':
            fragment = json.load(fragment_file)
        else:
            fragment = yaml.safe_load(fragment_file)
 
    # fill out any sub-fragments, looking in the parent path of the
    # fragment for local sub-fragments.
    combineConfigFiles(
        fragment,
        fragment_path.parent,
        fragment_key=fragment_key
    )
 
    # merge the fragment with this one
    _merge_dicts(local, fragment)
 
    # delete the fragment so we don't stumble over it again
    del local[fragment_key]
 
 

makeSequence()

def python.ConfigText.makeSequence	(		configPath,
			dataType,
			algSeq,
			geometry = None,
			autoconfigFromFlags = None,
			isPhyslite = False,
			noPhysliteBroken = False,
			noSystematics = None
	)

Definition at line 243 of file ConfigText.py.

def makeSequence(configPath, dataType, algSeq, geometry=None, autoconfigFromFlags=None,
                 isPhyslite=False, noPhysliteBroken=False, noSystematics=None):
    """
    """
 
    from AnalysisAlgorithmsConfig.ConfigAccumulator import ConfigAccumulator
 
    config = TextConfig(configPath)
 
    logCPAlgTextCfg.info("Configuration file read in:")
    config.printConfig()
 
    logCPAlgTextCfg.info("Default algorithms:")
    config.printAlgs(printOpts=True)
 
    logCPAlgTextCfg.info("Configuring algorithms based on YAML file:")
    configSeq = config.configure()
 
    # defaults are added to config as algs are configured
    logCPAlgTextCfg.info("Configuration used:")
    config.printConfig()
 
    # compile
    configAccumulator = ConfigAccumulator(algSeq, dataType, isPhyslite=isPhyslite, geometry=geometry, autoconfigFromFlags=autoconfigFromFlags, noSystematics=noSystematics)
    configSeq.fullConfigure(configAccumulator)
 
    # blocks can be reordered during configSeq.fullConfigure
    logCPAlgTextCfg.info("ConfigBlocks and their configuration:")
    configSeq.printOptions()
 
    from AnaAlgorithm.DualUseConfig import isAthena, useComponentAccumulator
    if isAthena and useComponentAccumulator:
        return configAccumulator.CA
    else:
        return None
 
 
# Combine configuration files
#
# See the README for more info on how this works
#

printYaml()

def python.ConfigText.printYaml	(		d,
			sort = False,
			jsonFormat = False
	)

Prints a dictionary as YAML

Definition at line 28 of file ConfigText.py.

def printYaml(d, sort=False, jsonFormat=False):
    """Prints a dictionary as YAML"""
    print(yaml.dump(d, default_flow_style=jsonFormat, sort_keys=sort))
 
 

readYaml()

def python.ConfigText.readYaml

(

yamlPath

)

Loads YAML file into a dictionary

Definition at line 19 of file ConfigText.py.

def readYaml(yamlPath):
    """Loads YAML file into a dictionary"""
    if not os.path.isfile(yamlPath):
        raise ValueError(f"{yamlPath} is not a file.")
    with open(yamlPath, 'r') as f:
        textConfig = yaml.safe_load(f)
    return textConfig
 
 

Variable Documentation

logCPAlgTextCfg

python.ConfigText.logCPAlgTextCfg = logging.getLogger('CPAlgTextCfg')

Definition at line 16 of file ConfigText.py.