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 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 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 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 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 __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 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 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 print_lines_simple(asker, lines):
return asker.ask_tail(print_lines(lines, T.from_int(0), T.from_str(" ")))
def render_dict(asker, x):
return asker.reply(answer=strings.concat(
T.from_str("D"),
lists.from_dict(x)
))
def make_str_expr(s):
return T(make_str_expr.head, s=T.from_str(s[0]))
def render_int(asker, x):
return asker.reply(answer=T.from_str(str(ints.to_int(asker, x))))
def get_starting_view(asker, query):
head = fields.get(asker, representations.head(), query)
bindings = fields.get(asker, representations.bindings(), query)
initial_lines = T.from_list([head, T.from_str("---")])
return asker.reply(answer=view(initial_lines, bindings))
def prompt(asker):
return asker.reply(answer=T.from_str(raw_input("")))
def quote_str(s):
return quote(T.from_str(s))
def make_assignment(ins):
return T(make_assignment.head, name=T.from_str(ins[0]), value=ins[1])
