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