menu_config_tests.StructuredChainNames Class Reference

Inheritance diagram for menu_config_tests.StructuredChainNames:

Collaboration diagram for menu_config_tests.StructuredChainNames:

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

Public Attributes
	failures
	description

Private Member Functions
def	_name_matches_hlt_convention (self, name)
def	_name_matches_l1_convention (self, name)
def	_matches_shared_conventions (self, name)

Private Attributes
	_trigger_level
	_signature_type_order

Static Private Attributes
	_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__()

def menu_config_tests.StructuredChainNames.__init__	(		self,
			trigger_level
	)

Reimplemented from menu_config_tests.MenuVerification.

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._signature_type_order = \
            self._SIGNATURE_TYPE_ORDER[trigger_level]
 

Member Function Documentation

_matches_shared_conventions()

def menu_config_tests.StructuredChainNames._matches_shared_conventions (   self,   name  )

private

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

Definition at line 117 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] == self._trigger_level.value,
                    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()

def menu_config_tests.StructuredChainNames._name_matches_hlt_convention (   self,   name  )

private

Definition at line 95 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()

def menu_config_tests.StructuredChainNames._name_matches_l1_convention (   self,   name  )

private

Definition at line 98 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()

def menu_config_tests.StructuredChainNames.run	(		self,
			config
	)

Reimplemented from menu_config_tests.MenuVerification.

Definition at line 85 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

_SIGNATURE_TYPE_ORDER

menu_config_tests.StructuredChainNames._SIGNATURE_TYPE_ORDER

staticprivate

Definition at line 70 of file menu_config_tests.py.

_signature_type_order

menu_config_tests.StructuredChainNames._signature_type_order

private

Definition at line 82 of file menu_config_tests.py.

_trigger_level

menu_config_tests.StructuredChainNames._trigger_level

private

Definition at line 81 of file menu_config_tests.py.

description

menu_config_tests.MenuVerification.description

inherited

Definition at line 29 of file menu_config_tests.py.

failures

menu_config_tests.StructuredChainNames.failures

Definition at line 88 of file menu_config_tests.py.

---

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

• menu_config_tests.py