def ensure_callable(var):
if isinstance(var, term.Var):
error.throw_instantiation_error()
elif isinstance(var, term.Callable):
return var
else:
error.throw_type_error("callable", var)
def impl_univ(engine, heap, first, second):
if not isinstance(first, term.Var):
if helper.is_term(first):
assert isinstance(first, term.Callable)
sig = first.signature().atom_signature
l = [term.Callable.build(first.name(), signature=sig)] + first.arguments()
else:
l = [first]
u1 = helper.wrap_list(l)
if not isinstance(second, term.Var):
u1.unify(second, heap)
else:
u1.unify(second, heap)
else:
if isinstance(second, term.Var):
error.throw_instantiation_error()
else:
l = helper.unwrap_list(second)
head = l[0].dereference(heap)
if not isinstance(head, term.Atom):
error.throw_type_error("atom", head)
l2 = [None] * (len(l) - 1)
for i in range(len(l2)):
l2[i] = l[i + 1]
name = jit.hint(head.signature(), promote=True).name
term.Callable.build(name, l2).unify(first, heap)
def handle_use_module_with_library(engine, heap, module, path, imports=None):
import os
import os.path
from prolog.builtin.sourcehelper import get_filehandle
newpath = None
if path.signature().eq(libsig):
arg = path.argument_at(0)
if isinstance(arg, Var) or not isinstance(arg, Atom): # XXX throw different errors
error.throw_instantiation_error()
modulename = arg.name()
assert modulename is not None
for libpath in engine.modulewrapper.libs:
temppath = os.path.join(libpath, modulename)
try:
assert isinstance(temppath, str)
fd, _ = get_filehandle(temppath)
except OSError:
continue
assert 0, "unreachable"
else:
assert isinstance(fd, int)
os.close(fd) # cleanup
newpath = Atom(temppath)
break
if not newpath:
error.throw_existence_error("source_sink", arg)
else:
error.throw_existence_error("source_sink", path)
assert isinstance(newpath, Atom)
handle_use_module(engine, heap, module, newpath, imports)
def ensure_callable(var):
if isinstance(var, term.Var):
error.throw_instantiation_error()
elif isinstance(var, term.Callable):
return var
else:
error.throw_type_error("callable", var)
def handle_use_module_with_library(engine, heap, module, path, imports=None):
import os
import os.path
from prolog.builtin.sourcehelper import get_filehandle
newpath = None
if path.signature().eq(libsig):
arg = path.argument_at(0)
if isinstance(arg, Var) or not isinstance(
arg, Atom): # XXX throw different errors
error.throw_instantiation_error()
modulename = arg.name()
assert modulename is not None
for libpath in engine.modulewrapper.libs:
temppath = os.path.join(libpath, modulename)
try:
assert isinstance(temppath, str)
fd, _ = get_filehandle(temppath)
except OSError:
continue
assert 0, "unreachable"
else:
assert isinstance(fd, int)
os.close(fd) # cleanup
newpath = Atom(temppath)
break
if not newpath:
error.throw_existence_error("source_sink", arg)
else:
error.throw_existence_error("source_sink", path)
assert isinstance(newpath, Atom)
handle_use_module(engine, heap, module, newpath, imports)
def impl_functor(engine, heap, t, functor, arity):
if helper.is_atomic(t):
functor.unify(t, heap)
arity.unify(term.Number(0), heap)
elif helper.is_term(t):
assert isinstance(t, term.Callable)
sig = t.signature()
atom = term.Callable.build(t.name(), signature=sig.atom_signature)
functor.unify(atom, heap)
arity.unify(term.Number(t.argument_count()), heap)
elif isinstance(t, term.Var):
if isinstance(functor, term.Var):
error.throw_instantiation_error()
a = helper.unwrap_int(arity)
jit.promote(a)
if a < 0:
error.throw_domain_error("not_less_than_zero", arity)
else:
functor = helper.ensure_atomic(functor)
if a == 0:
t.unify(functor, heap)
else:
jit.promote(functor)
name = helper.unwrap_atom(functor)
t.unify(
term.Callable.build(name, [heap.newvar() for i in range(a)]),
heap)
def impl_number_chars(engine, heap, num, charlist):
if not isinstance(charlist, term.Var):
cons_to_num(charlist).unify(num, heap)
else:
if isinstance(num, term.Var):
error.throw_instantiation_error(num)
else:
num_to_list(num).unify(charlist, heap)
def impl_get_attr(engine, heap, var, attr, value):
if not isinstance(var, Var):
throw_instantiation_error(var)
if not isinstance(var, AttVar):
raise UnificationFailed()
attribute_value, _ = var.get_attribute(attr)
if attribute_value is not None:
value.unify(attribute_value, heap)
else:
raise UnificationFailed()
def unwrap_int(obj):
if isinstance(obj, term.Number):
return obj.num
elif isinstance(obj, term.Float):
f = obj.floatval; i = int(f)
if f == i:
return i
elif isinstance(obj, term.Var):
error.throw_instantiation_error()
error.throw_type_error('integer', obj)
def unwrap_int(obj):
if isinstance(obj, term.Number):
return obj.num
elif isinstance(obj, term.Float):
f = obj.floatval
i = int(f)
if f == i:
return i
elif isinstance(obj, term.Var):
error.throw_instantiation_error()
error.throw_type_error('integer', obj)
def convert_to_str(obj):
if isinstance(obj, term.Var):
error.throw_instantiation_error()
if isinstance(obj, term.Atom):
return obj.name()
elif isinstance(obj, term.Number):
return str(obj.num)
elif isinstance(obj, term.Float):
return str(obj.floatval)
elif isinstance(obj, term.BigInt):
return obj.value.str()
error.throw_type_error("atom", obj)
def make_option_dict(options):
opts = {}
for option in options:
if isinstance(option, term.Var):
error.throw_instantiation_error()
if isinstance(option, term.Numeric):
error.throw_domain_error("stream_option", option)
if isinstance(option, term.Callable) and option.argument_count() == 1:
arg0 = option.argument_at(0)
if isinstance(arg0, term.Atom):
opts[option.name()] = arg0.name()
return opts
def unwrap_stream(engine, obj):
if isinstance(obj, term.Var):
error.throw_instantiation_error()
if isinstance(obj, term.Atom):
try:
stream = engine.streamwrapper.aliases[obj.name()]
except KeyError:
pass
else:
assert isinstance(stream, PrologStream)
return stream
error.throw_domain_error("stream", obj)
def convert_to_str(obj):
if isinstance(obj, term.Var):
error.throw_instantiation_error()
if isinstance(obj, term.Atom):
return obj.name()
elif isinstance(obj, term.Number):
return str(obj.num)
elif isinstance(obj, term.Float):
return str(obj.floatval)
elif isinstance(obj, term.BigInt):
return obj.value.str()
error.throw_type_error("atom", obj)
def unwrap_stream(engine, obj):
if isinstance(obj, term.Var):
error.throw_instantiation_error()
if isinstance(obj, term.Atom):
try:
stream = engine.streamwrapper.aliases[obj.name()]
except KeyError:
pass
else:
assert isinstance(stream, PrologStream)
return stream
error.throw_domain_error("stream", obj)
def make_option_dict(options):
opts = {}
for option in options:
if isinstance(option, term.Var):
error.throw_instantiation_error()
if isinstance(option, term.Numeric):
error.throw_domain_error("stream_option", option)
if isinstance(option, term.Callable) and option.argument_count() == 1:
arg0 = option.argument_at(0)
if isinstance(arg0, term.Atom):
opts[option.name()] = arg0.name()
return opts
def impl_atom_chars(engine, heap, atom, charlist):
if not isinstance(charlist, term.Var):
if isinstance(atom, term.Atom):
atom_to_cons(atom).unify(charlist, heap)
else:
cons_to_atom(charlist).unify(atom, heap)
else:
if isinstance(atom, term.Var):
error.throw_instantiation_error()
elif not isinstance(atom, term.Atom):
error.throw_type_error("atom", atom)
else:
atom_to_cons(atom).unify(charlist, heap)
def unwrap_outstream(engine, obj):
if isinstance(obj, term.Var):
error.throw_instantiation_error()
if isinstance(obj, term.Atom):
try:
stream = engine.streamwrapper.aliases[obj.name()]
except KeyError:
pass
else:
if not isinstance(stream, PrologOutputStream):
error.throw_permission_error("output", "stream",
term.Atom(stream.alias))
assert isinstance(stream, PrologOutputStream)
return stream
error.throw_domain_error("stream", obj)
def unwrap_outstream(engine, obj):
if isinstance(obj, term.Var):
error.throw_instantiation_error()
if isinstance(obj, term.Atom):
try:
stream = engine.streamwrapper.aliases[obj.name()]
except KeyError:
pass
else:
if not isinstance(stream, PrologOutputStream):
error.throw_permission_error("output", "stream",
term.Atom(stream.alias))
assert isinstance(stream, PrologOutputStream)
return stream
error.throw_domain_error("stream", obj)
def impl_meta_predicate(engine, heap, predlist):
run = True
while run:
assert isinstance(predlist, Callable)
if predlist.signature().eq(andsig):
pred = predlist.argument_at(0)
predlist = predlist.argument_at(1)
if isinstance(predlist, Var):
error.throw_instantiation_error()
else:
pred = predlist
run = False
assert isinstance(pred, Callable)
args = unwrap_meta_arguments(pred)
engine.modulewrapper.current_module.add_meta_predicate(
pred.signature(), args)
def call(self, query, rule, scont, fcont, heap, k=0):
if isinstance(query, Var):
query = query.dereference(heap)
if not isinstance(query, Callable):
if isinstance(query, Var):
raise error.throw_instantiation_error()
raise error.throw_type_error('callable', query)
signature = query.signature()
builtin = self.get_builtin(signature)
if builtin is not None:
return BuiltinContinuation(self, rule, scont, builtin,
query), fcont, heap
# get embedding of querystring using charRNN
query_string = self.get_query_string(query)
query_embedding = self.get_query_embedding(querystring)
# find kth most similar rule
# TODO: figure out how to track k
rule_index, rule_score = self.get_similar_rule(query_embedding, k)
rule = self.index2rule[rule_index]
if (k >= self.maxk):
raise error.UnificationFailed
else:
k = k + 1
if heap.depth > self.max_depth:
raise error.UnificationFailed
scont, fcont, heap = _make_rule_conts(self, scont, fcont, heap, query,
rule, k, rule_score)
return scont, fcont, heap
def impl_meta_predicate(engine, heap, predlist):
run = True
while run:
assert isinstance(predlist, Callable)
if predlist.signature().eq(andsig):
pred = predlist.argument_at(0)
predlist = predlist.argument_at(1)
if isinstance(predlist, Var):
error.throw_instantiation_error()
else:
pred = predlist
run = False
assert isinstance(pred, Callable)
args = unwrap_meta_arguments(pred)
engine.modulewrapper.current_module.add_meta_predicate(
pred.signature(), args)
def call(self, query, rule, scont, fcont, heap):
if isinstance(query, Var):
query = query.dereference(heap)
if not isinstance(query, Callable):
if isinstance(query, Var):
raise error.throw_instantiation_error()
raise error.throw_type_error('callable', query)
signature = query.signature()
builtin = self.get_builtin(signature)
if builtin is not None:
return BuiltinContinuation(self, rule, scont, builtin,
query), fcont, heap
# do a real call
module = rule.module
function = self._get_function(signature, module, query)
query = function.add_meta_prefixes(query, module.nameatom)
startrulechain = jit.hint(function.rulechain, promote=True)
rulechain = startrulechain.find_applicable_rule(
query, heap, self.similarity)
if rulechain is None:
raise error.UnificationFailed
if heap.depth > self.max_depth:
raise error.UnificationFailed
scont, fcont, heap = _make_rule_conts(self, scont, fcont, heap, query,
rulechain)
return scont, fcont, heap
def unwrap_meta_arguments(predicate):
assert isinstance(predicate, Callable)
args = predicate.arguments()
arglist = []
for arg in args:
if isinstance(arg, Var):
error.throw_instantiation_error()
assert 0
elif isinstance(arg, Atom) and arg.name() in meta_args:
val = arg.name()
elif isinstance(arg, Number) and 0 <= arg.num <= 9:
val = str(arg.num)
else:
error.throw_domain_error("expected one of 0..9, :, ?, +, -", arg)
assert 0
arglist.append(val[0])
return "".join(arglist)
def unwrap_meta_arguments(predicate):
assert isinstance(predicate, Callable)
args = predicate.arguments()
arglist = []
for arg in args:
if isinstance(arg, Var):
error.throw_instantiation_error()
assert 0
elif isinstance(arg, Atom) and arg.name() in meta_args:
val = arg.name()
elif isinstance(arg, Number) and 0 <= arg.num <= 9:
val = str(arg.num)
else:
error.throw_domain_error("expected one of 0..9, :, ?, +, -", arg)
assert 0
arglist.append(val[0])
return "".join(arglist)
def call(self, query, rule, scont, fcont, heap, k = 0, parent_rule = None, sister_rule = None, first = False):
if isinstance(query, Var):
query = query.dereference(heap)
if not isinstance(query, Callable):
if isinstance(query, Var):
raise error.throw_instantiation_error()
raise error.throw_type_error('callable', query)
signature = query.signature()
builtin = self.get_builtin(signature)
rule1 = None
try:
rule1 = scont.rule
except:
pass
log_sister = (rule1 == rule) and scont.from_and
if builtin is not None:
if (signature.name != ','):
if (log_sister):
scont.sister_rule = sister_rule
scont = BuiltinContinuation(self, rule, scont, builtin, query, parent_rule, sister_rule)
return scont, fcont, heap
if first:
return self.regularcall(query, rule, scont, fcont, heap)
query_string = self.get_query_string(query)
rule = (parent_rule, sister_rule)
var_start = query_string.index('(')
var_end = query_string.index(')')
var = query_string[var_start+1:var_end]
var = map(str.strip, var)
if (len(var) < 4):
var += [None] * (4-len(var))
rule_dist, term_dist = run_model(query_string, rule, var)
print('TOP TEN RULES')
self.get_top_ten(rule_dist)
print('\n')
rule, score, rule_dist = self.get_next_rule(rule_dist, heap)
if (rule is None):
k = self.maxk
if (k < self.maxk):
k = k+1
if heap.depth > self.max_depth:
raise error.UnificationFailed
scont, fcont, heap = _make_rule_conts(self, scont, fcont, heap,\
query, rule, k, rule_dist, score, \
parent_rule, sister_rule, log_sister)
return scont, fcont, heap
def impl_arg(engine, heap, rule, first, second, third, scont, fcont):
if isinstance(second, term.Var):
error.throw_instantiation_error()
if isinstance(second, term.Atom):
raise error.UnificationFailed()
error.throw_type_error('compound', second)
if not helper.is_term(second):
error.throw_type_error("compound", second)
assert isinstance(second, term.Callable)
if isinstance(first, term.Var):
return continue_arg(engine, scont, fcont, heap, first, 0, second, third, rule)
elif isinstance(first, term.Number):
num = first.num
if num == 0:
raise error.UnificationFailed
if num < 0:
error.throw_domain_error("not_less_than_zero", first)
if num > second.argument_count():
raise error.UnificationFailed()
arg = second.argument_at(num - 1)
third.unify(arg, heap)
else:
error.throw_type_error("integer", first)
return scont, fcont, heap
def call(self, query, rule, scont, fcont, heap):
if isinstance(query, Var):
query = query.dereference(heap)
if not isinstance(query, Callable):
if isinstance(query, Var):
raise error.throw_instantiation_error()
raise error.throw_type_error('callable', query)
signature = query.signature()
builtin = self.get_builtin(signature)
if builtin is not None:
return BuiltinContinuation(self, rule, scont, builtin, query), fcont, heap
# do a real call
module = rule.module
function = self._get_function(signature, module, query)
query = function.add_meta_prefixes(query, module.nameatom)
startrulechain = jit.hint(function.rulechain, promote=True)
rulechain = startrulechain.find_applicable_rule(query)
if rulechain is None:
raise error.UnificationFailed
scont, fcont, heap = _make_rule_conts(self, scont, fcont, heap, query, rulechain)
return scont, fcont, heap
def eval_arithmetic(self, engine):
self = self.dereference(None)
if isinstance(self, Var):
error.throw_instantiation_error()
return self.eval_arithmetic(engine)
def eval_arithmetic(self, engine):
self = self.dereference(None)
if isinstance(self, Var):
error.throw_instantiation_error()
return self.eval_arithmetic(engine)
