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 defprocedure_exprs_name(agent, exprs):
if not (isList(exprs)): raise AssertionError
if (len(exprs) != 1): raise AssertionError
pfe = exprs[0]
if pfe.functor != Symbol('defprocedure{}'):
raise LocatedError(pfe, "must be {defprocedure ...}")
return pfe[0].asValue()
def mapGetPred(map, *keysAndValues):
if not isMap(map):
raise RuntimeException("First argument to MapGet must be a map")
result = list(keysAndValues)
for index in range(0, len(result)-1, 2):
key = result[index]
if key == None:
raise RuntimeException("Must have bound values for keys in MapGet")
if isString(key):
default = None
elif isList(key) and len(key) == 2 and isString(key[0]):
default = key[1]
key = key[0]
else:
raise RuntimeException("Each MapGet key must be a String or a List of a String and a default value")
val = mapGet(map, key)
if val == None: # key isn't found
if default == None:
return None
else:
val = default
if result[index+1] == None: # No value specified
result[index+1] = val
elif result[index+1] != val: # Incorrect value specified
return None
if len(result)%2 != 0: # odd number of arguments
key = result[-1]
if key == None:
raise RuntimeException("Final MapGet key must be supplied")
if not isString(key):
raise RuntimeException("Final MapGet key must be a String")
if mapGet(map, key) == None: # specified key is not present
return None
return result
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_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 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 startXMLRPCServer(agent, params):
"""Start up an XML-RPC server on the localhost.
params is a list [portnum].
Raises an exception if agent already has a server started or if
it cannot use that port.
"""
if not isList(params) or len(params) != 1:
raise LowError("The parameters to startXMLServer must be of the form [$portnum]")
port = params[0]
global _SERVER
if _SERVER:
raise RuntimeException("Agent already has an XML-RPC server set up")
try:
server = MyServer(agent, port)
except socket.error, e:
# TODO: handle error properly, check the code and give a proper message
raise RuntimeException("Error opening socket")
def __init__(self, name, event, bindings, taskexpr):
TFrame.__init__(self, name, event)
self._bindings = bindings
from spark.internal.parse.expr import Expr
if isinstance(taskexpr, Expr): # ordinary creation
self._estack = [taskexpr]
self._dstack = [DSTACK_UNUSED_VALUE]
self._root_taskexpr = taskexpr
elif isList(taskexpr): # taskexpr = [root_taskexpr] when resuming
self._root_taskexpr = taskexpr[0]
# rely on set_state to set the following
self._estack = []
self._dstack = []
else:
raise UnlocatedError("Not an Expr or SPARK list of Exprs: %r" %
taskexpr)
self._subgoal_event = None
self._subgoal_event_list = []
def __init__(self, name, event, bindings, taskexpr):
TFrame.__init__(self, name, event)
self._bindings = bindings
from spark.internal.parse.expr import Expr
if isinstance(taskexpr, Expr): # ordinary creation
self._estack = [taskexpr]
self._dstack = [DSTACK_UNUSED_VALUE]
self._root_taskexpr = taskexpr
elif isList(taskexpr): # taskexpr = [root_taskexpr] when resuming
self._root_taskexpr = taskexpr[0]
# rely on set_state to set the following
self._estack = []
self._dstack = []
else:
raise UnlocatedError("Not an Expr or SPARK list of Exprs: %r" % taskexpr)
self._subgoal_event = None
self._subgoal_event_list = []
def mapGet(map, key):
"Return the value found for the given key in the map or None if not found"
if isStructure(map):
if key == _TYPE:
return map.functor.name
lenKey1 = len(key) + 1
for kv in map:
if isStructure(kv):
k = kv.functor.name
if len(k) == lenKey1 and k.startswith(key) and k.endswith(":"):
return kv[0]
else:
raise LowError("Not a valid map")
return None
elif isList(map) and len(map) == 2 and len(map[0]) == len(map[1]): # allows for old list of lists format
for index, keyi in enumerate(map[0]):
if keyi == key:
return map[1][index]
return None
else:
raise LowError("Not a valid map")
def encodeXMLValue(sparkValue):
"Converts a SPARK value to a python value that can be passed by XML"
if isinstance(sparkValue, UNCHANGED_TYPES):
return sparkValue
if sparkValue == sparkNULL():
return None
elif isStructure(sparkValue):
d = mapDict(sparkValue, encodeXMLValue)
if d != None:
return d
else:
# Use FUNCTOR/ARGS notation
return {FUNCTOR:sparkValue.functor.name,
ARGS:encodeXMLValues(sparkValue)}
elif isList(sparkValue):
return encodeXMLValues(sparkValue)
elif isSymbol(sparkValue):
return {SYM:sparkValue.name}
elif isVariable(sparkValue):
return {VAR:sparkValue.name}
else:
raise LowError("Cannot convert python type %r to XML"%sparkValue.__class__)
def mapGet(map, key):
"Return the value found for the given key in the map or None if not found"
if isStructure(map):
if key == _TYPE:
return map.functor.name
lenKey1 = len(key) + 1
for kv in map:
if isStructure(kv):
k = kv.functor.name
if len(k) == lenKey1 and k.startswith(key) and k.endswith(":"):
return kv[0]
else:
raise LowError("Not a valid map")
return None
elif isList(map) and len(map) == 2 and len(map[0]) == len(
map[1]): # allows for old list of lists format
for index, keyi in enumerate(map[0]):
if keyi == key:
return map[1][index]
return None
else:
raise LowError("Not a valid map")
def access(obj, *accessors):
value = obj
for accessor in accessors:
if isList(accessor):
if len(accessor) == 1:
value = value[accessor[0]]
else:
raise LowError("Invalid accessor: %r", accessor)
elif isStructure(accessor):
methodname = accessor.functor.name
method = getattr(value, methodname, None)
if method == None:
raise LowError("Object has no method called %s", methodname)
value = method(*accessor)
elif isSymbol(accessor):
value = getattr(value, accessor.name, None)
elif isInteger(accessor):
value = value[accessor]
else:
raise LowError("Invalid accessor: %r", accessor)
if value == None:
return None
return value
def access(obj, *accessors):
value = obj
for accessor in accessors:
if isList(accessor):
if len(accessor) == 1:
value = value[accessor[0]]
else:
raise LowError("Invalid accessor: %r", accessor)
elif isStructure(accessor):
methodname = accessor.functor.name
method = getattr(value, methodname, None)
if method == None:
raise LowError("Object has no method called %s", methodname)
value = method(*accessor)
elif isSymbol(accessor):
value = getattr(value, accessor.name, None)
elif isInteger(accessor):
value = value[accessor]
else:
raise LowError("Invalid accessor: %r", accessor)
if value == None:
return None
return value
def mapGetPred(map, *keysAndValues):
if not isMap(map):
raise RuntimeException("First argument to MapGet must be a map")
result = list(keysAndValues)
for index in range(0, len(result) - 1, 2):
key = result[index]
if key == None:
raise RuntimeException("Must have bound values for keys in MapGet")
if isString(key):
default = None
elif isList(key) and len(key) == 2 and isString(key[0]):
default = key[1]
key = key[0]
else:
raise RuntimeException(
"Each MapGet key must be a String or a List of a String and a default value"
)
val = mapGet(map, key)
if val == None: # key isn't found
if default == None:
return None
else:
val = default
if result[index + 1] == None: # No value specified
result[index + 1] = val
elif result[index + 1] != val: # Incorrect value specified
return None
if len(result) % 2 != 0: # odd number of arguments
key = result[-1]
if key == None:
raise RuntimeException("Final MapGet key must be supplied")
if not isString(key):
raise RuntimeException("Final MapGet key must be a String")
if mapGet(map, key) == None: # specified key is not present
return None
return result
def to_string(arg):
if isList(arg):
return "[%s]" % (" ".join([to_string(x) for x in arg]))
else:
return str(arg)
def to_string(arg):
if isList(arg):
return "[%s]"%(" ".join([to_string(x) for x in arg]))
else:
return str(arg)
def listify(x):
if isList(x):
return x
else:
return List((x,))
def _appropriate(fact):
m = fact[3]
return m == EMPTY_SPARK_LIST \
or m == mechanism \
or (isList(mechanism) and m in mechanism)
