def build_term(dict): """ Builds a Term object from the term metadata dictionary provided. """ # Add our metadata to our term piece-by-piece term = Term() try: term.id = dict['id'][0] term.name = dict['name'][0] except KeyError as k: raise TermMissingRequiredFieldException("Missing required field %s" % k) termDef = dict.get('def', [""]) term.definition = termDef[0] obsoleteBool = dict.get('is_obsolete', [False]) term.obsolete = obsoleteBool[0] term.synonyms.extend( format_synonym_list(dict.get('synonym', [])) ) term.relationships.extend( dict.get('relationship', []) ) term.xrefs.extend( dict.get('xref', []) ) term.alternateIds.extend( dict.get('alt_id', []) ) term.subsets.extend( dict.get('subset', []) ) return term
def test_parse_term_with_valid_strings(self): with self.subTest('2'): term = Term.parse_term('2') expected_term = Term.constant(2) self.assertEqual(term, expected_term) with self.subTest('x'): term = Term.parse_term('x') expected_term = Term(coeff=1, variable='x', power=1) self.assertEqual(term, expected_term) with self.subTest('x^2'): term = Term.parse_term('x^2') expected_term = Term(coeff=1, variable='x', power=2) self.assertEqual(term, expected_term) with self.subTest('2*x'): term = Term.parse_term('2*x') expected_term = Term(coeff=2, variable='x', power=1) self.assertEqual(term, expected_term) with self.subTest('2*x^2'): term = Term.parse_term('2*x^2') expected_term = Term(coeff=2, variable='x', power=2) self.assertEqual(term, expected_term)
def test__add__(self): term1 = Term(coeff=5, power=2) term2 = Term(coeff=2, power=2) result = term1 + term2 expected_result = Term(coeff=7, power=2) self.assertEqual(expected_result, result)
def shell(asker): current_view = view(T.from_list_of_str(["(Home)"]), T.from_dict({})) asker.tag(T("the current view"), current_view) while True: input = asker.ask_firmly(elicit(current_view)) asker.ask(update_view(current_view, input)) current_view = asker.refresh(current_view)
def p_typed_constants_lst(p): '''typed_constants_lst : constants_lst HYPHEN type typed_constants_lst | constants_lst HYPHEN type''' if len(p) == 4: p[0] = [Term.constant(value, p[3]) for value in p[1]] elif len(p) == 5: p[0] = [Term.constant(value, p[3]) for value in p[1]] + p[4]
def p_constants_lst(p): '''constants_lst : constant constants_lst | constant''' if len(p) == 2: p[0] = [Term.constant(p[1])] elif len(p) == 3: p[0] = [Term.constant(p[1])] + p[2]
def p_typed_variables_lst(p): '''typed_variables_lst : variables_lst HYPHEN type typed_variables_lst | variables_lst HYPHEN type''' if len(p) == 4: p[0] = [Term.variable(name, p[3]) for name in p[1]] elif len(p) == 5: p[0] = [Term.variable(name, p[3]) for name in p[1]] + p[4]
def render_term(asker, term): return asker.reply(answer=strings.concat( strings.concat( T.from_str("T("), field.get(asker, representations.head(), term)), T.from_str(")") ))
def p_variables_lst(p): '''variables_lst : variable variables_lst | variable''' if len(p) == 2: p[0] = [Term.variable(p[1])] elif len(p) == 3: p[0] = [Term.variable(p[1])] + p[2]
def handler(postingList): """ @describe: 将磁盘上的倒排记录表加载到内存 @param postingList: 一项倒排记录表磁盘存储项,包括词项、文档频率、高低端倒排记录表 """ # 初始化 term = postingList['term'] df = postingList['df'] highPostingList = postingList['highPostingList'] lowPostingList = postingList['lowPostingList'] # 定义倒排词项 hash[term] = Term() hash[term].df = df # 高端倒排记录表整理 if len(highPostingList) > 0: link = Link() for posting in highPostingList: link.append( Posting(posting['docID'], posting['tf'], posting['static_grade'], posting['time'])) hash[term].high_posting_list = link.head # 低端倒排记录表整理 if len(lowPostingList) > 0: link = Link() for posting in lowPostingList: link.append( Posting(posting['docID'], posting['tf'], posting['static_grade'], posting['time'])) hash[term].low_posting_list = link.head
def build(self, words, normalized, doc_len): terms_dic = dict() for word in words: term = terms_dic.get(word.word_id, None) if term is None: term = Term(word.word_id, 0) terms_dic[term.term_id] = term term.weight += 1 vec = list() i = 0 normalizer = 0 for term in terms_dic.values(): if normalized: term.weight /= float(doc_len) term.weight = self.term_weighter.cal_weight( term.term_id, term.weight) vec.append(term) normalizer += term.weight * term.weight i += 1 if normalized: normalizer = math.sqrt(normalizer) for term in vec: term.weight /= normalizer sorted(vec) return vec
def exposed_modifier(asker, rep): head = asker.ask(fields.get_field(representations.head(), rep)).answer if head is None: return asker.reply(answer=T.no()) else: result = strings.to_str(asker, head) not in hidden_modifier_heads return asker.reply(answer=T.from_bool(result))
def test(cls, axioms, ntests: int, merge_se: bool, typs_d: dict, lang_cls): assert isinstance(axioms, list) and axioms assert isinstance(ntests, int) and ntests > 0, ntests assert isinstance(typs_d, dict), typs_d iaxioms = [] test_funs = [] for i, axiom in enumerate(axioms): axioms_, test_funs_ = axiom.gen_test_funs(i, merge_se, typs_d, ntests, lang_cls) iaxioms.extend(axioms_) test_funs.extend(test_funs_) logger.info("{} instantiated candidates".format(len(iaxioms))) logger.detail("\n" + Term.str_of_terms(iaxioms)) logger.info("test against random inputs") code = lang_cls.mk_fun_main(test_funs) stats = lang_cls.myrun(code) #CM.pause() assert len(iaxioms) == len(stats) axioms = [axiom for axiom, stat in zip(iaxioms, stats) if stat] logger.info("{} candidate(s)".format(len(axioms))) if axioms: logger.debug("\n" + Term.str_of_terms(axioms)) return axioms
def setUp(self): self._first_polynomial = Polynomial([Term(2, 2), Term(2, 3)]) self._second_polynomial = Polynomial([Term(2, 4), Term(2, 2)]) self._result = {6: 4, 4: 4, 7: 4, 5: 4}
def main(): l = load() t = Term() x, y = 3, 3 pos = { '\x1b[A': (+1, 0), # up '\x1b[B': (-1, 0), # down '\x1b[C': (0, -1), # right '\x1b[D': (0, +1), # left } playing = True while playing: paint(l) k = t.get() m = pos.get(k) if not m: continue xx, yy = m xx += x yy += y if xx < 0 or xx > 3 or yy < 0 or yy > 3: continue l[x][y] = l[xx][yy] l[xx][yy] = '' x, y = xx, yy playing = not validate(l) paint(l) print("You Win!")
def preprocessing(data, StopWords): """ Parameters data ---------- data : string 数据的预处理 分离单词 去重、单词还原、去除标点 Returns : pure data ------- """ words = data['text'].lower() #变小写 r = '[~`!#$%^&*()_+-=|\';":/.,?><~·!@#¥%……&*()——+-=“:’;、。,?》《{}...]+' #去除标点 words = re.sub(r, "", words) words = words.split(" ") #分离单词 #去除停用词 words = [word for word in words if word not in StopWords and word != ''] #单词还原为原型 通过nltk 先标词形再还原_ #words: [Term(a,n)...] ret_words = [] words.sort() num = 0 old = words[0] for i in words: if old == i: num = num + 1 else: ins = Term(old, num) ret_words.append(ins) #num就是tf old = i num = 1 ins = Term(old, num) #补充最后一个 ret_words.append(ins) result = {"id": data['tweetId'], "words": ret_words, "size": len(words)} return result
def multiply_exponents(term1: Term) -> (Term, bool): assert term1.label == POW """ (a^b)^c --> a^(b*c) """ if term1.children[0].label == POW: return Term(POW, [term1.children[0].children[0], Term(MUL, [term1.children[1], term1.children[0].children[1]])]), True return term1, False
def sin_derivative(term1: Term, rules) -> Term: """rule for differentiating sinus: (sin(u))' = cos(u)*u'""" return Term(MUL, [ Term(COS, [term1.children[0]]), calculate_derivative(term1.children[0], rules) ])
def test_is_property(self): with self.subTest('True'): term = Term.constant(7) self.assertTrue(term.is_constant) with self.subTest('False'): term = Term(coeff=5, power=1) self.assertFalse(term.is_constant)
def calculate_derivative(term1: Term, rules: dict) -> Term: """uses a rule which then loops to differentiate""" if isinstance(term1.label, numbers.Number): return Term(0) elif term1.label == VAR: return Term(1) else: return rules[term1.label](term1, rules)
def cos_derivative(term1: Term, rules) -> Term: """rule for differentiating cosinus: (cos(u))' = -sin(u)*u' """ return Term(MUL, [ Term(-1), Term(SIN, [term1.children[0]]), calculate_derivative(term1.children[0], rules) ])
def mul_derivative(term1: Term, rules) -> Term: """rule for differentiating a product: (uv)' = u'v + uv'""" child1, child2 = term1.children # assumes binary tree return Term(ADD, [ Term(MUL, [calculate_derivative(child1, rules), child2]), Term(MUL, [child1, calculate_derivative(child2, rules)]) ])
def __reduceCoeff(self, reduced): coeff_map = {} last_operator = '+' # x+x -> coeff_map[x]=2 for term in reduced: if term not in ['+', '-']: coeff = term.getCoeff() without_coeff_factor = term.getWithoutCoeffFactor() without_coeff_factor_term = None facs = [] ops = [] if len(without_coeff_factor) != 0: for fac in without_coeff_factor: if fac not in ['*', '/']: facs.append(fac) else: ops.append(fac) without_coeff_factor_term = Term(facs, ops) if without_coeff_factor_term == None: key = "NONE" else: key = without_coeff_factor_term.toString() if coeff_map.get(key) == None: coeff_map[key] = [ eval(last_operator + repr(coeff)), without_coeff_factor ] else: coeff_map[key][0] += eval(last_operator + repr(coeff)) else: last_operator = term faclist = coeff_map.keys() faclist = ds.class_sort(faclist) _reduced = [] # coeff_map[x*y*z]=2 -> 2*x*y*z for fac in faclist: to_term = [] to_term_ops = [] coeff = coeff_map[fac][0] real_factor = coeff_map[fac][1] to_term.append(Number(coeff)) if len(real_factor) > 0: to_term_ops.append('*') # x*y*z for each_factor in real_factor: if each_factor in ['*', '/']: to_term_ops.append(each_factor) else: to_term.append(each_factor) if len(_reduced) > 0: _reduced.append('+') _reduced.append(Term(to_term, to_term_ops)) return _reduced
def distributive_property(term1: Term) -> (Term, bool): """ x*x*(1+3) --> x*x*1 + x*x*3 """ for i, child in enumerate(term1.children): # look for sum, if found use distributive property if child.label == ADD: term1.children.pop(i) # remove that sum, whats left are the terms from product to be distributed return Term(ADD, [Term(MUL, children=[summand] + [Term.copy(child) for child in term1.children]) for summand in child.children]), True else: # not found a sum among children return term1, False
def __merge_terms(self, terms): merged_expr = [Term(0.0, 2), Term(0.0, 1), Term(0.0, 0)] for term in terms: if term.degree == 2: merged_expr[0].coef += term.coef if term.degree == 1: merged_expr[1].coef += term.coef if term.degree == 0: merged_expr[2].coef += term.coef return merged_expr
def tan_derivative(term1: Term, rules) -> Term: """rule for differentiating tangens: (tan(u))' = u' + u'*(tan(u))^2""" arg = Term.copy(term1.children[0]) return Term(ADD, [ calculate_derivative(arg, rules), Term(MUL, [calculate_derivative(arg, rules), Term(POW, [term1, Term(2)])]) ])
def try_to_simplify(self, index_pairs): """ take a*b+a*c+d, and indexes [(0, 0), (1, 0)] - indexes choosing both a's, and try to simplify (b+c), if simplification reduced (b+c) to single value (d) then add a*(d) to self.term.children instead of a*(b+c). Function to be used inside extract_term. It takes a term and information on which terms are equal so can be extracted out of the sum. It does exactly that - extract the term out of the sum and tries to simplify() whats left. If it can simplify it does that and function returns extracted_term * whats_simplified among other summands of term1 that are left untouched. Further simpification back to the sum is left to distributive_property(). If no simplification can be made term is untouched - function tries to simplify on copy of terms. index_pairs describe where are the equal terms - its a single 2 element list yield by generate_index_pairs. List format is a list of pairs (i, j or None) so pairs of 2 indexes or 1 index and None. First index corresponds to index in term1.children, second to index in child.children. 'None' means its child itself. """ # need to make a copy of term1.children # want to try simplifying, but reverse changes if can't simplify children_copy = self.get_children_copy() # take any term of those equal terms if index_pairs[0][1] is None: # term is a simple term (i.e: x) extracted_term = children_copy[index_pairs[0][0]] else: # term is MUL term (i.e: (* x 4)) extracted_term = (children_copy[index_pairs[0][0]]).children[index_pairs[0][1]] # here its unnecessarily general, due to change of implementation children_left_untouched = [] children_after_term_extracted = [] positions_dict = dict(index_pairs) # child in term index : subchild in child.chldren or None affected_indexes = set((i for (i, j) in index_pairs)) for i, child in enumerate(children_copy): if i in affected_indexes: if positions_dict[i] is None: children_after_term_extracted.append(Term(1)) else: j = positions_dict[i] child.children.pop(j) # modifies child children_after_term_extracted.append(child) else: children_left_untouched.append(child) old_length = len(children_after_term_extracted) term_after_extracted = Term(ADD, children_after_term_extracted) simplified_term = do_simplifications(term_after_extracted, self.rules) simplified = len(simplified_term.children) < old_length or simplified_term.label != ADD # did it do anything? if simplified: new_term = Term(MUL, [extracted_term, simplified_term]) # ^ we rely on distributive property implemented in other function # to distribute extracted term back to terms. children_left_untouched.append(new_term) # already touched return Term(ADD, children_left_untouched), True else: return None, False
def add_exponents(term1: Term) -> (Term, bool): """ a * b ^ c * b --> a * b ^ (c + 1) """ assert term1.label == MUL for i, child_annie in enumerate(term1.children): for j, child_frank in enumerate(term1.children): if j == i: continue if child_annie.label == POW: # annie = a^b base_annie, exponent_annie = child_annie.children if child_frank.label == POW: # frank = c^d base_frank, exponent_frank = child_frank.children if terms_equal(base_annie, base_frank): # a=c; return a^(b+d) # remove ith and jth, append a^(b+d) return Term(term1.label, [term1.children[k] for k in range(len(term1.children)) if k not in [i, j]] + [Term(POW, [base_annie, Term(ADD, [exponent_annie, exponent_frank])])]), True else: # frank = f if terms_equal(child_frank, base_annie): # f=a; a^(b+1) # remove ith and jth, append a^(b+1) return Term(term1.label, [term1.children[k] for k in range(len(term1.children)) if k not in [i, j]] + [Term(POW, [base_annie, Term(ADD, [exponent_annie, Term(1)])])]), True if terms_equal(child_annie, child_frank): # a*a=a^2 return Term(term1.label, [term1.children[k] for k in range(len(term1.children)) if k not in [i, j]] + [Term(POW, [child_annie, Term(2)])]), True return term1, False
def render_list(asker, x): result = T.from_str("[") first = True for item in lists.iterator(asker, x): item_printed = asker.ask_firmly(render(item)) if not first: item_printed = strings.concat(T.from_str(", "), item_printed) first = False result = strings.concat(result, item_printed) result = strings.concat(result, T.from_str("]")) return asker.reply(answer=result)
def test_disk_read(): # test_disk_write() index = Index() index.insert(Term('json again')) index.insert(Term('json again')) index.insert(Term('json again')) index.root.disk_write() index.root.child[1].disk_write() index.root.child[2].disk_write() index.disk_write()
def getDerivativeBy(self, by_variable): factors=[] ops=[] factors.append(Number(-1)) ops.append('*') factors.append(Sin(self.param)) ops.append('*') factors.append(Paranthesis(self.param.getDerivativeBy(by_variable))) aa=Paranthesis(self.param.getDerivativeBy(by_variable)) a=Paranthesis(Expression([Term(factors,ops)], [])) return Paranthesis(Expression([Term(factors,ops)], []))
def make_raw_expr(xs): text = "" args = {} for x in xs: if type(x) is str: text += x else: arg_name = ("xyzw"+alphas)[len(args)] text += "[{}]".format(arg_name) args[arg_name] = x return T(make_raw_expr.head, text=T.from_str(text), bindings=T.from_dict_of_str(args))
def one_zero_in_exponent(term1: Term) -> (Term, bool): basis, index = term1.children[0], term1.children[1] if index.label == 0: return Term(1), True if index.label == 1: return basis, True if basis.label == 1: return Term(1), True if basis.label == 0: return Term(0), True return term1, False
def test__str__(self): with self.subTest('Prints all terms sorted'): self.p.add_term(Term.constant(0)) expected = '5*x^3 + 2*x^2 + 5' self.assertEqual(expected, str(self.p)) with self.subTest('With a term that is: 0'): self.p.add_term(Term.constant(0)) expected = '5*x^3 + 2*x^2 + 5' self.assertEqual(expected, str(self.p))
class TestTerm(unittest.TestCase): def setUp(self): self._term = Term(2, 7) def test_get_power(self): self.assertEqual(self._term.get_power(), 7) def test_get_coefficient(self): self.assertEqual(self._term.get_coefficient(), 2) def tearDown(self): self._term = None
def add_pred(self, name, args): args2 = [] for a in args: if type(a) is tuple: # name of variable with type arg = Term(name=a[0], type=a[1]) elif type(a) is str: # a constant value arg = Term(value=a[0]) else: print( 'ERROR: something went wrong, incorrect argument for predicate {}' .format(name)) args2.append(arg) self._predicates.append(Predicate(name, args2))
def render_pair(asker, x): return asker.reply(answer=strings.concat( strings.concat( T.from_str("("), asker.ask_firmly(render(fields.get(pairs.first(), x))), ), strings.concat( T.from_str(", "), strings.concat( asker.ask_firmly(render(fields.get(pairs.first(), x))), T.from_str(")") ) ) ))
def post(self): user = self.current_user semester = str(self.request.get('listSelectSemester')) year = int(self.request.get('listSelectYear')) term = Term.query(ancestor = user.key).filter(ndb.AND(Term.semester == semester, Term.year == year)).get() if not term: term = Term(parent = user.key, semester = semester, year = year) term.put() self.session['term'] = term.key.urlsafe() self.redirect('/list')
def zip(asker, req, a, b): if (properties.check_firmly(asker, is_empty(), a) or properties.check_firmly(asker, is_empty(), b)): return asker.reply(answer=empty()) zipped_first = T.pair(fields.get(asker, first(), a), fields.get(asker, first(), b)) zipped_tail = zip(fields.get(asker, tail(), a), fields.get(asker, tail(), b)) return asker.ask_tail(convert.convert(cons(zipped_first, zipped_tail), req))
def node_from_term(asker, quoted_term): head = asker.ask(fields.get_field(representations.head(), quoted_term)).firm_answer bindings = asker.ask(fields.get_field(representations.bindings(), quoted_term)).firm_answer return asker.reply(answer=properties.simple_add_modifier( node(head, T.empty_list()), children_on_expanded(bindings) ))
def add_children_on_expanded(asker, old, new, bindings): children = [] for p in lists.iterator(asker, lists.from_dict(bindings)): k = asker.ask(fields.get_field(first(), p)).firm_answer v = asker.ask(fields.get_field(second(), p)).firm_answer prefix = strings.string_concat(k, T.from_str(": ")) new_node = node_from_term(asker, v) new_node = updates.update( updates.apply_to(headline(), strings.prepend_str(prefix)), new_node ) children.append(new_node) return asker.reply(answer=updates.update( fields.set_field(all_children(), T.from_list(children)), new ))
def __call__(self, screen): """Z(screen) -> None""" # init the interface self.area = area.Area(self) self.term = Term(self, screen) (y, x) = self.term.viewsize() # wtf? why can't curses self.area.resize(y, x - 1) # draw on the screen edge? self.hero = Hero(self.area, 1, 1, None) self.actors = [self.hero] self.actors.extend(self.area.generate(0)) self.area.enter(self.hero.y, self.hero.x, self.hero) self.term.redraw() # start the game running = True while running: actor = self.actors[0] while running and actor.wait_until <= self.time: actor.act() if self.game_over == "quit": self.term.msg("Goodbye, thanks for playing!") self.term.waitforkey() running = False elif self.game_over == "escaped": self.term.msg("You escaped with %d gold!" % self.hero.gold) self.term.waitforkey() running = False elif self.game_over == "killed": self.term.msg("You died.") self.term.waitforkey() running = False self.time += 1 self.queue_actor(actor)
def __call__(self,screen): """Z(screen) -> None""" # init the interface self.area = area.Area(self) self.term = Term(self,screen) (y, x) = self.term.viewsize() # wtf? why can't curses self.area.resize(y, x-1) # draw on the screen edge? self.hero = Hero(self.area,1,1,None) self.actors = [self.hero] self.actors.extend(self.area.generate(0)) self.area.enter(self.hero.y, self.hero.x, self.hero) self.term.redraw() # start the game running = True while running: actor = self.actors[0] try: while actor.wait_until <= self.time: actor.act() except QuitGame: self.term.msg('Goodbye, thanks for playing!') self.term.waitforkey() running = False except Escaped: self.term.msg('You escaped with %d gold!' % self.hero.gold) self.term.waitforkey() running = False except WasKilled: self.term.msg('You died.') self.term.waitforkey() running = False finally: self.time += 1 self.queue_actor(actor)
def orthogonal(asker, field1, field2): if booleans.ask_firmly(asker, builtins.equal(field1, field2)): return asker.reply(answer=T.no()) result = orthogonality_tester.dispatch(asker, field1, field2) if result is not None: return result result = orthogonality_tester.dispatch(asker, field2, field1) if result is not None: return result
def update_view(asker, view, input): relayer = asker.pass_through(should_return.head) #FIXME using the name view_in is a hack to keep view from being locally scoped... @relayer(should_print.head) def print_string(s): view_in = asker.refresh(view) asker.update(add_line(input), view_in) #FIXME more things going wrong with representation levels... s = convert.unquote(asker, s) line = asker.ask_firmly(render(s)) asker.update(add_line(line), view_in) return properties.trivial() @relayer(should_dispatch.head) def dispatch(x): view_in = asker.refresh(view) asker.update(add_line(input), view_in) head = fields.get(asker, representations.head(), x) bindings = fields.get(asker, representations.bindings(), x) view_in = asker.refresh(view_in) asker.update(add_line(head), view_in) for p in dictionaries.item_iterator(asker, bindings): var, val = pairs.to_pair(asker, p) view_in = asker.refresh(view_in) asker.update(bind_variable(var, val), view_in) return properties.trivial() @relayer(should_assign.head) def assign(s, x): view_in = asker.refresh(view) asker.update(add_line(input), view_in) view_in = asker.refresh(view_in) asker.update(bind_variable(s, x), view_in) return properties.trivial() interpret_response = asker.ask(interpret_input(view, input), handler=relayer) if interpret_response.has_answer(): bindings = dictionaries.to_dict(asker, fields.get(asker, bindings_field(), view)) bindings_str = {strings.to_str(asker, k):v for k, v in bindings.items()} for char in "xyzw" + string.letters: if char not in bindings_str: break asker.update(bind_variable(T.from_str(char), interpret_response.answer), view) new_line = strings.concat( T.from_str("{} = ".format(char)), input ) asker.update(add_line(new_line), view) return asker.reply()
def visible_children(asker, object): expanded = convert.check_hard(asker, is_expanded(), object) object = asker.refresh(object) if not expanded: return asker.reply(answer=T.from_list([])) else: children = asker.ask(fields.get_field(all_children(), object)).firm_answer return asker.reply(answer=children)
def complex_dict(base=None, **kwargs): if base is None: base = {} to_make = dict(base, **kwargs) result = quote(T.empty_dict()) for name, value in to_make.items(): result = dict_cons(quote_str(name), value, result) return result
def __repr__(self): if self.statements == []: return "{}" if len(self.statements) == 1: st = self.statements[0] return "{"+`st[SUBJ]`+" "+`st[PRED]`+" "+`st[OBJ]`+"}" s = Term.__repr__(self) return "{%i}" % len(self.statements)
def __init__(self, *args, **kwargs): super(ContextUpdater, self).__init__(*args, **kwargs) self.internal = {} self.changed = {} self.original = {} self.current = {} self.updates = {} self.source = {} if self.Q is not None: self.question_bindings = self.Q.question.bindings for k, v in self.question_bindings.iteritems(): self.tag(in_question(T.from_str(k)), v)
def explore_node(asker, root, parents): asker.update(is_pointer_now(), root) while True: #TODO print the parents root = asker.refresh(root) lines = asker.ask(outline_to_lines(root)).firm_answer utilities.clear() asker.ask(print_lines_simple(lines)) c = utilities.getch() if c == 'q': return asker.reply() else: root = asker.refresh(root) asker.ask(process_char(root, T.from_char(c), parents))
def outline_to_lines(asker, root): debug() result = asker.ask(fields.get_field(cached_lines(), root)).answer if result is not None: return asker.reply(answer=result) base_headline = asker.ask(fields.get_field(headline(), root)).firm_answer root = asker.refresh(root) prefix = "* " if convert.check_hard(asker, is_pointer(), root) else " " full_headline = strings.string_concat(T.from_str(prefix), base_headline) root = asker.refresh(root) children = asker.ask(fields.get_field(visible_children(), root)).firm_answer body = empty_lines() for child in lists.iterator(asker, children): section = asker.ask(outline_to_lines(child)).firm_answer body = concat_lines(body, section) result = concat_lines(one_line(full_headline), indent_lines(body)) asker.update(updates.set_field(cached_lines(), result), root) return asker.reply(answer=result)
def propagate_back(s): if s.head == term.because.head: return propagate_back(s['operation']) elif s.head == term.explain.head: return propagate_back(s['operation']) or propagate_back(s['prior']) elif s.head == term.accessing.head: if change.head == updates.trivial.head: parent = s['term'] binding = s['binding'] return self.update( updates.trivial(), parent, repr_change=updates.apply_to_field( representations.referent_of(T.from_str(binding)), repr_change ).explain("tracing backwards from [v]", v=v) ) else: return False elif s.head == askers.answering.head: Q = s['Q'] if Q.head == fields.get_field.head: parent = Q['object'] field = Q['field'] return self.update( updates.apply_to_field(field, change), parent, repr_change=updates.apply_to_field(updates.lift_field(field), repr_change) ) elif Q.head == convert.convert.head: previous = Q['value'] return self.update( change, previous, repr_change=None ) return False
def find_hearst_concepts(self, triples): s_concepts = [] m_concepts = [] for (t1, rel, t2) in triples: term1 = Term(preprocessor.pos_tag(t1, True)) term2 = Term(preprocessor.pos_tag(t2, True)) synsets1 = wn.synsets(term1.get_head()[0], self.pos_tag(term1.get_head()[1])) synsets2 = wn.synsets(term2.get_head()[0], self.pos_tag(term2.get_head()[1])) if not synsets1: raise Exception("'{}' not found in WordNet".format(term1.get_head()[0])) if not synsets2: raise Exception("'{}' not found in WordNet".format(term2.get_head()[0])) (best1, best2) = self.comp(synsets1, synsets2) con1 = self.get_concept( concept.Concept(synset=best1, term=term1.get_head()[0]) ) con2 = self.get_concept( concept.Concept(synset=best2, term=term2.get_head()[0]) ) conChild1 = None conChild2 = None if len(term1.get_terms()) > 1: conChild1 = self.get_concept( concept.Concept(name=term1.get_terms(), term=term1.get_head()[0]) ) con1.add_hyponym(conChild1) conChild1.add_hypernym(con1) #m_concepts.append(conChild1) if len(term2.get_terms()) > 1: conChild2 = self.get_concept( concept.Concept(name=term2.get_terms(), term=term2.get_head()[0]) ) con2.add_hyponym(conChild2) conChild2.add_hypernym(con2) #m_concepts.append(conChild2) if conChild1: if conChild2: conChild1.add_relation(conChild2, rel) else: conChild1.add_relation(con2, rel) m_concepts.append(conChild1) else: if conChild2: con1.add_relation(conChild2, rel) m_concepts.append(conChild2) else: con1.add_relation(con2, rel) s_concepts.append(con1) s_concepts.append(con2) self.single_concepts = self.single_concepts.union(set(s_concepts)) self.multi_concepts = self.multi_concepts.union(set(m_concepts))
def deny(self): return self.reply(answer=T.from_bool(False))
class Zedventure(object): __slots__ = ("time", "area", "hero", "actors", "term", "rng", "game_over") def __init__(self, args): # init the game self.time = 0 self.area = None self.term = None self.hero = None self.game_over = None self.actors = [] self.rng = random.Random() def __call__(self, screen): """Z(screen) -> None""" # init the interface self.area = area.Area(self) self.term = Term(self, screen) (y, x) = self.term.viewsize() # wtf? why can't curses self.area.resize(y, x - 1) # draw on the screen edge? self.hero = Hero(self.area, 1, 1, None) self.actors = [self.hero] self.actors.extend(self.area.generate(0)) self.area.enter(self.hero.y, self.hero.x, self.hero) self.term.redraw() # start the game running = True while running: actor = self.actors[0] while running and actor.wait_until <= self.time: actor.act() if self.game_over == "quit": self.term.msg("Goodbye, thanks for playing!") self.term.waitforkey() running = False elif self.game_over == "escaped": self.term.msg("You escaped with %d gold!" % self.hero.gold) self.term.waitforkey() running = False elif self.game_over == "killed": self.term.msg("You died.") self.term.waitforkey() running = False self.time += 1 self.queue_actor(actor) def new_level(self, increment): self.actors = self.area.generate(increment) self.actors.insert(0, self.hero) self.area.occ[self.hero.y, self.hero.x] = self.hero def prev_level(self): if self.area.depth < 1: self.game_over = "escaped" else: self.new_level(-1) def next_level(self): self.new_level(1) def queue_actor(self, actor): done = False for i, a in enumerate(self.actors): if a > actor: self.actors.remove(actor) self.actors.insert(i, actor) done = True break if not done: self.actors.remove(actor) self.actors.append(actor) def coinflip(self): return bool(self.rng.randint(0, 1)) def chance_in(self, odds): return self.rng.randint(1, odds) == 1 def percent_chance(self, pct): return self.rng.randint(1, 100) <= pct
def let(var, val, f): return apply(quote(f), literal_term(T.from_dict({var:val})))
def dict_cons(asker, computation_bindings, key, value, other): return asker.reply(answer=T.dict_cons(key, value, other))
class Zedventure (object): __slots__ = ('time','area','hero','actors','term','rng') def __init__(self,args): # init the game self.time = 0 self.area = None self.term = None self.hero = None self.actors = [] self.rng = random.Random() def __call__(self,screen): """Z(screen) -> None""" # init the interface self.area = area.Area(self) self.term = Term(self,screen) (y, x) = self.term.viewsize() # wtf? why can't curses self.area.resize(y, x-1) # draw on the screen edge? self.hero = Hero(self.area,1,1,None) self.actors = [self.hero] self.actors.extend(self.area.generate(0)) self.area.enter(self.hero.y, self.hero.x, self.hero) self.term.redraw() # start the game running = True while running: actor = self.actors[0] try: while actor.wait_until <= self.time: actor.act() except QuitGame: self.term.msg('Goodbye, thanks for playing!') self.term.waitforkey() running = False except Escaped: self.term.msg('You escaped with %d gold!' % self.hero.gold) self.term.waitforkey() running = False except WasKilled: self.term.msg('You died.') self.term.waitforkey() running = False finally: self.time += 1 self.queue_actor(actor) def new_level(self,increment): self.actors = self.area.generate(increment) self.actors.insert(0,self.hero) self.area.occ[self.hero.y,self.hero.x] = self.hero def prev_level(self): self.new_level(-1) def next_level(self): self.new_level(1) def queue_actor(self,actor): done = False for i,a in enumerate(self.actors): if a > actor: self.actors.remove(actor) self.actors.insert(i, actor) done = True break if not done: self.actors.remove(actor) self.actors.append(actor) def coinflip(self): return bool(self.rng.randint(0,1)) def chance_in(self,odds): return self.rng.randint(1,odds) == 1 def percent_chance(self,pct): return self.rng.randint(1,100) <= pct
def quote_str(s): return quote(T.from_str(s))
def starting_state(): return state(T.from_dict({}), handlers.view_handler())