def __init__(self, id, after, type, rules): """ Create a rule block, with some ID, some restrictions on ordering, type (which is either 'until-success' or 'all', which means apply rules until one is successful, or apply all the rules regardless) and an initial ordered list of rules. For rules in blocks, ID and after are meaningless, they are run in sequence anyway. Blocks can be ordered like normal rules. """ self.id = id self.after = after self._rules = rules if type == 'until-success' or type == 'all': self._type = type else: raise rule_load_error(id, "Invalid type, must be either 'until-success' or 'all'")
def __init__(self, id, after, type, rules): """ Create a rule block, with some ID, some restrictions on ordering, type (which is either 'until-success' or 'all', which means apply rules until one is successful, or apply all the rules regardless) and an initial ordered list of rules. For rules in blocks, ID and after are meaningless, they are run in sequence anyway. Blocks can be ordered like normal rules. """ self.id = id self.after = after self._rules = rules if type == 'until-success' or type == 'all': self._type = type else: raise rule_load_error( id, "Invalid type, must be either 'until-success' or 'all'")
def _load_rule(self, filename, rulelines): """ Load a 'simple' recognition rule """ # get key/value dictionaries d = self._parse_rule(filename, rulelines) # Set defaults type = None match = None id = filename squelch = False guards = [] before_guards = [] after_guards = [] after = [] case_sensitive = False deliminate_numbers = False for key in d: # Only one 'Type field allowed if key == 'type': if (len(d[key]) != 1): raise rule_load_error(filename, "There must be exactly 1 'Type' field") else: type = d[key][0] # Only one 'Match' field allowed elif key == 'match': if (len(d[key]) != 1): raise rule_load_error(filename, "There must be exactly 1 'Match' field") else: match = d[key][0] # No more than one ID key allowed elif key == 'id': if (len(d[key]) == 1): id = d[key][0] elif (len(d[key]) > 1): raise rule_load_error(filename, "Too many 'ID' fields") # Squelch is an optional field, defaulting to False, which accepts # either true or false (case-insensitive) as values elif key == 'squelch': if (len(d[key]) == 1): squelch = d[key][0].lower() if squelch == 'true': squelch = True elif squelch == 'false': squelch = False else: raise rule_load_error(filename, "Squelch must be either 'True' or 'False'") elif (len(d[key]) > 1): raise rule_load_error(filename, "Too many 'Squelch' fields") # Case-sensitive is an optional field, defaulting to False, which # accepts either true or false (case-insensitive) as values elif key == 'case-sensitive': if (len(d[key]) == 1): case_sensitive = d[key][0].lower() if case_sensitive == 'true': case_sensitive = True elif case_sensitive == 'false': case_sensitive = False else: raise rule_load_error(filename, "Case-Sensitive must be either 'True' or 'False'") elif (len(d[key]) > 1): raise rule_load_error(filename, "Too many 'Case-Sensitive' fields") # Deliminate-Numbers is an optional field, defaulting to False, which # accepts either true or false (case-insensitive) as values elif key == 'deliminate-numbers': if (len(d[key]) == 1): deliminate_numbers = d[key][0].lower() if deliminate_numbers == 'true': deliminate_numbers = True elif deliminate_numbers == 'false': deliminate_numbers = False else: raise rule_load_error(filename, "Deliminate-Numbers must be either 'True' or 'False'") elif (len(d[key]) > 1): raise rule_load_error(filename, "Too many 'Deliminate-Numbers' fields") # set optional fields elif key == 'guard': guards = d[key] elif key == 'after': after = d[key] elif key == 'before-guard': before_guards = d[key] elif key == 'after-guard': after_guards = d[key] # error on unknown fields else: raise rule_load_error(filename, "Unknown field '" + key + "'") if type is None: raise rule_load_error(filename, "'Type' is a compulsory field") if match is None: raise rule_load_error(filename, "'Match' is a compulsory field") # Guard against any RE errors try: return recognition_rule(match, type, id, guards, after_guards, before_guards, after, squelch, case_sensitive, deliminate_numbers) except re.error as e: raise rule_load_error(filename, "Malformed regular expression: " + str(e)) except (SyntaxError, ValueError) as e: raise rule_load_error(filename, "Malformed Python expression: " + str(e))
def _load_rule(self, filename, rulelines): """ Load a 'simple' recognition rule """ # get key/value dictionaries d = self._parse_rule(filename, rulelines) # Set defaults type = None match = None id = filename squelch = False guards = [] before_guards = [] after_guards = [] after = [] case_sensitive = False deliminate_numbers = False for key in d: # Only one 'Type field allowed if key == 'type': if (len(d[key]) != 1): raise rule_load_error( filename, "There must be exactly 1 'Type' field") else: type = d[key][0] # Only one 'Match' field allowed elif key == 'match': if (len(d[key]) != 1): raise rule_load_error( filename, "There must be exactly 1 'Match' field") else: match = d[key][0] # No more than one ID key allowed elif key == 'id': if (len(d[key]) == 1): id = d[key][0] elif (len(d[key]) > 1): raise rule_load_error(filename, "Too many 'ID' fields") # Squelch is an optional field, defaulting to False, which accepts # either true or false (case-insensitive) as values elif key == 'squelch': if (len(d[key]) == 1): squelch = d[key][0].lower() if squelch == 'true': squelch = True elif squelch == 'false': squelch = False else: raise rule_load_error( filename, "Squelch must be either 'True' or 'False'") elif (len(d[key]) > 1): raise rule_load_error(filename, "Too many 'Squelch' fields") # Case-sensitive is an optional field, defaulting to False, which # accepts either true or false (case-insensitive) as values elif key == 'case-sensitive': if (len(d[key]) == 1): case_sensitive = d[key][0].lower() if case_sensitive == 'true': case_sensitive = True elif case_sensitive == 'false': case_sensitive = False else: raise rule_load_error( filename, "Case-Sensitive must be either 'True' or 'False'") elif (len(d[key]) > 1): raise rule_load_error(filename, "Too many 'Case-Sensitive' fields") # Deliminate-Numbers is an optional field, defaulting to False, which # accepts either true or false (case-insensitive) as values elif key == 'deliminate-numbers': if (len(d[key]) == 1): deliminate_numbers = d[key][0].lower() if deliminate_numbers == 'true': deliminate_numbers = True elif deliminate_numbers == 'false': deliminate_numbers = False else: raise rule_load_error( filename, "Deliminate-Numbers must be either 'True' or 'False'" ) elif (len(d[key]) > 1): raise rule_load_error( filename, "Too many 'Deliminate-Numbers' fields") # set optional fields elif key == 'guard': guards = d[key] elif key == 'after': after = d[key] elif key == 'before-guard': before_guards = d[key] elif key == 'after-guard': after_guards = d[key] # error on unknown fields else: raise rule_load_error(filename, "Unknown field '" + key + "'") if type is None: raise rule_load_error(filename, "'Type' is a compulsory field") if match is None: raise rule_load_error(filename, "'Match' is a compulsory field") # Guard against any RE errors try: return recognition_rule(match, type, id, guards, after_guards, before_guards, after, squelch, case_sensitive, deliminate_numbers) except re.error as e: raise rule_load_error(filename, "Malformed regular expression: " + str(e)) except (SyntaxError, ValueError) as e: raise rule_load_error(filename, "Malformed Python expression: " + str(e))
def _load_rule(self, filename, rulelines): """ Load a 'simple' normalisation rule """ # get key/value dictionaries d = self._parse_rule(filename, rulelines) # Set defaults type = None match = None id = filename value = None guards = [] before_guards = [] after_guards = [] sent_guards = [] after = [] tokenise = True deliminate_numbers = False change_type = None freq = None quant = None mod = None for key in d: # Only one 'Type' field allowed if key == 'type': if (len(d[key]) != 1): raise rule_load_error(filename, "Too many 'Type' field") else: type = d[key][0] # Only one 'Match' field allowed elif key == 'match': if (len(d[key]) != 1): raise rule_load_error(filename, "There must be exactly 1 'Match' field") else: match = d[key][0] # No more than one ID key allowed elif key == 'id': if (len(d[key]) == 1): id = d[key][0] elif (len(d[key]) > 1): raise rule_load_error(filename, "Too many 'ID' fields") # No more than one Value key allowed elif key == 'value': if (len(d[key]) == 1): value = d[key][0] elif (len(d[key]) > 1): raise rule_load_error(filename, "Too many 'Value' fields") # No more than one Change-Type key allowed elif key == 'change-type': if (len(d[key]) == 1): change_type = d[key][0] elif (len(d[key]) > 1): raise rule_load_error(filename, "Too many 'Change-Type' fields") # No more than one Freq key allowed elif key == 'freq': if (len(d[key]) == 1): freq = d[key][0] elif (len(d[key]) > 1): raise rule_load_error(filename, "Too many 'Freq' fields") # No more than one Quant key allowed elif key == 'quant': if (len(d[key]) == 1): quant = d[key][0] elif (len(d[key]) > 1): raise rule_load_error(filename, "Too many 'Quant' fields") # No more than one Mod key allowed elif key == 'mod': if (len(d[key]) == 1): mod = d[key][0] elif (len(d[key]) > 1): raise rule_load_error(filename, "Too many 'Mod' fields") # set optional fields elif key == 'guard': guards = d[key] elif key == 'after': after = d[key] elif key == 'before-guard': before_guards = d[key] elif key == 'after-guard': after_guards = d[key] elif key == 'sent-guard': sent_guards = d[key] elif key == 'tokenise': if (len(d[key]) == 1): tokenise = d[key][0].lower() if tokenise == 'true': tokenise = True elif tokenise == 'space': tokenise = ' ' elif tokenise == 'null': tokenise = '' elif (len(d[key]) > 1): raise rule_load_error(filename, "Too many 'Tokenise' fields") # Deliminate-Numbers is an optional field, defaulting to False, which # accepts either true or false (case-insensitive) as values elif key == 'deliminate-numbers': if (len(d[key]) == 1): deliminate_numbers = d[key][0].lower() if deliminate_numbers == 'true': deliminate_numbers = True elif deliminate_numbers == 'false': deliminate_numbers = False else: raise rule_load_error(filename, "Deliminate-Numbers must be either 'True' or 'False'") elif (len(d[key]) > 1): raise rule_load_error(filename, "Too many 'Deliminate-Numbers' fields") # error on unknown fields else: raise rule_load_error(filename, "Unknown field '" + key + "'") if match is None: raise rule_load_error(filename, "'Match' is a compulsory field") if deliminate_numbers and tokenise != True: raise rule_load_error(filename, "'Deliminate-Numbers' can not be set if Tokenise is") # Guard against any RE errors try: return normalisation_rule(match, type, id, value, change_type, freq, quant, mod, guards, after_guards, before_guards, sent_guards, after, tokenise, deliminate_numbers) except re.error as e: raise rule_load_error(filename, "Malformed regular expression: " + str(e))