def dictMap(d, fun=_identity): "Convert a dict to a map (appying fun to each component except the type)." fname = d.get(_TYPE) items = d.items() items.sort() args = [ Symbol(k + ":").structure(fun(v)) for (k, v) in items if k != _TYPE ] if fname == None: return Structure(_MAP_FUNCTOR, args) else: return Structure(Symbol(fname), args)
def decodeXMLValue(xmlValue): "Converts a python value returned by xmlrpc to a SPARK value" if isinstance(xmlValue, UNCHANGED_TYPES): return xmlValue elif xmlValue == None: return sparkNULL() elif isinstance(xmlValue, types.DictType): functor = xmlValue.get(FUNCTOR) if functor is not None: args = xmlValue.get(ARGS) if args is None: raise LowError("Missing %r element for structure"%ARGS) return Structure(Symbol(functor), decodeXMLValues(args)) sym = xmlValue.get(SYM) if sym is not None: return Symbol(sym) var = xmlValue.get(VAR) if var is not None: return Variable(var) # default return dictMap(xmlValue, decodeXMLValue) elif isinstance(xmlValue, types.ListType): return decodeXMLValues(xmlValue) elif isinstance(xmlValue, types.TupleType): return decodeXMLValues(xmlValue) else: raise LowError("Cannot convert value of type %r from XML"%xmlValue.__class__)
def executeTask(self, listener, taskname, taskargs): if self.agent == None: self.agent = G._AGENT staskargs = fromXPS(taskargs) log_incoming_request(listener, "executeTask", (listener, taskname, staskargs)) symOrError = taskNameToSymOrError(self.agent, taskname) if isString(symOrError): requestType = FAIL_REQUEST term = symOrError else: mode = optMode(self.agent, symOrError, ACTION_DO) if mode: requestType = "d" inargs = [ _if(usage == TERM_EVAL, x, None) for (x, usage) in zip(staskargs, mode) ] debug("inargs = %r", inargs) term = Structure(symOrError, List(inargs)) else: requestType = FAIL_REQUEST term = "Cannot find argument modes" #debug("initiating task via (%s, %r, %r, %r)", S_ExecuteTask.id, requestType, listener, term) self.agent.add_ephemeral(S_ExecuteTask, requestType, listener, term)
def initiate_request(agent, service_sym, info, method, args): """Initiate an asynchronous request service_sym is the 'mechanism' symbol info is arbitrary information to associate with the request method is the service name args specifies the service arguments returns (0, request_id) if initiation went well returns (errnum, error_message_string) otherwise """ facts = agentServices(agent, service_sym, method) if len(facts) == 0: errnum = ERR_METHOD_NOT_FOUND result = "Method %r hasn't been defined for %s"%(method, service_sym.id) elif len(facts) > 1: errnum = ERR_METHOD_NOT_FOUND result = "Method %r is not uniquely defined for %s"%(method, service_sym.id) else: _method, sym, requestType, _mechanism = facts[0] if requestType not in ("d", "d1", "db", "d0", "s"): errnum = ERR_SERVER_ERROR result = "Method maps to an invalid request type: %s"%(requestType,) else: requestId = allocateDropBox(info) log_incoming_request(requestId, method, args) postRequest(agent, requestType, requestId, Structure(sym, args), S_standardCallback) return 0, requestId requestId = log_incoming_request(None, method, args) log_outgoing_result(requestId, errnum, result) return (errnum, result)
def builtin_quoted(agent, value): if isList(value): elements = [builtin_quoted(agent, v) for v in value] return List(elements) elif isStructure(value): sym = value.functor if sym == PREFIX_COMMA_SYMBOL: return builtin_evaluate(agent, value[0]) else: argvalues = [builtin_quoted(agent, v) for v in value] return Structure(sym, argvalues) else: return value
def mergePartial(p1, p2): if len(p1) != len(p2): return None def merge(x, y): if x == None: return y else: return x newargs = [merge(e1, e2) for (e1, e2) in zip(p1, p2)] if isList(p1): return List(newargs) elif isStructure(p1): return Structure(p1.functor, newargs)
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 getStructure(self, agent): return Structure(self._symbol, self._fact)
def struct(self, functor_sym, args): return Structure(functor_sym, args)
def ieFact(agent, functorSymbol, fact): """Perform inverse-eval on elements of facts and construct a structure to write""" return Structure(functorSymbol, [inverse_eval(arg) for arg in fact])