def state_args(self): if self._completed is not None: return (self._completed, ) elif self._subgoal_event is None: return (List(self._estack), List(self._dstack)) else: return (List(self._estack), List(self._dstack), self._subgoal_event)
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 optBZ(optvalues): length = len(optvalues) indices = range(length) for index in indices: if optvalues[index] is None: indices[index] = index - length # negative index for bindable return (OptBindings(optvalues), List(indices))
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 executingTask(parentListener, taskname, arguments): executor = XPSExecutor.getNonsparkExecutor() larguments = List(arguments) requestId = log_outgoing_request(None, "executingTask", (parentListener, taskname, larguments)) listener = executor.executingTask(parentListener, taskname, toXPS(larguments)) log_incoming_result(requestId, "result", listener) return listener
def subset(superset, subset): ss = [] for e in superset: if not e in ss: ss.append(e) if subset == None: return List(constructSubsets(ss)) else: return testHasSubset(ss, subset)
def persistSPULoadInfo(): # write added facts of the file for fact in asserted: functor = fact.functor if functor in SPU_LOAD_INFO_PREDICATES: iefactlist.append(ieFact(agent, functor, fact)) # assert LoadedFileObjects objects = List(PERSIST_ID_SAVE.recordedObjects()) lfofact = (spu.filename, spu.index, objects) agent.addfact(P_LoadedFileObjects, lfofact)
def accumulator_set_key_value(acc, key, value): "Remove any existing key-value pair for key and add a new key value pair" contents = acc._contents newpair = List((key, value)) for i in range(len(contents)): if contents[i][0] == key: contents[i] = newpair return True contents.append(newpair) return True
def call(self, agent, bindings, zexpr): l = [termEvalErr(agent, bindings, zitem) for zitem in zexpr] if not l: raise LocatedError(zexpr, "*list function requires at least one argument") else: try: temp = list(l[0]) except TypeError: raise LocatedError(zexpr, "First argument to *list is not a sequence") return List(temp + l[1:])
def tchild_complete(self, agent, tframe, zexpr, index, result): # if (index != 2): raise AssertionError if result is SUCCESS: (_solutions, results) = tframe.tfget() bindings = tframe.getBaseBindings() r = List( [termEvalErr(agent, bindings, zitem) for zitem in zexpr[3::2]]) results.append(r) return tframe.tfyield(agent) else: return tframe.tfcompleted(agent, result)
def call(self, agent, bindings, zexpr): l = [termEvalErr(agent, bindings, zitem) for zitem in zexpr] if not l: raise LocatedError(zexpr, "list* function requires at least one argument") else: result = l[:-1] try: result.extend(l[-1]) except TypeError: raise LocatedError(zexpr, "Last argument to list* is not a sequence") return List(result)
def parseAndConclude(agent, statement, packagename): if not (isinstance(agent, Agent)): raise AssertionError if not (isString(statement)): raise AssertionError if not (isString(packagename)): raise AssertionError spu = PseudoFileSPU(packagename) spu.textUpdate(None, statement) if spu.if_OK2_insert_info_FILENAME_SPU(): if load_file_into_agent(spu.filename, agent): return List(spu.getExprs()) w = Writeable() printErrors(spu, False, w) raise UnlocatedError(str(w))
def startExecuteTask(agent, listener, taskname, arguments): if not isinstance(listener, ExecutionListener): listener = None newlistener = _SparkExecutionListener(agent, listener) debug("creating listener %s with parent %s", newlistener, listener) executor = XPSExecutor.getNonsparkExecutor() if executor == None: raise LowError("XPSExecutor nonsparkExecutor is not set") larguments = List(arguments) log_outgoing_request(newlistener, "executeTask", (newlistener, taskname, larguments)) executor.executeTask(newlistener, taskname, toXPS(larguments)) return newlistener
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 conclude(self, agent, bindings, zexpr): """Conclude this predicate and return whether the database has been changed.""" from spark.internal.persist_aux import is_resuming if is_resuming(): return self.val = termEvalErr(agent, bindings, zexpr[0]) print "TestPersistPred: setting to %s" % self.val print "TestPersistPred: posting add fact event" from spark.pylang.defaultimp import AddFactEvent agent.post_event( AddFactEvent( self.symbol, List([termEvalErr(agent, bindings, z) for z in zexpr])))
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 match_inverse(self, agent, bindings, zexpr, obj): # require sequence type for obj try: temp = list(obj) except TypeError: return False numElements = len(zexpr) - 1 if len(temp) < numElements: return False else: vals = [List(temp[:-numElements])] + temp[-numElements:] for zitem, value in zip(zexpr, vals): if not termMatch(agent, bindings, zitem, value): return False return True
def format_string(format, args): newmsg = [] state = 0 aList = list(args) aList.reverse() for ch in format: if state == 0: number = "" if ch == '%': state = 1 else: newmsg.append(ch) elif state == 1: if ch == '%': newmsg.append(ch) state = 0 elif ch == 's': newmsg.append(to_string(_popArg(aList))) state = 0 elif ch == 'r': newmsg.append(value_str(_popArg(aList))) state = 0 elif ch.isdigit(): number = "%" + ch state = 2 elif ch == "d": newmsg.append("%d" % _popArg(aList)) state = 0 else: raise SyntaxError("Invalid format command: %%%s" % ch) elif state == 2: if ch.isdigit(): number = number + ch elif ch == "d": mess = number + "d" newmsg.append(mess % _popArg(aList)) state = 0 else: raise SyntaxError("Invalid format command: %s" % (number + ch)) if state == 1: raise SyntaxError("Unused Format string ends in %") if aList: aList.reverse() raise SyntaxError("Unused arguments in format string: %s" % value_str(List(aList))) return "".join(newmsg)
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 roles(self, agent): if self._cached_roles != None: return self._cached_roles roles_expr = self._procedure.closed_zexpr.keyget0("roles:") if roles_expr is None: roles = EMPTY_SPARK_LIST else: bindings = self.getBaseBindings() oldroles = quotedEval(agent, self.getBaseBindings(), roles_expr) # get variable bindings for the moment roles = List([ r.functor.structure(bindings.getVariableValue(agent, r[0])) for r in oldroles ]) # roles = () # for roles_expr in self._procedure.closed_expr.roles_exprs: # roles = roles + termEvalErr(agent, self.bindings, roles_expr.sub_expr()) self._cached_roles = roles return roles
def rawoaasolve(agent, sparkgoal, sparkparams, sparkpattern=None): oaa = _oaa(agent) iclgoal = value_to_icl(sparkgoal) iclparams = value_to_icl(sparkparams) iclanswers = IclList() debug("calling oaaSolve on %s", iclgoal) functor = iclgoal.functor logInfo("rawoaasolve[%s]" % functor) result = oaa.oaaSolve(iclgoal, iclparams, iclanswers) logInfo("rawoaasolve complete[%s]" % functor) if result: debug("oaaSolve returned success: %s", iclanswers) if not iclanswers.isList(): raise LowError( "The call to oaaSolve returned a non-IclList answer: %s" % iclanswers) if sparkpattern is None: ans = icl_to_value(iclanswers) else: bindings = HashMap() iclpattern = value_to_icl(sparkpattern) anslist = [] for iclans in iclanswers.iterator(): bindings.clear() if UNIFIER.matchTerms(iclans, iclgoal, bindings): anslist.append( icl_to_value(UNIFIER.deref(iclpattern, bindings))) else: raise LowError( "The call to oaaSolve returned an answer that doesn't unify with the query:\nans=%s\query=%s" % (iclans, iclgoal)) ans = List(anslist) logInfo("rawoaasolve answers deconstructed[%s]" % functor) return ans else: debug("oaaSolve return failure: %s", iclanswers) logError("rawoaasolve return failure with answers [%s]" % iclanswers) raise OAAError("The call to oaaSolve [goal %s] failed and returned %s"\ %(functor, iclanswers))
def sparkZip(*lists): return List(zip(*lists))
def custom_sort_list(x, fun_str): import code y = list(x) y.sort(eval(fun_str)) return List(y)
def sort_spark_list(x): y = list(x) y.sort() return List(y)
def call(self, agent, bindings, zexpr): l = [termEvalErr(agent, bindings, zitem) for zitem in zexpr] return List(l)
def listify(x): if isList(x): return x else: return List((x,))
def accumulator_values(acc): return List(acc[:])
def coerceToSPARKForOAA(self): return List(self._contents)
def __getitem__(self, index): if isinstance(index, types.SliceType): return List(self._contents[index]) else: return self._contents[index]
def state_args(self): return (List(self._contents),)