menu_config_tests.StructuredChainNames Class Reference

Inheritance diagram for menu_config_tests.StructuredChainNames:

Collaboration diagram for menu_config_tests.StructuredChainNames:

Public Member Functions
	__init__ (self, trigger_level)
	run (self, config)

Public Attributes
	description = description
list	failures = []

Protected Member Functions
	_name_matches_hlt_convention (self, name)
	_name_matches_l1_convention (self, name)
	_matches_shared_conventions (self, name)

Protected Attributes
	_trigger_level = trigger_level
list	_allowed_prefixes = [trigger_level.value]
dict	_signature_type_order

Static Protected Attributes
dict	_SIGNATURE_TYPE_ORDER

Detailed Description

Verifies that chain names start with the expected prefix, and have their
parts in the correct order by type, as well as any trigger level specific
restrictions.

Definition at line 63 of file menu_config_tests.py.

Constructor & Destructor Documentation

__init__()

menu_config_tests.StructuredChainNames.__init__	(		self,
			trigger_level )

Definition at line 78 of file menu_config_tests.py.

    def __init__(self, trigger_level):
        super(StructuredChainNames, self).__init__(
            description="Chain names are structured in the expected way")
        self._trigger_level = trigger_level
        self._allowed_prefixes = [trigger_level.value]
        if trigger_level == TriggerLevel.HLT:
            self._allowed_prefixes.append("EF")
        self._signature_type_order = \
            self._SIGNATURE_TYPE_ORDER[trigger_level]
 

Member Function Documentation

_matches_shared_conventions()

menu_config_tests.StructuredChainNames._matches_shared_conventions ( self, name )

protected

True if name starts with level prefix, and all signature
types are in the correct order, otherwise False.

Definition at line 120 of file menu_config_tests.py.

    def _matches_shared_conventions(self, name):
        '''
        True if name starts with level prefix, and all signature
        types are in the correct order, otherwise False.
        '''
        # The signature objects in each item should be ordered by type, in the
        # order defined in _SIGNATURE_TYPE_ORDER.
        signature_types = "|".join(self._signature_type_order)
        sig_type_pattern = re.compile(
            r"_\d*[egj]?({})\d+s?".format(signature_types))
 
# this is commented because needs to be discussed (it will be removed/changed in next dev)
        # re to find the signature that has the probe leg
        #sig_probe_pattern = re.compile(r"_\d*?({})\d+s?[\D]*?_probe".format(signature_types))
 
        
        def items_in_order(part):
            #part    = part.replace("leg","p") #if we leave the word leg, the findall(..) function will find a 'g'
            indices = [self._signature_type_order.index(x) for x in 
                       sig_type_pattern.findall(part)]
 
# this is commented because needs to be discussed (it will be removed/changed in next dev)
            # this finds the signatures with the probe leg 
            # matches = sig_type_pattern.findall(part)
            # matches_probe = sig_probe_pattern.findall(part)
            # if len(matches_probe):
            #     assert(len(matches_probe)==1)
            #     probe_leg = matches_probe[0]
            #     matches_after_probe = matches.copy()
            #     # force the probe leg to be the last one
            #     if probe_leg in matches_after_probe:
            #         # Remove the element
            #         matches_after_probe.remove(probe_leg)
            #         # Append it to the end
            #         matches_after_probe.append(probe_leg)
            #         indices_after_probe = [self._signature_type_order.index(x) for x in matches_after_probe]
            #         # copy the new indices
            #         #indices = indices_after_probe.copy()
                   
            
            rr =  indices == sorted(indices)
            if not rr:
                log.error("[StructuredChainNames::items_in_order] %s NOT SORTED!", indices)
 
            return rr
 
        def are_signatures_in_order(name_parts):
            
            to_check = ["".join(f"_{p}" for p in name_parts if "-" not in p)]
            
            # Sections of topo item parts are checked for ordering independently.
            topo_parts = [p for p in name_parts if "-" in p]
            for topo in topo_parts:
                to_check.extend(topo.split("-"))
            res = all(items_in_order(part) for part in to_check)
            if not res:
                for part in to_check:
                    if not items_in_order(part):
                        log.error("[StructuredChainNames::are_signatures_in_order] %s not in order!", part)
            return res
 
        # Name must begin with the trigger level, and contain at least one item.
        parts = name.split("_")
 
        result= all((len(parts) > 1,
                        parts[0] in self._allowed_prefixes,
                        are_signatures_in_order(parts[1:])))
        if not result:
            log.error("[StructuredChainNames::_matches_shared_conventions] chain deosn't match convention: parts[0] = %s, value = %s, parts[1:] = %s, signature_types = %s", 
                      parts[0], self._trigger_level.value, parts[1:], signature_types)
            
        return result
 
 

