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),)
