parsingRulesHelper Namespace Reference

Functions
def	rulesParser

Variables
tuple	rulesRegexpCompileFunction = lambdax:( len(x)==2 and (x[0], re.compile(x[1])) or (x[0], re.compile(x[1]), x[2]) )

Function Documentation

def parsingRulesHelper.rulesParser	(		parsing_rules,
			lines,
			compileRules = True
	)

    Applies the (provided) regular expression rules (=rule[1] for rule in parsing_rules)
    to each line and if it matches the line,
    puts the mached information to the dictionary as the specified keys (=rule[0]) which is later returned
    Rule[3] contains whether the field is required to be found. If so and it isn't found the exception would be raised.
    rules = [
      ( (field_name_1_to_match, field_name_2), regular expression, /optionaly: is the field required? if so "req"/ )
    ]

Definition at line 9 of file parsingRulesHelper.py.

References Association.map, and match().

Referenced by parserPerfsuiteMetadata.parserPerfsuiteMetadata._applyParsingRules(), and FileNamesHelper.read_ConfigurationFromSimulationCandles().

def rulesParser(parsing_rules, lines, compileRules = True):
        """ 
            Applies the (provided) regular expression rules (=rule[1] for rule in parsing_rules)
            to each line and if it matches the line,
            puts the mached information to the dictionary as the specified keys (=rule[0]) which is later returned
            Rule[3] contains whether the field is required to be found. If so and it isn't found the exception would be raised.
            rules = [
              ( (field_name_1_to_match, field_name_2), regular expression, /optionaly: is the field required? if so "req"/ )
            ]
         """
        info = {}
        #we compile the parsing rules
        if compileRules:
            parsing_rules = map(rulesRegexpCompileFunction, parsing_rules)
        """ we dynamicaly check if line passes any of the rules and in this way put the information to the info dict. """
        for line in lines:
            for rule in parsing_rules:
                if rule[1].match(line):
                    g = rule[1].match(line).groups()
                    #print g
                    #print "rule fields:"  + str(rule[0])
                    i = 0
                    for field_name in rule[0]:
                        "we use empty field name to mark unneeded parts of regular expression"
                        if field_name != "":
                            #print str(i) + ":" + field_name
                            # we do want to store None values as empty strings ""
                            #TODO: we might want to change it if we multiple introduced rules having same result targets
                            if g[i] == None:
                                info[field_name] = ""
                            else:
                                info[field_name] = g[i]
                        i += 1
        #For the values which do not exist we put "" and check for REQUIRED values
        missing_fields = []
        for rule in parsing_rules:
            for field_name in rule[0]:
                if field_name:
                    if not info.has_key(field_name):
                        info[field_name] = ""
                    """ check for required fields"""
                    if len(rule) == 3 and rule[2] =="req":
                        if not info[field_name]:
                            missing_fields.append(field_name)
        return (info, missing_fields)

Variable Documentation

tuple parsingRulesHelper.rulesRegexpCompileFunction = lambdax:( len(x)==2 and (x[0], re.compile(x[1])) or (x[0], re.compile(x[1]), x[2]) )

Definition at line 7 of file parsingRulesHelper.py.