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 both_stripper(asker, update, object, a, b):
keeps = properties.trivial()
strips = properties.trivial()
for x in [a, b]:
keep_or_strip = asker.ask(modifiers_to_strip(update, x, object)).value
new_keeps = fields.get(asker, fields.implication_about(to_keep()), keep_or_strip)
keeps = properties.both(keeps, new_keeps)
new_strips = fields.get(asker, fields.implication_about(to_strip()), keep_or_strip)
strips = properties.both(strips, new_strips)
return asker.reply(value=keep_strip(keep=keeps, strip=strips))
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()
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 print_view(asker, view):
clear()
lines = fields.get(asker, lines_field(), view)
for line in lists.iterator(asker, lines):
s = strings.to_str(asker, line)
print(s)
return asker.reply()
def to_str(asker, s):
if s.to_str() is not None:
return s.to_str()
result = literalizer.dispatch(asker, s)
if result is not None:
return result
else:
chars = fields.get(asker, list_of_chars(), s)
return ''.join(to_char(c) for c in lists.iterator(asker, chars))
def apply_update(asker, update, object):
fast_result = fast_updater.dispatch(asker, update, object)
if fast_result is not None:
return fast_result
exposed_object = asker.ask(convert.convert(object, convert.exposed_modifier())).firm_answer
old_modifier = exposed_object.modifier
#FIXME these forms seems more correct but are way too slow...
#if properties.check_firmly(asker, properties.is_trivial(), old_modifier):
#if booleans.ask_firmly(asker, builtins.equal(properties.trivial(), old_modifier)):
if properties.trivial.head == old_modifier.head:
return asker.ask_tail(apply_update_raw(update, exposed_object))
keep_or_strip = asker.ask(modifiers_to_strip(update, old_modifier, exposed_object)).value
kept_modifier = fields.get(asker, fields.implication_about(to_keep()), keep_or_strip)
stripped_modifier = fields.get(asker, fields.implication_about(to_strip()), keep_or_strip)
stripped_object = exposed_object.simple_update(_modifier=kept_modifier)
stripped_result = asker.ask(apply_update_raw(update, stripped_object)).firm_answer
return asker.ask_tail(reintroduce_modifier(
stripped_modifier,
update,
stripped_object,
stripped_result
))
def predict_input(asker, view):
lines = fields.get(asker, lines_field(), view)
h = asker.ask(state.get_history()).firm_answer
response = asker.ask(fields.get_field(dictionaries.image(lines), h))
if response.has_answer():
return asker.reply(answer=response.answer)
else:
input = asker.ask_firmly(elicit(view))
asker.ask(state.update_state(updates.apply_to_field(
state.history(),
updates.set_field(
dictionaries.image(lines),
input
)
)))
return asker.reply(answer=input)
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 get_lookups(self):
""" Returns lookups valid for the field type defined by the aspect """
fields = {'AutoField': None,
'BigIntegerField': None,
'BooleanField': None,
'CharField': 'textual',
'CommaSeparatedIntegerField': None,
'DateField': 'continous',
'DateTimeField': 'continous',
'DecimalField': None,
'EmailField': None,
'FileField': None,
'FileField': None,
'FieldFile': None,
'FilePathField': None,
'FloatField': None,
'ImageField': None,
'IntegerField': 'continous',
'IPAddressField': None,
'GenericIPAddressField': None,
'NullBooleanField': None,
'PositiveIntegerField': None,
'PositiveSmallIntegerField': None,
'SlugField': None,
'SmallIntegerField': None,
'TextField': None,
'TimeField': None,
'URLField': None,
'ForeignKey': 'relation',
'ManyToManyField': None,
'OneToOneField': None}
lookups = {'textual': (('exact', 'Exact'), ('iexact', 'Case-insensitive exact'), ('contains', 'Contains'), ('icontains', 'Case-insensitive contains'),
('startswith', 'Starts with'), ('istartswith', 'Case-insensitive starts with'), ('endswith', 'Ends with'),
('iendswith', 'Case-insensitve ends with')),
'continous': (('exact', 'Exact'), ('gt', 'Greater then'), ('gte', 'Greater then or exact'), ('lt', 'Lower then'), ('lte', 'Lower then or exact')),
'relation': (('exact', 'Exact'),),
}
internal_type = fields.get(self.get_field().get_internal_type())
return lookups.get(internal_type, (('exact', 'Exact'),))
def get_lookups(self):
""" Returns lookups valid for the field type defined by the aspect """
fields = {'AutoField': None,
'BigIntegerField': None,
'BooleanField': None,
'CharField': 'textual',
'CommaSeparatedIntegerField': None,
'DateField': 'continous',
'DateTimeField': 'continous',
'DecimalField': None,
'EmailField': None,
'FileField': None,
'FileField': None,
'FieldFile': None,
'FilePathField': None,
'FloatField': None,
'ImageField': None,
'IntegerField': 'continous',
'IPAddressField': None,
'GenericIPAddressField': None,
'NullBooleanField': None,
'PositiveIntegerField': None,
'PositiveSmallIntegerField': None,
'SlugField': None,
'SmallIntegerField': None,
'TextField': None,
'TimeField': None,
'URLField': None,
'ForeignKey': 'relation',
'ManyToManyField': None,
'OneToOneField': None}
lookups = {'textual': (('exact', 'Exact'), ('iexact', 'Case-insensitive exact'), ('contains', 'Contains'), ('icontains', 'Case-insensitive contains'),
('startswith', 'Starts with'), ('istartswith', 'Case-insensitive starts with'), ('endswith', 'Ends with'),
('iendswith', 'Case-insensitve ends with')),
'continous': (('exact', 'Exact'), ('gt', 'Greater then'), ('gte', 'Greater then or exact'), ('lt', 'Lower then'), ('lte', 'Lower then or exact')),
'relation': (('exact', 'Exact'),),
}
internal_type = fields.get(self.get_field().get_internal_type())
return lookups.get(internal_type, (('exact', 'Exact'),))
def interpret_raw(asker, view, text, bindings):
#FIXME I think that most field lookups should be done implicitly
variable_bindings = fields.get(asker, bindings_field(), view)
lookup_value = asker.ask(fields.get_field(
dictionaries.image(text),
variable_bindings
))
if lookup_value.has_answer():
return asker.reply(answer=lookup_value.answer)
update_bindings = dictionaries.map(
computations.apply_to_single(
computations.askQ_literal(interpret_expression(
computations.quote(view),
computations.getvar(computations.quote(computations.x_var))
)),
computations.x_var
)
)
return asker.reply(answer=representations.quoted_term(
text,
functions.apply(update_bindings, bindings)
))
#FIXME should have other answers soon, not everything should be held...
return elicit_meaning(text, view, functions.apply(update_bindings, bindings))
def easy_check(asker, object):
#FIXME seems pretty awkward
import fields
m = fields.get(asker, fields.modifier(), object)
return asker.reply(answer=custom_checker.dispatch(asker, m))
def apply_to_field(asker, object, field, update):
value = fields.get(asker, field=field, object=object)
#FIXME this update should sometimes be held
#but for now, I have no way to make good tradeoffs about the costs of doing that
new_value = asker.ask_firmly(apply_update(update, value))
return asker.ask_tail(apply_update(set_field(field, new_value), object))
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 itemize_cons(asker, head, tail):
a = fields.get(asker, pairs.first(), head)
b = fields.get(asker, pairs.second(), head)
return asker.reply(answer=cons(a, b, from_items(tail)))
def to_pair(asker, p):
return (fields.get(asker, first(), p), fields.get(asker, second(), p))
def expose_modifier(asker, object):
rep = representations.quote(object)
head = strings.to_str(asker, fields.get(asker, representations.head(), rep))
if head not in hidden_modifier_heads:
new_modifier = convert.reduce(asker, object.modifier)
return asker.reply(answer=object.simple_update(_modifier=new_modifier))
