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