def interpret_ref_obj_filter(interpreter, speaker, filters_d): F = MemoryFilter(interpreter.agent.memory) # currently spec intersects all comparators TODO? comparator_specs = filters_d.get("comparator") if comparator_specs: for s in comparator_specs: F.append( interpret_comparator(interpreter, speaker, s, is_condition=False)) # FIXME!!! AUTHOR # FIXME!!! has_x=FILTERS # currently spec intersects all has_x, TODO? # FIXME!!! tags_from_dict is crude, use tags/relations appropriately # triples = [] tags = tags_from_dict(filters_d) triples = [{"pred_text": "has_tag", "obj_text": tag} for tag in tags] # for k, v in filters_d.items(): # if type(k) is str and "has" in k: # if type(v) is str: # triples.append({"pred_text": k, "obj_text": v}) # Warning: BasicFilters will filter out agent's self # FIXME !! finer control over this ^ if triples: F.append(BasicFilter(interpreter.agent.memory, {"triples": triples})) return F
def interpret_task_filter(interpreter, speaker, filters_d, get_all=False): F = MemoryFilter(interpreter.agent.memory) task_tags = ["currently_running", "running", "paused", "finished"] T = filters_d.get("triples") task_properties = [ a.get("obj_text").lower() for a in T if a.get("obj_text", "").lower() in task_tags ] search_data = {} search_data["base_table"] = "Tasks" search_data["base_exact"] = {} if "currently_running" in task_properties: search_data["base_exact"]["running"] = 1 if "paused" in task_properties: search_data["base_exact"]["paused"] = 1 else: search_data["base_exact"]["paused"] = 0 search_data["base_range"] = {} if "finished" in task_properties: search_data["base_range"]["minfinished"] = 0 F.append(BasicFilter(interpreter.agent.memory, search_data)) # currently spec intersects all comparators TODO? comparator_specs = filters_d.get("comparator") if comparator_specs: for s in comparator_specs: F.append( interpret_comparator(interpreter, speaker, s, is_condition=False)) return F
def interpret_time(self, interpreter, speaker, d): event = None if d.get("special_time_event"): return TimeCondition(interpreter.agent, d["special_time_event"]) else: if not d.get("comparator"): raise ErrorWithResponse( "I don't know how to interpret this time condition") dc = d["comparator"] dc["input_left"] = {"value_extractor": "NULL"} comparator = interpret_comparator(interpreter, speaker, dc) if d.get("event"): event = self(interpreter, speaker, d["event"]) return TimeCondition(interpreter.agent, comparator, event=event)
def interpret_dance_filter(interpreter, speaker, filters_d, get_all=False): F = MemoryFilter(interpreter.agent.memory) search_data = {} triples = [] for t in filters_d.get("triples"): triples.append(t) search_data["base_table"] = "Dances" search_data["triples"] = triples F.append(BasicFilter(interpreter.agent.memory, search_data)) # currently spec intersects all comparators TODO? comparator_specs = filters_d.get("comparator") if comparator_specs: for s in comparator_specs: F.append( interpret_comparator(interpreter, speaker, s, is_condition=False)) return F
def __call__(self, interpreter, speaker, filters_d, get_all=False): """ This is a subinterpreter to handle FILTERS dictionaries Args: interpreter: root interpreter. speaker (str): The name of the player/human/agent who uttered the chat resulting in this interpreter filters_d: FILTERS logical form from semantic parser get_all (bool): if True, output attributes are set with get_all=True Outputs a (chain) of MemoryFilter objects """ agent_memory = interpreter.agent.memory self.get_attribute = interpreter.subinterpret.get( "attribute", AttributeInterpreter()) output = filters_d.get("output") val_map = None if output and type(output) is dict: attr_d = output.get("attribute") a = self.get_attribute(interpreter, speaker, attr_d, get_all=get_all) val_map = ApplyAttribute(agent_memory, a) elif output and output == "count": val_map = CountTransform(agent_memory) # NB (kavyasrinet) output can be string and have value "memory" too here # is this a specific memory? # ... then return mem, _ = maybe_specific_mem(interpreter, speaker, {"filters": filters_d}) if mem: if val_map: val_map.append(FixedMemFilter(agent_memory, mem.memid)) return val_map else: return FixedMemFilter(agent_memory, mem.memid) F = MemoryFilter(agent_memory) # currently spec intersects all comparators TODO? comparator_specs = filters_d.get("comparator") if comparator_specs: for s in comparator_specs: F.append( interpret_comparator(interpreter, speaker, s, is_condition=False)) # FIXME!!! AUTHOR # FIXME!!! has_x=FILTERS # currently spec intersects all has_x, TODO? # FIXME!!! tags_from_dict is crude, use tags/relations appropriately # triples = [] tags = tags_from_dict(filters_d) triples = [{"pred_text": "has_tag", "obj_text": tag} for tag in tags] # for k, v in filters_d.items(): # if type(k) is str and "has" in k: # if type(v) is str: # triples.append({"pred_text": k, "obj_text": v}) # Warning: BasicFilters will filter out agent's self # FIXME !! finer control over this ^ if triples: F.append(BasicFilter(agent_memory, {"triples": triples})) selector = None location_d = filters_d.get("location") if location_d: selector = build_linear_extent_selector(interpreter, speaker, location_d) else: argval_d = filters_d.get("argval") if argval_d: polarity = "arg" + argval_d.get("polarity").lower() attribute_d = argval_d.get("quantity").get("attribute") selector_attribute = self.get_attribute( interpreter, speaker, attribute_d) # FIXME ordinal = { "first": 1, "second": 2, "third": 3 }.get(argval_d.get("ordinal", "first").lower(), 1) sa = ApplyAttribute(agent_memory, selector_attribute) selector = ExtremeValueMemorySelector(agent_memory, polarity=polarity, ordinal=ordinal) selector.append(sa) if val_map: if selector: selector.append(F) val_map.append(selector) else: val_map.append(F) return val_map else: if selector: selector.append(F) return selector return F