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