def Run(cls, controller, *, me):
workspace = controller.workspace
supergroups_map = workspace.CalculateSupergroupMap()
History.Note("CF_RemoveSpuriousRelations: called")
for element in workspace.elements:
supergps = supergroups_map[element]
if not supergps:
continue
relations_to_remove = []
for relation in element.relations:
if relation.first == element:
other_end = relation.second
else:
other_end = relation.first
other_supergps = supergroups_map[other_end]
if not other_supergps:
continue
if supergps.intersection(other_supergps):
continue
other_end.relations.discard(relation)
relations_to_remove.append(relation)
History.Note("CF_RemoveSpuriousRelations: removed",
times=len(relations_to_remove))
for relation in relations_to_remove:
element.relations.discard(relation)
def FocusOn(self, focusable, controller):
fringe = focusable.GetFringe()
# TODO(amahabal) This way, anything that was ever a fringe element of an item stays that way.
# But this way is much cheaper than updating everything, and not super wrong...
# When we choose an object based on fringe overlap, we can recalculate,
# if we wish...
for fe, wt in fringe.items():
self.fringe_element_to_item_to_wt[fe][focusable] = wt
timestamp = controller.steps_taken
self.last_focus_time[focusable] = timestamp
controller.ltm.GetNode(content=focusable).IncreaseActivation(
5, current_time=controller.steps_taken)
actions = focusable.GetActions(controller)
prior_overlapping_foci = self.PriorFociWithSimilarFringe(
current_focus=focusable, timestamp=timestamp)
if prior_overlapping_foci:
actions.extend(focusable.GetRemindingBasedActions(
prior_overlapping_foci))
History.Note("In FocusOn: Prior overlapping foci seen")
if actions:
selected_actions = ChooseAboutN(2, [(x, x.urgency) for x in actions])
History.Note("In FocusOn: Total of suggested actions", times=len(actions))
History.Note(
"In FocusOn: Total of selected actions", times=len(selected_actions))
for action in selected_actions:
controller.coderack.AddCodelet(
action,
msg="While focusing on %s" % focusable.BriefLabel(),
parents=(focusable, ))
def InsertGroup(self, group, *, parent=None):
"""Inserts a group into the workspace. It must not conflict with an existing group, else
a ConflictingGroupException is raised.
Returns a new group formed from things added to the workspace.
"""
conflicting_groups = tuple(self.GetConflictingGroups(group))
if conflicting_groups:
logger.info('Conflicts while adding %s: %s', group,
'; '.join(str(x) for x in conflicting_groups))
History.Note("Group insert: conflict")
raise ConflictingGroupException(
conflicting_groups=conflicting_groups)
else:
History.Note("Group insert: no conflict")
return self._PlonkIntoPlace(group)
def __init__(self, *, first, second, parents=[]):
self.first = first
self.second = second
Categorizable.__init__(self)
if History._is_history_on:
roles = {first._hid: "first end", second._hid: "second end"}
History.AddArtefact(self, ObjectType.WS_RELN, "", parents, roles)
History.Note("Created relation")
def GetFringe(self):
fringe = self.CalculateFringe()
for cat, instance_logic in self.categories.items():
fringe[cat] = 1
for att, val in instance_logic._attributes.items():
fringe[(cat, att, val.Structure())] = 0.5
self.stored_fringe = fringe
History.Note("GetFringe called")
return fringe
def FindCategories(self, *, end_category):
new_cats = []
for reln_cat in end_category._RelationCategories:
if self.IsKnownAsInstanceOf(reln_cat):
continue
if (self.DescribeAs(reln_cat)):
History.Note("Category added to reln")
new_cats.append(reln_cat)
return new_cats
def Append(self, *, magnitudes):
"""Adds elements with these magnitudes at the end."""
to_add = [PSElement(magnitude=x) for x in magnitudes]
for idx, el in enumerate(to_add, self._next_index):
el._span = (idx, idx)
self._objects_with_span[(idx, idx)][el.Structure()] = el
self.element.extend(to_add)
self._next_index += len(magnitudes)
History.Note("Arena: elements added", times=len(magnitudes))
def InsertElement(self, element):
"""Insert an element beyond the last element."""
assert isinstance(element, SElement)
anchored = SAnchored(sobj=element,
items=[],
start_pos=self.num_elements,
end_pos=self.num_elements,
is_sequence_element=True)
self.num_elements += 1
History.AddArtefact(anchored, ObjectType.WS_GROUP, "Initial creation")
History.Note("Element Inserted")
self.elements.append(anchored)
def FocusOn(self, focusable, *, parents=None):
"""Focus on focusable, and act on a fringe-hit."""
History.AddEvent(EventType.OBJECT_FOCUS, "", [(focusable, "")])
assert (isinstance(focusable, FocusableMixin))
focusable.OnFocus(self.controller)
self._PrepareForFocusing(focusable)
hit_map = self.StoreFringeAndCalculateOverlap(focusable)
# Possibly add codelets based on the fringe hit.
potential_codelets = []
for prior_focusable, overlap_amount in hit_map.items():
if overlap_amount < Stream.kMinOverlapToTriggerSimilarity:
continue
potential_codelets.extend(
prior_focusable.GetSimilarityAffordances(
focusable,
other_fringe=self.stored_fringes[focusable],
my_fringe=self.stored_fringes[prior_focusable],
controller=self.controller))
potential_codelets.extend(
focusable.GetAffordances(controller=self.controller))
if potential_codelets:
selected_codelets = ChooseAboutN(2, [(x, x.urgency)
for x in potential_codelets])
History.Note("Chose to keep codelet during FocusOn",
times=len(selected_codelets))
History.Note("Chose not to keep codelet during FocusOn",
times=len(potential_codelets) -
len(selected_codelets))
effective_parents = [focusable]
if parents:
effective_parents.extend(parents)
for codelet in selected_codelets:
self.controller.coderack.AddCodelet(
codelet,
msg="While focusing on %s" % focusable.BriefLabel(),
parents=effective_parents)
def Run(cls, controller, left, right, *, me):
if left not in controller.workspace.groups or right not in controller.workspace.groups:
# Groups gone, fizzle.
History.Note("CF_ActOnOverlappingGroups: left group now dead")
return
if set(left.items).intersection(set(right.items)):
# So overlap, and share elements.
left_underlying_set = left.object.underlying_mapping_set
right_underlying_set = right.object.underlying_mapping_set
# TODO(# --- Jan 28, 2012): Even if the following fails, there is reason to try and
# see how the two may be made to agree.
if left_underlying_set and left_underlying_set.intersection(
right_underlying_set):
# This calls out for merging!
new_group_items = sorted(set(left.items).union(set(
right.items)),
key=lambda x: x.start_pos)
logging.debug("New group items: %s",
'; '.join(str(x) for x in new_group_items))
new_group = SAnchored.Create(
new_group_items,
underlying_mapping_set=left_underlying_set.intersection(
right_underlying_set))
try:
controller.workspace.Replace((left, right), new_group)
except ConflictingGroupException as e:
SubspaceDealWithConflictingGroups(
controller,
workspace_arguments=dict(
new_group=new_group,
incumbents=e.conflicting_groups),
parents=[me, left, right],
msg="Conflict when merging overlapping groups").Run()
except CannotReplaceSubgroupException as e:
SubspaceDealWithConflictingGroups(
controller,
workspace_arguments=dict(new_group=new_group,
incumbents=e.supergroups),
parents=[me, left, right],
msg=
"Cannot replace subgp when merging overlapping groups"
).Run()
def Run(cls, controller, relation, *, me):
# If there is a group spanning the proposed group, perish the thought.
left, right = relation.first.start_pos, relation.second.end_pos
from farg.apps.seqsee.util import GreaterThanEq, LessThanEq
if tuple(
controller.workspace.GetGroupsWithSpan(LessThanEq(left),
GreaterThanEq(right))):
History.Note("CF_GroupFromRelation: a spanning group exists")
return
anchored = SAnchored.Create(
(relation.first, relation.second),
underlying_mapping_set=relation.mapping_set)
try:
controller.workspace.InsertGroup(anchored, parent=[me])
except ConflictingGroupException as e:
SubspaceDealWithConflictingGroups(
controller,
workspace_arguments=dict(new_group=anchored,
incumbents=e.conflicting_groups),
parents=[me, relation],
msg="Conflict while inserting %s" %
anchored.BriefLabel()).Run()
def __init__(self):
self.stored_fringe = None
History.Note("Focusable created")
Categorizable.__init__(self)
def __init__(self, *, first, second):
self.first = first
self.second = second
Categorizable.__init__(self)
History.Note("Created relation")
def Run(cls, controller, item, *, me):
if item not in controller.workspace.groups:
History.Note("CF_ExtendGroup: item not in workspace")
# item deleted?
return
# QUALITY TODO(Feb 14, 2012): Direction to extend choice can be
# improved.
extend_right = True
if (item.start_pos > 0 and Toss(0.5)):
extend_right = False
parts = item.items
underlying_mapping_set = item.object.underlying_mapping_set
if not underlying_mapping_set:
History.Note("CF_ExtendGroup: no underlying relations")
return
mapping = SelectWeightedByActivation(
controller.ltm, underlying_mapping_set)
if extend_right:
next_part = mapping.Apply(parts[-1].object)
if not next_part:
History.Note(
"CF_ExtendGroup: could not apply mapping to last part")
return
magnitudes = next_part.FlattenedMagnitudes()
number_of_known_elements = len(
controller.workspace.elements) - item.end_pos - 1
if len(magnitudes) > number_of_known_elements:
# TODO(# --- Feb 14, 2012): This is where we may go beyond known elements.
# To the extent that the next few elements are known, ensure that they agree with
# what's known.
if not controller.workspace.CheckForPresence(item.end_pos + 1,
magnitudes[:number_of_known_elements]):
return
# The following either returns false soon if the user will not be asked, or asks
# the user and returns the response. If the response is yes, the elements are also
# added.
should_continue = SubspaceGoBeyondKnown(
controller,
workspace_arguments=dict(basis_of_extension=item,
suggested_terms=magnitudes),
parents=[me, item]).Run()
if not should_continue:
return
else:
if not controller.workspace.CheckForPresence(item.end_pos + 1, magnitudes):
return
next_part_anchored = SAnchored.CreateAt(
item.end_pos + 1, next_part)
new_parts = list(parts[:])
new_parts.append(next_part_anchored)
else:
flipped = mapping.FlippedVersion()
if not flipped:
return
previous_part = flipped.Apply(parts[0].object)
if not previous_part:
return
magnitudes = previous_part.FlattenedMagnitudes()
if len(magnitudes) > item.start_pos:
return
if not controller.workspace.CheckForPresence(item.start_pos - len(magnitudes),
magnitudes):
return
prev_part_anchored = SAnchored.CreateAt(item.start_pos - len(magnitudes),
previous_part)
new_parts = [prev_part_anchored]
new_parts.extend(parts)
new_group = SAnchored.Create(new_parts,
underlying_mapping_set={mapping})
from farg.apps.seqsee.exceptions import ConflictingGroupException
from farg.apps.seqsee.exceptions import CannotReplaceSubgroupException
from farg.apps.seqsee.subspaces.deal_with_conflicting_groups import SubspaceDealWithConflictingGroups
try:
controller.workspace.Replace(item, new_group)
except ConflictingGroupException as e:
SubspaceDealWithConflictingGroups(
controller,
workspace_arguments=dict(new_group=new_group,
incumbents=e.conflicting_groups),
parents=[me, item],
msg="Conflict when replacing item with enlarged group").Run()
except CannotReplaceSubgroupException as e:
SubspaceDealWithConflictingGroups(
controller,
workspace_arguments=dict(new_group=new_group,
incumbents=e.supergroups),
parents=[me, item],
msg="Cannot replace subgp when extending item").Run()
