def builtin_evaluate(agent, value):
if (isSymbol(value)): raise AssertionError, \
"A naked symbol is not evaluable"
if isString(value):
return value
elif isList(value):
elements = [builtin_evaluate(agent, v) for v in value]
return List(elements)
elif isInteger(value):
return value
elif isFloat(value):
return value
elif isStructure(value):
sym = value.functor
if sym == BACKQUOTE_SYMBOL:
return builtin_quoted(agent, value[0])
else:
argvalues = [builtin_evaluate(agent, v) for v in value]
fullsym = Symbol(BUILTIN_PACKAGE_NAME + "." + sym.id)
imp = agent.getImp(fullsym)
#if not (isinstance(imp, FunImpInt)): raise AssertionError, \
# "Not a function: %s"%sym
b, z = valuesBZ(argvalues)
result = imp.call(agent, b, z)
return result
else:
return value
def builtin_evaluate(agent, value):
if isSymbol(value):
raise AssertionError, "A naked symbol is not evaluable"
if isString(value):
return value
elif isList(value):
elements = [builtin_evaluate(agent, v) for v in value]
return List(elements)
elif isInteger(value):
return value
elif isFloat(value):
return value
elif isStructure(value):
sym = value.functor
if sym == BACKQUOTE_SYMBOL:
return builtin_quoted(agent, value[0])
else:
argvalues = [builtin_evaluate(agent, v) for v in value]
fullsym = Symbol(BUILTIN_PACKAGE_NAME + "." + sym.id)
imp = agent.getImp(fullsym)
# if not (isinstance(imp, FunImpInt)): raise AssertionError, \
# "Not a function: %s"%sym
b, z = valuesBZ(argvalues)
result = imp.call(agent, b, z)
return result
else:
return value
def conclude(self, agent, bindings, zexpr):
DefStandard.conclude(self, agent, bindings, zexpr)
name = entity(agent, bindings, zexpr[0])
cueexpr = zexpr.keyget0("cue:")[0]
cuePredsym = bindings.bImp(agent, cueexpr).predsym
cuePredImp = agent.getImp(cuePredsym)
ent = entity(agent, bindings, cueexpr[0])
procedure = self.call(agent, bindings, zexpr)
b, z = valuesBZ((ent, procedure, name))
cuePredImp.conclude(agent, b, z)
def conclude(self, agent, bindings, zexpr):
DefStandard.conclude(self, agent, bindings, zexpr)
name = entity(agent, bindings, zexpr[0])
cueexpr = zexpr.keyget0("cue:")[0]
cuePredsym = bindings.bImp(agent, cueexpr).predsym
cuePredImp = agent.getImp(cuePredsym)
ent = entity(agent, bindings, cueexpr[0])
procedure = self.call(agent, bindings, zexpr)
b, z = valuesBZ((ent, procedure, name))
cuePredImp.conclude(agent, b, z)
def loadFactsFromFile(agent, filename, failedConcludes, diffIo, missingPredsList):
from spark.internal.parse.basicvalues import VALUE_CONSTRUCTOR, Structure, isStructure
from spark.internal.parse.generic_tokenizer import FileSource
#from spark.internal.parse.sparkl_parser import EOF_DELIMITER, SPARKLTokenizer, SPARKLParser, BogusValue
from spark.internal.parse.sparkl_parser import parseSPARKL
from spark.lang.builtin_eval import builtin_evaluate
from spark.internal.repr.varbindings import valuesBZ
from spark.pylang.implementation import PersistablePredImpInt
from spark.internal.parse.usagefuns import termEvalErr
print "RESUMING KB FROM", filename
#parser = SPARKLParser(VALUE_CONSTRUCTOR, SPARKLTokenizer(FileSource(filename)))
#parseVal = parser.terms_and_taggeds(True, EOF_DELIMITER, "end of input")
f = open(filename, 'rb')
string = f.read()
f.close()
parseVal = parseSPARKL(string, "File "+filename, VALUE_CONSTRUCTOR)
facts = [] # keep track of all facts in file
for val in parseVal:
# if isinstance(val, BogusValue):
# bogusValues.append(val)
# continue
if not (isStructure(val)): raise AssertionError
functor = val.functor
try:
imp = agent.getImp(functor)
except LowError, e:
if functor not in missingPredsList:
#TODO: make warning only once per prediate functor
console_warning("Predicate %s is no longer part of the SPARK process models and facts for it will be purged", functor.name)
missingPredsList.append(functor)
continue
if not (isinstance(imp, PersistablePredImpInt)): raise AssertionError
#evaluate each of the args before putting into the zexpr
try:
fact = [builtin_evaluate(agent, arg) for arg in val]
facts.append(Structure(functor, fact))
b, z = valuesBZ(fact)
except:
errid = NEWPM.displayError()
console_error("(persist) unable to resume knowledge base fact \n\t%s\n", val)
continue
bindings_altzexpr = imp.resume_conclude(agent, b, z)
if bindings_altzexpr is not None:
(bindings, altzexpr) = bindings_altzexpr
failedConcludes.append((imp, bindings, altzexpr,))
diffIo.write("-(%s %s)\n"%(val.functor.name, \
" ".join([persist_strrep(v) for v in val])))
diffIo.write("+(%s %s)\n"%(val.functor.name, \
" ".join([persist_strrep(termEvalErr(agent, bindings, z)) for z in altzexpr])))
def reduce(agent, fun, list):
if None in list: # NULL ELEMENT
raise LowError("Cannot apply reduce to a partial list")
imp = agent.value_imp(fun)
val = list[0]
index = 1
while index < len(list):
b, z = valuesBZ((val, list[index]))
val = imp.call(agent, b, z)
index += 1
return val
def concludeComponent(predsym, keyword, evaluatorfn):
if isinstance(keyword, int):
valexpr = zexpr[keyword]
else:
valexpr = zexpr.keyget0(keyword)
if valexpr is not None:
value = evaluatorfn(agent, bindings, valexpr)
if value is not None:
#print "*** (%s %s %s)"%(predsym, sym, value)
imp = agent.getImp(predsym)
b, z = valuesBZ((sym, value))
imp.conclude(agent, b, z)
def concludeComponent(predsym, keyword, evaluatorfn):
if isinstance(keyword, int):
valexpr = zexpr[keyword]
else:
valexpr = zexpr.keyget0(keyword)
if valexpr is not None:
value = evaluatorfn(agent, bindings, valexpr)
if value is not None:
#print "*** (%s %s %s)"%(predsym, sym, value)
imp = agent.getImp(predsym)
b, z = valuesBZ((sym, value))
imp.conclude(agent, b, z)
def concludeImp(self, agent, bindings, zexpr):
"Set the implementation for the defined symbol"
# This has been separated out for use in resuming a persisted state.
# imp: is treated almost the same, but the value is applied to the
# symbol declaration before being asserted
if self.USEIMP:
valexpr = zexpr.keyget0("imp:")
if valexpr is not None:
sym = entity(agent, bindings, zexpr[0])
decl = agent.getDecl(sym)
value = termEvalErr(agent, bindings, valexpr)(decl)
imp = agent.getImp(P_Implementation)
b, z = valuesBZ((sym, value))
imp.conclude(agent, b, z)
def concludeImp(self, agent, bindings, zexpr):
"Set the implementation for the defined symbol"
# This has been separated out for use in resuming a persisted state.
# imp: is treated almost the same, but the value is applied to the
# symbol declaration before being asserted
if self.USEIMP:
valexpr = zexpr.keyget0("imp:")
if valexpr is not None:
sym = entity(agent, bindings, zexpr[0])
decl = agent.getDecl(sym)
value = termEvalErr(agent, bindings, valexpr)(decl)
imp = agent.getImp(P_Implementation)
b, z = valuesBZ((sym, value))
imp.conclude(agent, b, z)
def conclude(self, agent, bindings, zexpr):
DefStandard.conclude(self, agent, bindings, zexpr)
name = entity(agent, bindings, zexpr[0])
kind = termEvalErr(agent, bindings, zexpr[1])
docExpr = zexpr.keyget0("doc:")
if docExpr:
doc = termEvalErr(agent, bindings, docExpr)
else:
doc = ""
adviceClosureValue = self.call(agent, bindings, zexpr)
advicePredImp = agent.getImp(ADVICE)
b, z = valuesBZ((name, kind, adviceClosureValue, doc))
# TODO: consider calling advicePredImp.conclude(agent, bindings, (?(zexpr[0]), zexpr[1], zexpr, ?(sexpr.keyget0("doc:")))
advicePredImp.conclude(agent, b, z)
def conclude(self, agent, bindings, zexpr):
DefStandard.conclude(self, agent, bindings, zexpr)
name = entity(agent, bindings, zexpr[0])
kind = termEvalErr(agent, bindings, zexpr[1])
docExpr = zexpr.keyget0("doc:")
if docExpr:
doc = termEvalErr(agent, bindings, docExpr)
else:
doc = ""
adviceClosureValue = self.call(agent, bindings, zexpr)
advicePredImp = agent.getImp(ADVICE)
b, z = valuesBZ((name, kind, adviceClosureValue, doc))
# TODO: consider calling advicePredImp.conclude(agent, bindings, (?(zexpr[0]), zexpr[1], zexpr, ?(sexpr.keyget0("doc:")))
advicePredImp.conclude(agent, b, z)
def map_call(agent, funvalue, *args):
if len(args) < 1:
raise LowError("map requires at least one list argument")
imp = agent.value_imp(funvalue)
l = len(args[0])
for arg in args:
if len(arg) != l:
raise LowError("Mismatched lengths of lists supplied to map")
# apply imp to each tuple
result = []
for tup in zip(*args):
if None in tup: # NULL ELEMENT
# result is partial if any input list is partial
result.append(None)
else:
b, z = valuesBZ(tup)
result.append(imp.call(agent, b, z))
return List(result)
def bindings(self):
return valuesBZ(self._fact)[0]
def resume_conclude(self, agent, bindings, zexpr):
#as part of the test, we fail on the resume conclude
b, z = valuesBZ(("Test-Succeeded", ))
return (b, z)
def find_tframes(self, agent):
b, z = valuesBZ(self._fact)
sym = self._symbol
return get_all_tframes(agent, self, b, P_NewFact, sym, z)
def zexpr(self):
return valuesBZ(self._fact)[1]
def bindings(self):
return valuesBZ(self._fact)[0]
def zexpr(self):
return valuesBZ(self._fact)[1]
def resume_conclude(self, agent, bindings, zexpr):
#as part of the test, we fail on the resume conclude
b, z = valuesBZ(("Test-Succeeded",))
return (b, z)
def loadFactsFromFile(agent, filename, failedConcludes, diffIo,
missingPredsList):
from spark.internal.parse.basicvalues import VALUE_CONSTRUCTOR, Structure, isStructure
from spark.internal.parse.generic_tokenizer import FileSource
#from spark.internal.parse.sparkl_parser import EOF_DELIMITER, SPARKLTokenizer, SPARKLParser, BogusValue
from spark.internal.parse.sparkl_parser import parseSPARKL
from spark.lang.builtin_eval import builtin_evaluate
from spark.internal.repr.varbindings import valuesBZ
from spark.pylang.implementation import PersistablePredImpInt
from spark.internal.parse.usagefuns import termEvalErr
print "RESUMING KB FROM", filename
#parser = SPARKLParser(VALUE_CONSTRUCTOR, SPARKLTokenizer(FileSource(filename)))
#parseVal = parser.terms_and_taggeds(True, EOF_DELIMITER, "end of input")
f = open(filename, 'rb')
string = f.read()
f.close()
parseVal = parseSPARKL(string, "File " + filename, VALUE_CONSTRUCTOR)
facts = [] # keep track of all facts in file
for val in parseVal:
# if isinstance(val, BogusValue):
# bogusValues.append(val)
# continue
if not (isStructure(val)): raise AssertionError
functor = val.functor
try:
imp = agent.getImp(functor)
except LowError, e:
if functor not in missingPredsList:
#TODO: make warning only once per prediate functor
console_warning(
"Predicate %s is no longer part of the SPARK process models and facts for it will be purged",
functor.name)
missingPredsList.append(functor)
continue
if not (isinstance(imp, PersistablePredImpInt)): raise AssertionError
#evaluate each of the args before putting into the zexpr
try:
fact = [builtin_evaluate(agent, arg) for arg in val]
facts.append(Structure(functor, fact))
b, z = valuesBZ(fact)
except:
errid = NEWPM.displayError()
console_error(
"(persist) unable to resume knowledge base fact \n\t%s\n", val)
continue
bindings_altzexpr = imp.resume_conclude(agent, b, z)
if bindings_altzexpr is not None:
(bindings, altzexpr) = bindings_altzexpr
failedConcludes.append((
imp,
bindings,
altzexpr,
))
diffIo.write("-(%s %s)\n"%(val.functor.name, \
" ".join([persist_strrep(v) for v in val])))
diffIo.write("+(%s %s)\n"%(val.functor.name, \
" ".join([persist_strrep(termEvalErr(agent, bindings, z)) for z in altzexpr])))
def find_tframes(self, agent):
b, z = valuesBZ(self._fact)
sym = self._symbol
return get_all_tframes(agent, self, b, P_NewFact, sym, z)
