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
