def test_sanity(self): controller = MyController() c = Codelet(Foo, controller, 50, dict(x=3)) self.assertEqual(50, c.urgency) self.assertEqual(18, c.Run()) self.assertEqual(c, controller.most_recent_codelet) self.assertEqual(48, c.Run())
def GetSimilarityAffordances(self, other, other_fringe, my_fringe, controller): logging.debug('GetSimilarityAffordances called: [%s] and [%s] ', self, other) if not isinstance(other, SAnchored): return () left, right = sorted((self, other), key=lambda x: x.start_pos) # Do they overlap? if left.end_pos >= right.start_pos: # They overlap. So we will want to form a bigger group... from farg.apps.seqsee.codelet_families.overlapping_groups import CF_ActOnOverlappingGroups return [ Codelet(CF_ActOnOverlappingGroups, controller, 100, dict(left=left, right=right)) ] else: # So both are anchored, and have overlapping fringes. Time for subspaces! urgency = 100.0 / (right.start_pos - left.end_pos ) # denominator is at least 1. from farg.apps.seqsee.subspaces.get_mapping import CF_FindAnchoredSimilarity return [ Codelet( CF_FindAnchoredSimilarity, controller, urgency, dict(left=left, right=right, seqsee_ltm=controller.ltm)) ]
def GetAffordances(self, controller): logging.debug('GetAffordances called for %s', self) codelets = [] from farg.apps.seqsee.codelet_families.all import CF_FocusOn for relation in self.relations: # QUALITY TODO(Feb 10, 2012): Whether to add a relation-focusing codelet should depend # on its confidence, whether it is internal (part of a group), and other considerations. codelets.append( Codelet(CF_FocusOn, controller, 25, dict(focusable=relation))) my_node = controller.ltm.GetNode(content=self) outgoing_isa_edges = my_node.GetOutgoingEdgesOfTypeIsa() for edge in outgoing_isa_edges: # QUALITY TODO(Feb 10, 2012): Category activation and edge strength relevant here. category = edge.to_node.content # The following appears to repeatedly check; However, note that the link in the LTM # suggests that the categorization is possible. if not self.object.IsKnownAsInstanceOf(category): from farg.apps.seqsee.codelet_families.all import CF_DescribeAs codelets.append( Codelet(CF_DescribeAs, controller, 25, dict(item=self.object, category=category))) if self.object.underlying_mapping_set: from farg.apps.seqsee.codelet_families.extend_group import CF_ExtendGroup codelets.append( Codelet(CF_ExtendGroup, controller, 25, dict(item=self))) return codelets
def GetAffordances(self, controller): # TODO(# --- Jan 3, 2012): Too eager, tone this down later. from farg.apps.seqsee.codelet_families.all import CF_GroupFromRelation from farg.apps.seqsee.codelet_families.all import CF_IsThisInterlaced if self.AreEndsContiguous(): return (Codelet(CF_GroupFromRelation, controller, 50, dict(relation=self)), ) else: distance_object = self.ChooseDistanceObject(controller) if controller.GetActivation(content=distance_object) > 0.8: return (Codelet(CF_IsThisInterlaced, controller, 50, dict(distance=distance_object)), ) else: return ()
def GetRemindingBasedActions(self, prior_overlapping): return [ Codelet( family=CF_PrintOverlapWithPrior, controller=controller, urgency=100) ]
def AddCodelet(self, *, family, urgency, arguments_dict=None, parents=None, msg=""): """Adds a codelet to the coderack. Keyword-only Args: family: Family of codelet. Subclass of :py:class:`~farg.core.codelet.CodeletFamily`. urgency: Number between 0 and 100 indicating urgency. arguments_dict: A dictionary of extra arguments to pass to the codelet. See details in the documentation of :py:class:`~farg.core.codelet.CodeletFamily`. """ if arguments_dict is None: arguments_dict = {} codelet = Codelet(family=family, controller=self, urgency=urgency, arguments_dict=arguments_dict) self.coderack.AddCodelet(codelet, parents=parents, msg=msg)
def test_force_next_codelet(self): """For testing, it is useful to mark the next codelet that GetCodelet() returns.""" c = Coderack(10) controller = MyController() codelet = Codelet(Foo, controller, 20, dict(x=3)) codelet2 = Codelet(Foo, controller, 30, dict(x=4)) codelet3 = Codelet(Foo, controller, 30, dict(x=4)) c.AddCodelet(codelet) c.AddCodelet(codelet2) self.assertEqual(None, c._forced_next_codelet) self.assertRaises(FargError, c.ForceNextCodelet, codelet3) # Not in coderack c.ForceNextCodelet(codelet2) self.assertEqual(codelet2, c._forced_next_codelet) self.assertEqual(codelet2, c.GetCodelet()) self.assertEqual(None, c._forced_next_codelet) # Not in coderack any longer. self.assertRaises(FargError, c.ForceNextCodelet, codelet2)
def SuggestActions(self, *, instance, logic, controller): """What actions could we take with things that are integers?""" # Are these categories? "I have tried extending right", "I should try extending right..." # I want to suggest the following only when it has not recently been tried. Perhaps the logic # can store some of this bookkeepinginfo? object_to_right = controller.workspace.GetObjectToRight(instance) if not object_to_right: return [] return [ Codelet(family=CF_DescribeRelationWithObject, controller=controller, urgency=100, arguments_dict=dict(first=instance, second=object_to_right)) ]
def test_basic(self): c = Coderack(max_capacity=10) controller = MyController() codelet = Codelet(Foo, controller, urgency=20, arguments_dict=dict(x=3)) assert 10 == c._max_capacity c.AddCodelet(codelet) assert 1 == c._codelet_count assert 20 == c._urgency_sum c._ExpungeSomeCodelet() assert 0 == c._codelet_count assert 0 == c._urgency_sum self.assertRaises(CoderackEmptyException, c.GetCodelet)
def _AddRoutineCodelets(self, force=False): """Add routine codelets to the coderack. The codelets are found in routine_codelets_to_add, which is a list of 3-tuples. Each 3-tuple contains the codelet family, urgency, and probability with which to add that codelet. Args: force: If true, the third field of the 3-tuple ("probability of adding") is ignored. The codelets are added with a certain probability (specified in the third term of the tuple), but this can be over-ridden with force (or if the coderack is empty). """ if self.coderack.IsEmpty(): force = True if self.routine_codelets_to_add: for family, urgency, probability in self.routine_codelets_to_add: if force or Toss(probability): cl = Codelet(family, self, urgency) self.coderack.AddCodelet(cl, msg="Routine codelet")
def CalculateActions(self, ctrl): return [ Codelet(family=CF_PrintIWasFocused, controller=ctrl, urgency=100) ]