def _reconstruct_prolog_code(self, acode): todo = [('and', [])] idx = 0 while idx < len(acode): a = acode[idx] if a == 'or(': todo.append(('or', [])) elif a == 'and(': todo.append(('and', [])) elif a == ')': c = todo.pop() todo[len(todo) - 1][1].append(Predicate(c[0], c[1])) else: clause = self.aip_parser.parse_line_clause_body(a) todo[len(todo) - 1][1].append(clause.body) idx += 1 if len(todo) != 1: logging.warn('unbalanced acode detected.') return None c = todo.pop() return Predicate(c[0], c[1])
def convert_nlp_test(pred): global test_cnt # print "% ", unicode(pred) lang = pred.args[0].name ivr_in = pred.args[1].args[0].args[0] ivr_out = pred.args[1].args[1].args[0] head = Predicate(name='nlp_test', args=[ StringLiteral(MODULE_NAME), Predicate(name=lang), StringLiteral('t%04d' % test_cnt), Predicate(name='FIXME'), ListLiteral([ivr_in, ivr_out, ListLiteral([])]) ]) test_cnt += 1 clause = Clause(head=head) print unicode(clause)
def _setup_context (self, user, lang, inp, prev_context, prev_res): cur_context = Predicate(do_gensym (self.rt, 'context')) res = { } if ASSERT_OVERLAY_VAR_NAME in prev_res: res[ASSERT_OVERLAY_VAR_NAME] = prev_res[ASSERT_OVERLAY_VAR_NAME].clone() res = do_assertz ({}, Clause ( Predicate('user', [cur_context, Predicate(user)]) , location=self.dummyloc), res=res) res = do_assertz ({}, Clause ( Predicate('lang', [cur_context, Predicate(lang)]) , location=self.dummyloc), res=res) token_literal = ListLiteral (list(map(lambda x: StringLiteral(x), inp))) res = do_assertz ({}, Clause ( Predicate('tokens', [cur_context, token_literal]) , location=self.dummyloc), res=res) currentTime = datetime.datetime.utcnow().replace(tzinfo=pytz.UTC).isoformat() res = do_assertz ({}, Clause ( Predicate('time', [cur_context, StringLiteral(currentTime)]) , location=self.dummyloc), res=res) if prev_context: res = do_assertz ({}, Clause ( Predicate('prev', [cur_context, prev_context]) , location=self.dummyloc), res=res) # copy over all previous context statements to the new one s1s = self.rt.search_predicate ('context', [prev_context, '_1', '_2'], env=res) for s1 in s1s: res = do_assertz ({}, Clause ( Predicate('context', [cur_context, s1['_1'], s1['_2']]) , location=self.dummyloc), res=res) # copy over all previous mem statements to the new one s1s = self.rt.search_predicate ('mem', [prev_context, '_1', '_2'], env=res) for s1 in s1s: res = do_assertz ({}, Clause ( Predicate('mem', [cur_context, s1['_1'], s1['_2']]) , location=self.dummyloc), res=res) # import pdb; pdb.set_trace() res['C'] = cur_context return res, cur_context
def convert_answerz(c): pred = c.head lang = pred.args[1].name n = pred.args[2].name pred = c.body s = pred.args[2].s head = Predicate( name='nlp_%s_r' % MODULE_NAME, args=[Predicate(name=lang), Predicate(name=n), Variable(name='R')]) body = Predicate( name='says', args=[Predicate(name=lang), Variable(name='R'), StringLiteral(s)]) clause = Clause(head=head, body=body) print unicode(clause)
def convert_nlp_gens(pred): # print "gens ", pred.args lang = pred.args[0].name ms = pred.args[1].s resp = pred.args[2] res = convert_macro_string(ms) res = Predicate( name='nlp_gens', args=[StringLiteral(MODULE_NAME), Predicate(name=lang), res, resp]) print unicode(res) + u'.'
def builtin_say_eoa(g, pe): """ say_eoa ( +Lang, +Str, [+Score] ) """ pe._trace('CALLED BUILTIN say_eoa', g) pred = g.terms[g.inx] args = pred.args if len(args) < 2: raise PrologRuntimeError('say_eoa: at least 2 args expected.') if len(args) > 3: raise PrologRuntimeError('say_eoa: max 3 args expected.') arg_L = pe.prolog_eval(args[0], g.env).name arg_S = pe.prolog_get_string(args[1], g.env) _queue_action(g, [Predicate('say'), arg_L, arg_S]) score = 0.0 if len(args) > 2: score = pe.prolog_get_float(args[2], g.env) _eoa(g, pe, score) return True
def _prolog_from_json(o): if o['pt'] == 'Constant': return Predicate(o['name']) if o['pt'] == 'StringLiteral': return StringLiteral(o['s']) if o['pt'] == 'NumberLiteral': return NumberLiteral(o['f']) if o['pt'] == 'ListLiteral': return ListLiteral(o['l']) raise PrologRuntimeError('cannot convert from json: %s .' % repr(o))
def _builtin_action_wrapper(self, name, g, pe): l = [Predicate(name)] for arg in g.terms[g.inx].args: # logging.debug ('_builtin_action_wrapper: %s arg=%s' % (name, repr(arg))) value = pe.prolog_eval(arg, g.env) l.append(value) if not ACTION_VARNAME in g.env: g.env[ACTION_VARNAME] = [] g.env[ACTION_VARNAME].append(l) return True
def convert_nlp_gen(pred): print "% ", unicode(pred) lang = pred.args[0].name ms = pred.args[1].s res = convert_macro_string(ms) head = Predicate(name='nlp_%s_s' % MODULE_NAME, args=[ Predicate(name=lang), Predicate(name='fixme'), Variable(name='S') ]) body = Predicate(name='hears', args=[Predicate(name=lang), Variable(name='S'), res]) clause = Clause(head=head, body=body) print unicode(clause)
def find_prev_context (self, user, env={}): pc = None ctxid = 0 # logging.debug ('find_prev_context: user=%s' % user) for s in self.rt.search_predicate('user', ['_1', Predicate(user)], env=env): cid = int (s['_1'].name[7:]) if not pc or cid>ctxid: pc = s['_1'] # logging.debug ('find_prev_context: s=%s, pc=%s' % (unicode(s), unicode(pc))) return pc
def builtin_say(g, pe): """ say ( +Lang, +Str ) """ pe._trace('CALLED BUILTIN say', g) pred = g.terms[g.inx] args = pred.args if len(args) != 2: raise PrologRuntimeError('say: 2 args expected.') arg_L = pe.prolog_eval(args[0], g.env).name arg_S = pe.prolog_get_string(args[1], g.env) _queue_action(g, [Predicate('say'), arg_L, arg_S]) return True
def builtin_r_sayv(g, pe): """" r_sayv (+Context, +Var, +Fmt) """ pe._trace('CALLED BUILTIN r_sayv', g) pred = g.terms[g.inx] args = pred.args if len(args) != 3: raise PrologRuntimeError( 'r_sayv: 3 args (+Context, +Var, +Fmt) expected.', g.location) arg_context = pe.prolog_eval(args[0], g.env, g.location) arg_var = pe.prolog_eval(args[1], g.env, g.location) arg_fmt = pe.prolog_get_constant(args[2], g.env, g.location) if not isinstance(arg_var, Literal): raise PrologRuntimeError( u'r_sayv: failed to eval "%s"' % unicode(args[1]), g.location) # import pdb; pdb.set_trace() res = {} if isinstance(arg_var, StringLiteral): v = arg_var.s else: v = unicode(arg_var) if arg_fmt == 'd': v = unicode(int(float(v))) elif arg_fmt == 'f': v = unicode(float(v)) res = do_assertz(g.env, Clause(Predicate( 'c_say', [arg_context, StringLiteral(v)]), location=g.location), res=res) return [res]
def rdf_to_pl(l): value = unicode(l) if isinstance(l, rdflib.Literal): if l.datatype: datatype = str(l.datatype) if datatype == 'http://www.w3.org/2001/XMLSchema#decimal': value = NumberLiteral(float(value)) elif datatype == 'http://www.w3.org/2001/XMLSchema#float': value = NumberLiteral(float(value)) elif datatype == 'http://www.w3.org/2001/XMLSchema#integer': value = NumberLiteral(float(value)) elif datatype == 'http://www.w3.org/2001/XMLSchema#dateTime': dt = dateutil.parser.parse(value) value = NumberLiteral(time.mktime(dt.timetuple())) elif datatype == 'http://www.w3.org/2001/XMLSchema#date': dt = dateutil.parser.parse(value) value = NumberLiteral(time.mktime(dt.timetuple())) elif datatype == DT_LIST: value = json.JSONDecoder( object_hook=_prolog_from_json).decode(value) elif datatype == DT_CONSTANT: value = Predicate(value) else: raise PrologRuntimeError( 'sparql_query: unknown datatype %s .' % datatype) else: if l.value is None: value = ListLiteral([]) else: value = StringLiteral(value) else: value = StringLiteral(value) return value
def builtin_r_say(g, pe): """" r_say (+Context, +Token) """ pe._trace('CALLED BUILTIN r_say', g) pred = g.terms[g.inx] args = pred.args if len(args) != 2: raise PrologRuntimeError('r_say: 2 args (+Context, +Token) expected.', g.location) arg_context = pe.prolog_eval(args[0], g.env, g.location) arg_token = pe.prolog_eval(args[1], g.env, g.location) # import pdb; pdb.set_trace() res = {} res = do_assertz(g.env, Clause(Predicate('c_say', [arg_context, arg_token]), location=g.location), res=res) return [res]
def builtin_ner(g, pe): global ner_dict """ ner (+Lang, +Cat, +TS, +TE, +Tokens, -Entity, -Score) """ pe._trace('CALLED BUILTIN ner', g) pred = g.terms[g.inx] args = pred.args if len(args) != 7: raise PrologRuntimeError( 'ner: 7 args ( +Lang, +Cat, +TS, +TE, +Tokens, -Entity, -Score ) expected.', g.location) # # extract args, tokens # arg_Lang = pe.prolog_get_constant(args[0], g.env, g.location) arg_Class = pe.prolog_eval(args[1], g.env, g.location) arg_TStart = pe.prolog_get_int(args[2], g.env, g.location) arg_TEnd = pe.prolog_get_int(args[3], g.env, g.location) arg_Tokens = pe.prolog_get_list(args[4], g.env, g.location) arg_Entity = pe.prolog_get_variable(args[5], g.env, g.location) arg_Score = pe.prolog_get_variable(args[6], g.env, g.location) # import pdb; pdb.set_trace() if not ner_dict: _build_ner_dict(pe) if not arg_Lang in ner_dict: raise PrologRuntimeError('ner: lang %s unknown.' % arg_Lang, g.location) tokens = list(map(lambda x: x.s, arg_Tokens.l)) res = [] if isinstance(arg_Class, Variable): for c in ner_dict[arg_Lang]: for entity, score in ner(arg_Lang, c, arg_TStart, arg_TEnd, tokens): r = { arg_Class.name: Predicate(c), arg_Entity: Predicate(entity), arg_Score: NumberLiteral(score) } res.append(r) else: if not arg_Class.name in ner_dict[arg_Lang]: raise PrologRuntimeError('ner: class %s unknown.' % arg_Class.name, g.location) for entity, score in _ner(arg_Lang, arg_Class.name, arg_TStart, arg_TEnd, tokens): r = { arg_Entity: Predicate(entity), arg_Score: NumberLiteral(score) } res.append(r) return res
def _rdf_exec(g, pe, generate_lists=False): # rdflib.plugins.sparql.parserutils.CompValue # # class CompValue(OrderedDict): # def __init__(self, name, **values): # # SelectQuery( # p = # Project( # p = # LeftJoin( # p2 = # BGP( # triples = [(rdflib.term.Variable(u'leaderobj'), rdflib.term.URIRef(u'http://dbpedia.org/ontology/leader'), rdflib.term.Variable(u'leader'))] # _vars = set([rdflib.term.Variable(u'leaderobj'), rdflib.term.Variable(u'leader')]) # ) # expr = # TrueFilter( # _vars = set([]) # ) # p1 = # BGP( # triples = [(rdflib.term.Variable(u'leader'), rdflib.term.URIRef(u'http://www.w3.org/1999/02/22-rdf-syntax-ns#type'), rdflib.term.URIRef(u'http://schema.org/Person')), (rdflib.term.Variable(u'leader'), rdflib.term.URIRef(u'http://www.w3.org/2000/01/rdf-schema#label'), rdflib.term.Variable(u'label'))] # _vars = set([rdflib.term.Variable(u'label'), rdflib.term.Variable(u'leader')]) # ) # _vars = set([rdflib.term.Variable(u'leaderobj'), rdflib.term.Variable(u'label'), rdflib.term.Variable(u'leader')]) # ) # PV = [rdflib.term.Variable(u'leader'), rdflib.term.Variable(u'label'), rdflib.term.Variable(u'leaderobj')] # _vars = set([rdflib.term.Variable(u'leaderobj'), rdflib.term.Variable(u'label'), rdflib.term.Variable(u'leader')]) # ) # datasetClause = None # PV = [rdflib.term.Variable(u'leader'), rdflib.term.Variable(u'label'), rdflib.term.Variable(u'leaderobj')] # _vars = set([rdflib.term.Variable(u'leaderobj'), rdflib.term.Variable(u'label'), rdflib.term.Variable(u'leader')]) # ) pred = g.terms[g.inx] args = pred.args # if len(args) == 0 or len(args) % 3 != 0: # raise PrologRuntimeError('rdf: one or more argument triple(s) expected, got %d args' % len(args)) distinct = False triples = [] optional_triples = [] filters = [] limit = 0 offset = 0 arg_idx = 0 var_map = {} # string -> rdflib.term.Variable while arg_idx < len(args): arg_s = args[arg_idx] # check for optional structure if isinstance(arg_s, Predicate) and arg_s.name == 'optional': s_args = arg_s.args if len(s_args) != 3: raise PrologRuntimeError('rdf: optional: triple arg expected') arg_s = s_args[0] arg_p = s_args[1] arg_o = s_args[2] logging.debug('rdf: optional arg triple: %s' % repr( (arg_s, arg_p, arg_o))) optional_triples.append( (pl_to_rdf(arg_s, g.env, pe, var_map, pe.kb), pl_to_rdf(arg_p, g.env, pe, var_map, pe.kb), pl_to_rdf(arg_o, g.env, pe, var_map, pe.kb))) arg_idx += 1 # check for filter structure elif isinstance(arg_s, Predicate) and arg_s.name == 'filter': logging.debug('rdf: filter structure detected: %s' % repr(arg_s.args)) s_args = arg_s.args # transform multiple arguments into explicit and-tree pl_expr = s_args[0] for a in s_args[1:]: pl_expr = Predicate('and', [pl_expr, a]) filters.append( prolog_to_filter_expression(pl_expr, g.env, pe, var_map, pe.kb)) arg_idx += 1 # check for distinct elif isinstance(arg_s, Predicate) and arg_s.name == 'distinct': s_args = arg_s.args if len(s_args) != 0: raise PrologRuntimeError( 'rdf: distinct: unexpected arguments.') distinct = True arg_idx += 1 # check for limit/offset elif isinstance(arg_s, Predicate) and arg_s.name == 'limit': s_args = arg_s.args if len(s_args) != 1: raise PrologRuntimeError('rdf: limit: one argument expected.') limit = pe.prolog_get_int(s_args[0], g.env) arg_idx += 1 elif isinstance(arg_s, Predicate) and arg_s.name == 'offset': s_args = arg_s.args if len(s_args) != 1: raise PrologRuntimeError('rdf: offset: one argument expected.') offset = pe.prolog_get_int(s_args[0], g.env) arg_idx += 1 else: if arg_idx > len(args) - 3: raise PrologRuntimeError( 'rdf: not enough arguments for triple') arg_p = args[arg_idx + 1] arg_o = args[arg_idx + 2] logging.debug('rdf: arg triple: %s' % repr((arg_s, arg_p, arg_o))) triples.append( (pl_to_rdf(arg_s, g.env, pe, var_map, pe.kb), pl_to_rdf(arg_p, g.env, pe, var_map, pe.kb), pl_to_rdf(arg_o, g.env, pe, var_map, pe.kb))) arg_idx += 3 logging.debug('rdf: triples: %s' % repr(triples)) logging.debug('rdf: optional_triples: %s' % repr(optional_triples)) logging.debug('rdf: filters: %s' % repr(filters)) if len(triples) == 0: raise PrologRuntimeError( 'rdf: at least one non-optional triple expected') var_list = var_map.values() var_set = set(var_list) p = CompValue('BGP', triples=triples, _vars=var_set) for t in optional_triples: p = CompValue('LeftJoin', p1=p, p2=CompValue('BGP', triples=[t], _vars=var_set), expr=CompValue('TrueFilter', _vars=set([]))) for f in filters: p = CompValue('Filter', p=p, expr=f, _vars=var_set) if limit > 0: p = CompValue('Slice', start=offset, length=limit, p=p, _vars=var_set) if distinct: p = CompValue('Distinct', p=p, _vars=var_set) algebra = CompValue('SelectQuery', p=p, datasetClause=None, PV=var_list, _vars=var_set) result = pe.kb.query_algebra(algebra) logging.debug('rdf: result (len: %d): %s' % (len(result), repr(result))) if len(result) == 0: return False if generate_lists: # bind each variable to list of values for binding in result: for v in binding.labels: l = binding[v] value = rdf_to_pl(l) if not v in g.env: g.env[v] = ListLiteral([]) g.env[v].l.append(value) return True else: # turn result into list of bindings res_bindings = [] for binding in result: res_binding = {} for v in binding.labels: l = binding[v] value = rdf_to_pl(l) res_binding[v] = value res_bindings.append(res_binding) if len(res_bindings) == 0 and len(result) > 0: res_bindings.append({}) # signal success logging.debug('rdf: res_bindings: %s' % repr(res_bindings)) return res_bindings