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))