_name_matches_hlt_convention()

menu_config_tests.StructuredChainNames._name_matches_hlt_convention ( self, name )

protected

Definition at line 98 of file menu_config_tests.py.

    def _name_matches_hlt_convention(self, name):
        return "_L1" in name and self._matches_shared_conventions(name)
 

_name_matches_l1_convention()

menu_config_tests.StructuredChainNames._name_matches_l1_convention ( self, name )

protected

Definition at line 101 of file menu_config_tests.py.

    def _name_matches_l1_convention(self, name):
        def FEX_items_in_order(name):
            '''
            Where multiple FEX algorithms are used for the same item type,
            they should be in alphabetical order.
            '''
            fex_pattern = r"\d*([egj])({})[A-Z]*\d+s?".format(
                "|".join(self._signature_type_order))
            fex_items = re.findall(fex_pattern, name)
 
            for item_type in self._signature_type_order:
                fexes_of_type = [fex for fex, match_type in fex_items
                                 if match_type == item_type]
                if not fexes_of_type == sorted(fexes_of_type):
                    return False
            return True
 
        return self._matches_shared_conventions(name) and FEX_items_in_order(name)
 

run()

menu_config_tests.StructuredChainNames.run	(		self,
			config )

Reimplemented from menu_config_tests.MenuVerification.

Definition at line 88 of file menu_config_tests.py.

    def run(self, config):
        if self._trigger_level == TriggerLevel.HLT:
            names = config["chains"].keys()
            self.failures = [n for n in names
                             if not self._name_matches_hlt_convention(n)]
        elif self._trigger_level == TriggerLevel.L1:
            names = [item["name"] for item in config["items"].values()]
            self.failures = [n for n in names
                             if not self._name_matches_l1_convention(n)]
 

Member Data Documentation

_allowed_prefixes

list menu_config_tests.StructuredChainNames._allowed_prefixes = [trigger_level.value]

protected

Definition at line 82 of file menu_config_tests.py.

_SIGNATURE_TYPE_ORDER

dict menu_config_tests.StructuredChainNames._SIGNATURE_TYPE_ORDER

staticprotected

Initial value:

=  {
        TriggerLevel.HLT: getListOfSignatureStrings(),
        # TODO: import list of signatures items from L1 code
        TriggerLevel.L1: [
            "EM", "MU", "TAU", "J", "XE", "HT"
        ],
    }

Definition at line 70 of file menu_config_tests.py.

_signature_type_order

dict menu_config_tests.StructuredChainNames._signature_type_order

protected

Initial value:

=  \
            self._SIGNATURE_TYPE_ORDER[trigger_level]

Definition at line 85 of file menu_config_tests.py.

_trigger_level

menu_config_tests.StructuredChainNames._trigger_level = trigger_level

protected

Definition at line 81 of file menu_config_tests.py.

description

menu_config_tests.MenuVerification.description = description

inherited

Definition at line 29 of file menu_config_tests.py.

failures

list menu_config_tests.MenuVerification.failures = []

inherited

Definition at line 30 of file menu_config_tests.py.

---

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

• menu_config_tests.py