def create(self, otherchunk, actrvariables=None): """ Create (aka set) a chunk for manual control. The chunk is returned (and could be used by device or external environment). """ if actrvariables == None: actrvariables = {} try: mod_attr_val = { x[0]: utilities.check_bound_vars(actrvariables, x[1]) for x in otherchunk.removeunused() } #creates dict of attr-val pairs according to otherchunk except ACTRError as arg: raise ACTRError( "Setting the chunk '%s' in the manual buffer is impossible; %s" % (otherchunk, arg)) new_chunk = chunks.Chunk(self._MANUAL, **mod_attr_val) #creates new chunk if new_chunk.cmd.values not in utilities.CMDMANUAL: raise ACTRError( "Motor module received an invalid command: '%s'. The valid commands are: '%s'" % (new_chunk.cmd.values, utilities.CMDMANUAL)) if new_chunk.cmd.values == utilities.CMDPRESSKEY: pressed_key = new_chunk.key.values.upper( ) #change key into upper case mod_attr_val["key"] = pressed_key new_chunk = chunks.Chunk(self._MANUAL, **mod_attr_val) #creates new chunk if pressed_key not in self.LEFT_HAND and new_chunk.key.values not in self.RIGHT_HAND: raise ACTRError("Motor module received an invalid key: %s" % pressed_key) return new_chunk
def __getitem__(self, key): for x in key.removeunused(): temp_chunk = chunks.Chunk(typename=getattr(key, "typename"), **{x[0]: x[1]}) try: return self._data[temp_chunk][key] except KeyError: return self._data[key] return self._data[chunks.Chunk(typename=getattr(key, "typename"))]
def __delitem__(self, key): for x in key: temp_chunk = chunks.Chunk(typename=getattr(key, "typename"), **{x[0]: x[1]}) try: del self._data[temp_chunk][key] except KeyError: del self._data[key] if len(key) == 0: del self._data[chunks.Chunk(typename=getattr(key, "typename"))]
def __contains__(self, elem): if not isinstance(elem, chunks.Chunk): return False for x in elem: temp_chunk = chunks.Chunk(typename=getattr(elem, "typename"), **{x[0]: x[1]}) #elem is in structued _data return temp_chunk in self._data and elem in self._data[temp_chunk] #if we got here, it's because loop above did not proceed, so elem has no slot-values; then we check the empty chunk return chunks.Chunk(typename=getattr(elem, "typename")) in self._data
def automatic_buffering(self, stim): """ Buffer visual object automatically. """ temp_dict = {key: stim[key] for key in stim if key != 'position' and key != 'text' and key != 'vis_delay'} temp_dict.update({'screen_pos': chunks.Chunk(utilities.VISUALLOCATION, **{'screen_x': stim['position'][0], 'screen_y': stim['position'][1]}), 'value': stim['text']}) new_chunk = chunks.Chunk(utilities.VISUAL, **temp_dict) if new_chunk: angle_distance = 2*utilities.calculate_visual_angle(self.current_focus, (stim['position'][0], stim['position'][1]), self.environment.size, self.environment.simulated_screen_size, self.environment.viewing_distance) #the stimulus has to be within 2 degrees from the focus (foveal region) encoding_time = utilities.calculate_delay_visual_attention(angle_distance=angle_distance, K=self.model_parameters["eye_mvt_scaling_parameter"], k=self.model_parameters['eye_mvt_angle_parameter'], emma_noise=self.model_parameters['emma_noise'], vis_delay=stim.get('vis_delay')) return new_chunk, encoding_time
def __setitem__(self, key, time): if self.unrestricted_number_chunks and key not in self: for x in key: if utilities.splitting(x[1]).values and utilities.splitting(x[1]).values in self.unrestricted_number_chunks: self.unrestricted_number_chunks.update([utilities.splitting(x[1]).values]) if self.restricted_number_chunks and key not in self: for x in key: if utilities.splitting(x[1]).values and (x[0], utilities.splitting(x[1]).values) in self.restricted_number_chunks: self.restricted_number_chunks.update([(x[0], utilities.splitting(x[1]).values)]) if isinstance(key, chunks.Chunk): if len(key) == 0: if isinstance(time, np.ndarray): #time is an array self._data.update({key: time}) else: try: #time is a number self._data.update({key: np.array([round(float(time), 4)])}) except TypeError: #time is a sequence self._data.update({key: np.array(time)}) for x in key.removeunused(): temp_chunk = chunks.Chunk(typename=getattr(key, "typename"), **{x[0]: x[1]}) if isinstance(time, np.ndarray): #time is an array self._data.setdefault(temp_chunk, {}).update({key: time}) else: try: #time is a number self._data.setdefault(temp_chunk, {}).update({key: np.array([round(float(time), 4)])}) except TypeError: #time is a sequence self._data.setdefault(temp_chunk, {}).update({key: np.array(time)}) else: raise utilities.ACTRError("Only chunks can be added as attributes to Declarative Memory; '%s' is not a chunk" % key)
def automatic_search(self, stim): """ Automatically search for a new stim in environment. """ new_chunk = None found = None closest = float("inf") for st in stim: if st not in self.recent: position = st['position'] #check on closest try: if utilities.calculate_pythagorian_distance( self.environment.current_focus, position) > closest: continue except TypeError: pass temp_dict = { key: st[key] for key in st if key != 'position' and key != 'text' and key != 'vis_delay' } temp_dict.update({ 'screen_x': st['position'][0], 'screen_y': st['position'][1] }) closest = utilities.calculate_pythagorian_distance( self.environment.current_focus, position) new_chunk = chunks.Chunk(utilities.VISUALLOCATION, **temp_dict) found = st return new_chunk, found
def modify(self, otherchunk, actrvariables=None): """ Modify the chunk in Buffer according to the info in otherchunk. """ if actrvariables == None: actrvariables = {} elem = self._data.pop() try: mod_attr_val = {x[0]: utilities.check_bound_vars(actrvariables, x[1]) for x in otherchunk.removeunused()} #creates dict of attr-val pairs according to otherchunk except utilities.ACTRError as arg: raise utilities.ACTRError("The chunk '%s' is not defined correctly; %s" % (otherchunk, arg)) elem_attr_val = {x[0]: x[1] for x in elem} elem_attr_val.update(mod_attr_val) #updates original chunk with attr-val from otherchunk mod_chunk = chunks.Chunk(otherchunk.typename, **elem_attr_val) #creates new chunk self._data.add(mod_chunk) #put chunk directly into buffer
def create(self, otherchunk, harvest=None, actrvariables=None): """ Create (aka set) a chunk in goal buffer. """ try: mod_attr_val = { x[0]: utilities.check_bound_vars(actrvariables, x[1]) for x in otherchunk.removeunused() } #creates dict of attr-val pairs according to otherchunk except utilities.ACTRError as arg: raise utilities.ACTRError( "Setting the buffer using the chunk '%s' is impossible; %s" % (otherchunk, arg)) new_chunk = chunks.Chunk(otherchunk.typename, **mod_attr_val) #creates new chunk self.add(new_chunk, 0, harvest) #put chunk using add
def func(): production = rule['rule']() for pro in production: for key in pro: code = key[0] buff = key[1:] renaming_set = set(utilities._LHSCONVENTIONS.keys()) renaming_set.update(utilities._RHSCONVENTIONS.keys()) renaming_set.difference_update({utilities._RHSCONVENTIONS_REVERSED["execute"], utilities._RHSCONVENTIONS_REVERSED["clear"], utilities._RHSCONVENTIONS_REVERSED["extra_test"], utilities._LHSCONVENTIONS_REVERSED["query"]}) if code in renaming_set: mod_attr_val = {} for elem in pro[key]: varval = utilities.make_chunkparts_with_new_vars(elem[1], variable_dict, val_dict) mod_attr_val[elem[0]] = varval new_chunk = chunks.Chunk(pro[key].typename, **mod_attr_val) pro[key] = new_chunk yield pro
def shift(self, otherchunk, harvest=None, actrvariables=None): """ Return a chunk, time needed to attend and shift eye focus to the chunk, and the landing site of eye mvt. """ if actrvariables == None: actrvariables = {} try: mod_attr_val = {x[0]: utilities.check_bound_vars(actrvariables, x[1]) for x in otherchunk.removeunused()} #creates dict of attr-val pairs according to otherchunk except ACTRError as arg: raise ACTRError("The chunk '%s' is not defined correctly; %s" % (otherchunk, arg)) vis_delay = None for each in self.environment.stimulus: try: if self.environment.stimulus[each]['position'] == (float(mod_attr_val['screen_pos'].screen_x), float(mod_attr_val['screen_pos'].screen_y)): mod_attr_val['value'] = self.environment.stimulus[each]['text'] vis_delay = self.environment.stimulus[each].get('vis_delay') except (AttributeError, KeyError): raise ACTRError("The chunk in the visual buffer is not defined correctly. It is not possible to move attention.") new_chunk = chunks.Chunk(self._VISUAL, **mod_attr_val) #creates new chunk if new_chunk.cmd not in utilities.CMDVISUAL: raise ACTRError("Visual module received an invalid command: '%s'. The valid commands are: '%s'" % (new_chunk.cmd, utilities.CMDVISUAL)) if new_chunk.cmd == utilities.CMDMOVEATTENTION and self.model_parameters['emma']: angle_distance = utilities.calculate_visual_angle(self.current_focus, [float(new_chunk.screen_pos.screen_x), float(new_chunk.screen_pos.screen_y)], self.environment.size, self.environment.simulated_screen_size, self.environment.viewing_distance) encoding_time = utilities.calculate_delay_visual_attention(angle_distance=angle_distance, K=self.model_parameters["eye_mvt_scaling_parameter"], k=self.model_parameters['eye_mvt_angle_parameter'], emma_noise=self.model_parameters['emma_noise'], vis_delay=vis_delay) preparation_time = utilities.calculate_preparation_time(emma_noise=self.model_parameters['emma_noise']) execution_time = utilities.calculate_execution_time(angle_distance, emma_noise=self.model_parameters['emma_noise']) landing_site = utilities.calculate_landing_site([float(new_chunk.screen_pos.screen_x), float(new_chunk.screen_pos.screen_y)], angle_distance, emma_landing_site_noise=self.model_parameters['emma_landing_site_noise']) elif new_chunk.cmd == utilities.CMDMOVEATTENTION and not self.model_parameters['emma']: encoding_time = 0.085 preparation_time = 0 execution_time = 0.085 landing_site = (float(new_chunk.screen_pos.screen_x), float(new_chunk.screen_pos.screen_y)) else: raise ACTRError("Visual module received an invalid command: '%s'. The only valid command currently is: %s" % (new_chunk.cmd, utilities.CMDMOVEATTENTION)) return new_chunk, (encoding_time, preparation_time, execution_time), landing_site
def shift(self, otherchunk, harvest=None, actrvariables=None, model_parameters=None): """ Return a chunk, time needed to attend and shift eye focus to the chunk, and the landing site of eye mvt. """ if model_parameters == None: model_parameters = {} model_parameters = model_parameters.copy() model_parameters.update(self.model_parameters) if actrvariables == None: actrvariables = {} try: mod_attr_val = {x[0]: utilities.check_bound_vars(actrvariables, x[1]) for x in otherchunk.removeunused()} except ACTRError as arg: raise ACTRError("Shifting towards the chunk '%s' is impossible; %s" % (otherchunk, arg)) vis_delay = None for each in self.environment.stimulus: try: if self.environment.stimulus[each]['position'] == (float(mod_attr_val['screen_pos'].values.screen_x.values), float(mod_attr_val['screen_pos'].values.screen_y.values)): mod_attr_val['value'] = self.environment.stimulus[each]['text'] vis_delay = self.environment.stimulus[each].get('vis_delay') except (AttributeError, KeyError): raise ACTRError("The chunk in the visual buffer is not defined correctly. It is not possible to move attention.") new_chunk = chunks.Chunk(self._VISUAL, **mod_attr_val) #creates new chunk if model_parameters['emma']: angle_distance = utilities.calculate_visual_angle(self.environment.current_focus, [float(new_chunk.screen_pos.values.screen_x.values), float(new_chunk.screen_pos.values.screen_y.values)], self.environment.size, self.environment.simulated_screen_size, self.environment.viewing_distance) encoding_time = utilities.calculate_delay_visual_attention(angle_distance=angle_distance, K=model_parameters["eye_mvt_scaling_parameter"], k=model_parameters['eye_mvt_angle_parameter'], emma_noise=model_parameters['emma_noise'], vis_delay=vis_delay) preparation_time = utilities.calculate_preparation_time(emma_noise=model_parameters['emma_noise'], emma_preparation_time=model_parameters['emma_preparation_time']) execution_time = utilities.calculate_execution_time(angle_distance, emma_noise=model_parameters['emma_noise']) landing_site = utilities.calculate_landing_site([float(new_chunk.screen_pos.values.screen_x.values), float(new_chunk.screen_pos.values.screen_y.values)], angle_distance, emma_landing_site_noise=model_parameters['emma_landing_site_noise']) elif not model_parameters['emma']: encoding_time = 0.085 preparation_time = 0 execution_time = 0.085 landing_site = (float(new_chunk.screen_pos.values.screen_x.values), float(new_chunk.screen_pos.values.screen_y.values)) return new_chunk, (encoding_time, preparation_time, execution_time), landing_site
def retrieve(self, time, otherchunk, actrvariables, buffers, extra_tests, model_parameters): """ Retrieve a chunk from declarative memory that matches otherchunk. """ model_parameters = model_parameters.copy() model_parameters.update(self.model_parameters) if actrvariables == None: actrvariables = {} try: mod_attr_val = {x[0]: utilities.check_bound_vars(actrvariables, x[1], negative_impossible=False) for x in otherchunk.removeunused()} except utilities.ACTRError as arg: raise utilities.ACTRError("Retrieving the chunk '%s' is impossible; %s" % (otherchunk, arg)) chunk_tobe_matched = chunks.Chunk(otherchunk.typename, **mod_attr_val) max_A = float("-inf") #collect the subset of dm that is useful (only chunks that match the searched chunk will be used if len(chunk_tobe_matched.removeunused()) == 0 or ( model_parameters["subsymbolic"] and model_parameters["partial_matching"]): used_dm = self.dm else: used_dm = {} for x in chunk_tobe_matched.removeunused(): temp_chunk = chunks.Chunk(typename=getattr(chunk_tobe_matched, "typename"), **{x[0]: x[1]}) temp_data = {} for x in self.dm._data: if temp_chunk <= x: temp_data.update(self.dm._data[x]) #update used_dm with found chunks (either by creating it, if it is empty, or by intersecting with already present chunks) if not used_dm: used_dm = temp_data elif len(used_dm) <= len(temp_data): temp_data2 = {} for i in used_dm: if i in temp_data: temp_data2[i] = temp_data[i] used_dm = temp_data2 elif len(temp_data) < len(used_dm): temp_data2 = {} for i in temp_data: if i in used_dm: temp_data2[i] = used_dm[i] used_dm = temp_data2 retrieved = None #loop through this subset and check activation for chunk in used_dm: try: if extra_tests["recently_retrieved"] == False or extra_tests["recently_retrieved"] == 'False': if self.__finst and chunk in self.recent: continue else: if self.__finst and chunk not in self.recent: continue except KeyError: pass if model_parameters["subsymbolic"]: #if subsymbolic, check activation A_pm = 0 if model_parameters["partial_matching"]: A_pm = chunk_tobe_matched.match(chunk, partialmatching=True, mismatch_penalty=model_parameters["mismatch_penalty"]) else: if not chunk_tobe_matched <= chunk: continue try: A_bll = utilities.baselevel_learning(time, self.dm[chunk], model_parameters["baselevel_learning"], model_parameters["decay"], self.dm.activations.get(chunk), optimized_learning=model_parameters["optimized_learning"]) #bll except UnboundLocalError: continue if math.isnan(A_bll): raise utilities.ACTRError("The following chunk cannot receive base activation: %s. The reason is that one of its traces did not appear in a past moment." % chunk) try: A_sa = utilities.spreading_activation(chunk, buffers, self.dm, model_parameters["buffer_spreading_activation"], model_parameters["strength_of_association"], model_parameters["spreading_activation_restricted"], model_parameters["association_only_from_chunks"]) except IndexError: A_sa = float(0) inst_noise = utilities.calculate_instantaneous_noise(model_parameters["instantaneous_noise"]) A = A_bll + A_sa + A_pm + inst_noise #chunk.activation is the manually specified activation, potentially used by the modeller if utilities.retrieval_success(A, model_parameters["retrieval_threshold"]) and max_A < A: self.spreading_activation = A_sa max_A = A self.activation = max_A retrieved = chunk extra_time = utilities.retrieval_latency(A, model_parameters["latency_factor"], model_parameters["latency_exponent"]) if model_parameters["activation_trace"]: print("(Partially) matching chunk:", chunk) print("Base level learning:", A_bll) print("Spreading activation", A_sa) print("Partial matching", A_pm) print("Noise:", inst_noise) print("Total activation", A) print("Time to retrieve", extra_time) else: #otherwise, just standard time for rule firing, so no extra calculation needed if chunk_tobe_matched <= chunk and self.dm[chunk][0] != time: #the second condition ensures that the chunk that was created are not retrieved at the same time retrieved = chunk extra_time = model_parameters["rule_firing"] if not retrieved: self.activation, self.spreading_activation = None, None if model_parameters["subsymbolic"]: extra_time = utilities.retrieval_latency(model_parameters["retrieval_threshold"], model_parameters["latency_factor"], model_parameters["latency_exponent"]) else: extra_time = model_parameters["rule_firing"] if self.__finst: self.recent.append(retrieved) if self.__finst < len(self.recent): self.recent.popleft() return retrieved, extra_time
def retrieve(self, time, otherchunk, actrvariables, buffers, extra_tests, model_parameters): """ Retrieve a chunk from declarative memory that matches otherchunk. """ model_parameters = model_parameters.copy() model_parameters.update(self.model_parameters) if actrvariables == None: actrvariables = {} try: mod_attr_val = { x[0]: utilities.check_bound_vars(actrvariables, x[1]) for x in otherchunk.removeunused() } except utilities.ACTRError as arg: raise utilities.ACTRError( "The chunk '%s' is not defined correctly; %s" % (otherchunk, arg)) chunk_tobe_matched = chunks.Chunk(otherchunk.typename, **mod_attr_val) max_A = float("-inf") retrieved = None for chunk in self.dm: try: if extra_tests["recently_retrieved"] == False or extra_tests[ "recently_retrieved"] == 'False': if self.__finst and chunk in self.recent: continue else: if self.__finst and chunk not in self.recent: continue except KeyError: pass if model_parameters[ "subsymbolic"]: #if subsymbolic, check activation A_pm = 0 if model_parameters["partial_matching"]: A_pm = chunk_tobe_matched.match( chunk, partialmatching=True, mismatch_penalty=model_parameters["mismatch_penalty"]) else: if not chunk_tobe_matched <= chunk: continue if chunk in self.dm.activations: A_bll = utilities.baselevel_learning( time, self.dm[chunk], model_parameters["baselevel_learning"], model_parameters["decay"], self.dm.activations[chunk], optimized_learning=model_parameters[ "optimized_learning"]) #bll else: A_bll = utilities.baselevel_learning( time, self.dm[chunk], model_parameters["baselevel_learning"], model_parameters["decay"], optimized_learning=model_parameters[ "optimized_learning"]) #bll A_sa = utilities.spreading_activation( chunk, buffers, self.dm, model_parameters["buffer_spreading_activation"], model_parameters["strength_of_association"], model_parameters["spreading_activation_restricted"], model_parameters["association_only_from_chunks"]) inst_noise = utilities.calculate_instantanoues_noise( model_parameters["instantaneous_noise"]) A = A_bll + A_sa + A_pm + inst_noise #chunk.activation is the manually specified activation, potentially used by the modeller if utilities.retrieval_success( A, model_parameters["retrieval_threshold"]) and max_A < A: max_A = A self.activation = max_A retrieved = chunk extra_time = utilities.retrieval_latency( A, model_parameters["latency_factor"], model_parameters["latency_exponent"]) if model_parameters["activation_trace"]: print("(Partially) matching chunk:", chunk) print("Base level learning:", A_bll) print("Spreading activation", A_sa) print("Partial matching", A_pm) print("Noise:", inst_noise) print("Total activation", A) print("Time to retrieve", extra_time) else: #otherwise, just standard time for rule firing if chunk_tobe_matched <= chunk: retrieved = chunk extra_time = model_parameters["rule_firing"] if not retrieved: if model_parameters["subsymbolic"]: extra_time = utilities.retrieval_latency( model_parameters["retrieval_threshold"], model_parameters["latency_factor"], model_parameters["latency_exponent"]) else: extra_time = model_parameters["rule_firing"] if self.__finst: self.recent.append(retrieved) if self.__finst < len(self.recent): self.recent.popleft() return retrieved, extra_time
def find(self, otherchunk, actrvariables=None, extra_tests=None): """ Set a chunk in vision based on what is on the screen. """ if extra_tests == None: extra_tests = {} if actrvariables == None: actrvariables = {} try: mod_attr_val = {x[0]: utilities.check_bound_vars(actrvariables, x[1]) for x in otherchunk.removeunused()} except utilities.ACTRError as arg: raise utilities.ACTRError("The chunk '%s' is not defined correctly; %s" % (otherchunk, arg)) chunk_used_for_search = chunks.Chunk(utilities.VISUALLOCATION, **mod_attr_val) found = None found_stim = None closest = float("inf") x_closest = float("inf") y_closest = float("inf") current_x = None current_y = None for each in self.environment.stimulus: position = (int(self.environment.stimulus[each]['position'][0]), int(self.environment.stimulus[each]['position'][1])) try: #checks absolute position if chunk_used_for_search.screen_x and int(chunk_used_for_search.screen_x) != position[0]: continue except (TypeError, ValueError): pass try: #checks absolute position if chunk_used_for_search.screen_y and int(chunk_used_for_search.screen_y) != position[1]: continue except (TypeError, ValueError): pass try: #checks on x and y relative positions if chunk_used_for_search.screen_x[0] == utilities.VISIONSMALLER and int(chunk_used_for_search.screen_x[1:]) <= position[0]: continue elif chunk_used_for_search.screen_x[0] == utilities.VISIONGREATER and int(chunk_used_for_search.screen_x[1:]) >= position[0]: continue except (TypeError, IndexError): pass try: #checks on x and y relative positions if chunk_used_for_search.screen_y[0] == utilities.VISIONSMALLER and int(chunk_used_for_search.screen_y[1:]) <= position[1]: continue elif chunk_used_for_search.screen_y[0] == utilities.VISIONGREATER and int(chunk_used_for_search.screen_y[1:]) >= position[1]: continue except (TypeError, IndexError): pass try: #checks on x and y absolute positions if chunk_used_for_search.screen_x == utilities.VISIONLOWEST and current_x != None and position[0] > current_x: continue elif chunk_used_for_search.screen_x == utilities.VISIONHIGHEST and current_x != None and position[0] < current_x: continue except TypeError: pass try: #checks on x and y absolute positions if chunk_used_for_search.screen_y == utilities.VISIONLOWEST and current_y != None and position[1] > current_y: continue elif chunk_used_for_search.screen_y == utilities.VISIONHIGHEST and current_y != None and position[1] < current_y: continue except TypeError: pass try: if extra_tests["attended"] == False or extra_tests["attended"] == 'False': if self.finst and self.environment.stimulus[each] in self.recent: continue else: if self.finst and self.environment.stimulus[each] not in self.recent: continue except KeyError: pass try: #checks on closest if (chunk_used_for_search.screen_x == utilities.VISIONCLOSEST or chunk_used_for_search.screen_y == utilities.VISIONCLOSEST) and utilities.calculate_pythagorian_distance(self.environment.current_focus, position) > closest: continue except TypeError: pass try: #checks on onewayclosest if (chunk_used_for_search.screen_x == utilities.VISIONONEWAYCLOSEST) and utilities.calculate_onedimensional_distance(self.environment.current_focus, position, horizontal=True) > x_closest: continue except TypeError: pass try: #checks on onewayclosest if (chunk_used_for_search.screen_y == utilities.VISIONONEWAYCLOSEST) and utilities.calculate_onedimensional_distance(self.environment.current_focus, position, horizontal=False) > y_closest: continue except TypeError: pass found_stim = self.environment.stimulus[each] visible_chunk = chunks.makechunk(nameofchunk="vis1", typename="_visuallocation", **{key: each[key] for key in self.environment.stimulus[each] if key != 'position' and key != 'text' and key != 'vis_delay'}) if visible_chunk <= chunk_used_for_search: temp_dict = visible_chunk._asdict() temp_dict.update({"screen_x":position[0], "screen_y":position[1]}) found = chunks.Chunk(utilities.VISUALLOCATION, **temp_dict) current_x = position[0] current_y = position[1] closest = utilities.calculate_pythagorian_distance(self.environment.current_focus, position) x_closest = utilities.calculate_onedimensional_distance(self.environment.current_focus, position, horizontal=True) y_closest = utilities.calculate_onedimensional_distance(self.environment.current_focus, position, horizontal=False) return found, found_stim
def func(): production1 = rule1['rule']() production2 = rule2['rule']() pro1 = next(production1).copy() pro2 = next(production2).copy() for key in pro1: code = key[0] buff = key[1:] #querying just kept if utilities._LHSCONVENTIONS[code] == "query": continue #here below -- testing if key not in pro2: continue pro2buff = pro2.pop(key)._asdict() pro1buff = pro1[key]._asdict() mod_attr_val = {} if buff in slotvals: for slot in pro2buff: try: slotvals_slot = slotvals[buff][slot].removeunused() except (KeyError, AttributeError, TypeError): slotvals_slot = None if not slotvals_slot: varval = utilities.merge_chunkparts(pro1buff[slot], pro2buff[slot]) mod_attr_val[slot] = varval else: mod_attr_val[slot] = pro1buff[slot] elif buff == retrieval: continue #test on retrieved elem from rule1 in rule2 is removed because no retrieval else: for slot in pro2buff: varval = utilities.merge_chunkparts(pro1buff[slot], pro2buff[slot]) mod_attr_val[slot] = varval new_chunk = chunks.Chunk(pro1[key].typename, **mod_attr_val) pro1[key] = new_chunk #test on pro2 here below -- buffers might be in pro2 that are missing in pro1 for key in pro2: code = key[0] buff = key[1:] if utilities._LHSCONVENTIONS[code] == "query": temp_production1 = rule1['rule']() _, temp_testing = next(temp_production1), next(temp_production1) for temp_key in temp_testing: if utilities._RHSCONVENTIONS[temp_key[0]] != "modify" and utilities._RHSCONVENTIONS[temp_key[0]] != "extra_test" and temp_key[1:] == buff: break else: pro1.setdefault(key, {}).update(pro2[key]) continue pro2buff = pro2[key]._asdict() mod_attr_val = {} if buff in slotvals: for slot in pro2buff: try: slotvals_slot = slotvals[buff][slot].removeunused() except (KeyError, AttributeError, TypeError): slotvals_slot = None if not slotvals_slot: mod_attr_val[slot] = pro2buff[slot] elif buff == retrieval: continue #test on retrieved elem from rule1 in rule2 is removed because no retrieval else: mod_attr_val = pro2buff.copy() new_chunk = chunks.Chunk(pro2[key].typename, **mod_attr_val) pro1[key] = new_chunk yield pro1 pro1 = next(production1).copy() pro2 = next(production2).copy() #anything in pro2 should go into action for key in pro2: code = key[0] buff = key[1:] if utilities._RHSCONVENTIONS[code] in {"execute", "clear", "extra_test"}: continue if buff not in slotvals: continue pro1buff = slotvals[buff] pro2buff = pro2[key]._asdict() mod_attr_val = {} for slot in pro2buff: if pro1buff and slot in pro1buff: varval = utilities.merge_chunkparts(pro2buff[slot], pro1buff[slot]) mod_attr_val[slot] = varval else: mod_attr_val[slot] = pro2buff[slot] new_chunk = chunks.Chunk(pro2[key].typename, **mod_attr_val) pro2[key] = new_chunk #actions in pro1 here below -- buffers might be in pro1 that are missing in pro2 for key in pro1: code = key[0] buff = key[1:] for temp_key in pro2: if temp_key[1:] == buff: key = None break if not key: continue if buff == retrieval: continue if utilities._RHSCONVENTIONS[code] in {"execute", "clear", "extra_test"}: pro2[key] = pro1[key] continue pro1buff = pro1[key]._asdict() mod_attr_val = {} for slot in pro1buff: mod_attr_val[slot] = pro1buff[slot] new_chunk = chunks.Chunk(pro1[key].typename, **mod_attr_val) pro2[key] = new_chunk yield pro2