han_lark_tester Namespace Reference

Classes
class	AlgorithmNameInterpreter
class	T

Functions
def	algorithm_check (tree)

Variables
	grammarfile = find_datafile('DataQualityInterfaces/han_def.lark')
	grammar = open(grammarfile).read()
	transformer = T()
	parser = lark.Lark(grammar, parser='lalr', lexer='contextual', transformer=transformer)
	infile = open(sys.argv[1]).read()
	tree = parser.parse(infile)

Function Documentation

algorithm_check()

def han_lark_tester.algorithm_check

(

tree

)

Definition at line 80 of file han_lark_tester.py.

def algorithm_check(tree):
    import ROOT
    import cppyy
 
    ROOT.gSystem.Load('libdqm_core.so')
    cppyy.include("dqm_core/AlgorithmManager.h")
 
    cppyy.cppdef(r"""
#include <dqm_core/AlgorithmManager.h>
std::pair<std::vector<std::string>, std::vector<std::string>> get_lib_algs() {
std::vector<std::string> rv1;
std::vector<std::string> rv2;
for (const auto& p : dqm_core::AlgorithmManager::instance().getAlgorithmMap()) {
  rv1.push_back(p.first);
}
for (const auto& p : dqm_core::AlgorithmManager::instance().getSummaryMakerMap()) {
  rv2.push_back(p.first);
}
return std::move(std::make_pair(rv1, rv2));
}
"""
    )
 
    rv = True
    try:
        AlgorithmNameInterpreter().visit(tree)
    except ValueError as e:
        print(f'ERROR: {e}')
        return False
    libs = {_.children[0].value for _ in tree.find_data('libname')}  # Defined libraries
    compalgs = {_.children[0].value for _ in tree.find_data('compalgname')}  # Defined composite algorithms
    
    # Check if the referenced libraries exist
    for lib in libs:
        if ROOT.gSystem.Load(lib) < 0:
            rv = False
            print(f'ERROR: Library {lib} defined by a libname clause cannot be found. Referenced by:')
            for alg in tree.find_data('algorithmblock'):
                alibname = alg.find_data('libname')
                if alibname and lib in {_.children[0].value for _ in alibname}:
                    print(list(alg.find_data('algorithmname'))[0].children[0].value)
 
    # Extract the list of "base" algorithms and summaries
    libalgos, libsummaries = ROOT.get_lib_algs()
 
    # Check that the composite algorithms reference existing base algorithms (and not summaries!)
    for alg in tree.find_data('compalgblock'):
        subalglist = [_ for _ in alg.children if _.data == 'subalglist']
        for tok in subalglist[0].children:
            if tok.value not in libalgos:
                algname = list(alg.find_data('compalgname'))[0].children[0].value
                print(f'ERROR: composite algorithm {algname} references {tok.value} which is not a known algorithm')
                rv = False
 
    # Check that all the instantiated algorithms and summaries refer to existing base algorithms and summaries
    instalgos = set()
    instsummaries = set()
    for alg in tree.find_data('algorithmblock'):
        try:
            algname = [_.children[0].value for _ in alg.children if isinstance(_, lark.Tree) and _.data == "algorithmname"][0]
            algrealname = [_.children[0].value for _ in alg.children if isinstance(_, lark.Tree) and _.data == "realname"][0]
            if algrealname in libalgos:
                instalgos.add(algname)
            elif algrealname in libsummaries:
                instsummaries.add(algname)
            elif algrealname in compalgs:
                instalgos.add(algname)
            else:
                print(f'ERROR: undefined base algorithm {algrealname} for {algname}')
                rv = False
        except Exception as e:
            print('??? problem processing', alg, e)
 
    # These SHOULD just be summaries
    for ref in tree.find_data('algorefstatement'):
        nodealg = ref.children[0].children[0].value
        if nodealg not in instsummaries:
            print(f'ERROR: an output is specifying algorithm = {nodealg} which is not a known summary algorithm')
            rv = False
    
    # These SHOULD just be non-summary algos
    for ref in list(tree.find_data('dirblock')) + list(tree.find_data('histblock')):
        nodealg = [_ for _ in ref.children if _.data == 'algorithmreference']
        if nodealg:
            nodealgname = nodealg[0].children[0].value
            if nodealgname not in instalgos:
                refname = [_ for _ in ref.children if _.data in ('histname', 'dirname')][0].children[0].value
                print(f'ERROR: a dir/hist is specifying algorthm = {nodealgname} which is not a known histogram algorithm. Referenced by {refname}')
                rv = False
 
    return rv
 
 

Variable Documentation

grammar

han_lark_tester.grammar = open(grammarfile).read()

Definition at line 75 of file han_lark_tester.py.

grammarfile

han_lark_tester.grammarfile = find_datafile('DataQualityInterfaces/han_def.lark')

Definition at line 72 of file han_lark_tester.py.

infile

han_lark_tester.infile = open(sys.argv[1]).read()

Definition at line 173 of file han_lark_tester.py.

parser

han_lark_tester.parser = lark.Lark(grammar, parser='lalr', lexer='contextual', transformer=transformer)

Definition at line 77 of file han_lark_tester.py.

transformer

han_lark_tester.transformer = T()

Definition at line 76 of file han_lark_tester.py.

tree

han_lark_tester.tree = parser.parse(infile)

Definition at line 175 of file han_lark_tester.py.