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