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)