def nextToken(self):
while self.current:
validelements = [(x,y) for x,y in self.alphabet.grammardict.items() if self.current[0] in y.first]
if not validelements:
if not self.generate_unknown:
raise Exception("Not found")
string = self.current[0]
self.consume()
return unknownchar, string
elif len(validelements) == 1:
element = validelements[0][1]
checker = load_checker(element)
for size in range(element.maxsize or len(self.current), element.minsize, -1):
if checker.check(self.current[:size]):
break
else:
raise Exception("Nothing consumed")
string = self.current[:size]
for _ in range(size):
self.consume()
return validelements[0][0], string
else:
raise Exception("Multiple choices")
return "EOF_TYPE", ""
def __init__(self, module):
Checker.__init__(self)
self._matchFun = module["matchFun"]
auxdic = module.get('auxdic', {})
self.auxgrammar = {}
for key, value in auxdic.items():
self.auxgrammar[key] = load_checker(value)
def __call__(self, inputstring): #-> set:
result = set()
for summary in self.searcher.search():
typ = None
name = None
try:
for mem in self.memorylist:
if summary["identifier"] in mem:
name = summary["identifier"]
try:
typ = mem.load(name)
except:
LOG.exception("Error while loading memory %s" % name)
continue
break
else:
continue # not found
checker = load_checker(typ)
if checker.check(inputstring):
result.add(str(name))
except TypeError:
continue
return result
def __auxcheck(self, specdict, data):
"""Recursive checker implementation"""
for key, spec in specdict.items():
value = data.get(key)
if key == "$or" and len(specdict) == 1:
return any([self.__auxcheck(x, data) for x in spec])
elif isinstance(spec, dict) and len(spec) == 1:
operator = list(spec.keys())[0]
operand = list(spec.values())[0]
if operator == "$type":
if not load_checker(operand).check(str(value)):
return False
elif operator == "$or":
if not any([self.__auxcheck({key:x}, data) for x in operand]):
return False
else: #unknown operator
return spec == value
elif isinstance(spec, dict):
if not self.__auxcheck(spec, value):
return False
else:
if spec != value:
return False
return True
def __init__(self, gd):
Checker.__init__(self)
self.gd = gd
from pydsl.Memory.Loader import load_checker
self.checkerinstances = [load_checker(x) for x in self.gd.grammardict]
def checker(self):
if self.__checker is None:
from pydsl.Memory.Loader import load_checker
self.__checker = load_checker(self.grammarname)
return self.__checker
def function(inputdic, inputgt, outputgt):
grammarname = str(inputdic['grammar'])
from pydsl.Memory.Loader import load_checker
grammar = load_checker(grammarname)
result = grammar.check(inputdic['string'])
return {"output":str(result)}
def testloadgrammar(self):
#Load a grammar that uses a package (integerOPGrammar), call check
from pydsl.Memory.Loader import load_checker # FIXME: is load_grammar_tool
grammar = load_checker("integerop")
self.assertTrue(grammar.check("123+3"))
def check(self, word):
if not self._checker:
from pydsl.Memory.Loader import load_checker
self._checker = load_checker(self.gd)
return self._checker.check(word)
def testChecker(self):
checker = load_checker(self.alphabet)
self.assertTrue(checker.check(["1234","11/11/1991"]))
self.assertFalse(checker.check(["bcdf"]))
