def test_basics(self):
fm = FARGModel()
# Did it initialize a random-number seed?
self.assertIsInstance(fm.seed, int)
# Build something
ca = fm.build(SeqCanvas([SeqState((4, 5, 6), None)]))
# Is it there?
eiws = fm.get_eiws(ca)
self.assertEqual(eiws.elem, ca)
# Can we find it by exact match?
self.assertEqual(fm.the(ca), ca)
# Can we find it by searching for its class?
self.assertEqual(fm.the(Canvas), ca)
# Does it have initial activation?
self.assertEqual(fm.a(ca), 1.0)
# TODO Check builder and behalf_of
# TODO Log the BUILT?
cr = fm.build(CellRef(ca, 1)) # pointer to 2nd cell on canvas
# TODO auto-support between CellRef and Canvas? (as in next line)
#self.assertEqual(fm.ae_weight(cr, ca), fm.mutual_support_weight)
delta = ArithDelta((4, 5), 9, plus)
state1 = SeqState((9, 6), delta)
fm.paint(cr, state1) # TODO paint_on()?
self.assertEqual(ca[1], state1)
def run( # type: ignore[override]
self,
fm: FARGModel,
agent: Agent,
sleep_duration: int
) -> CodeletResults:
fm.sleep(agent, sleep_duration)
return None
def test_before_from_avails(self) -> None:
fm = FARGModel()
ca = fm.build(self.pons_start_canvas())
cr0 = CellRef(ca, 0)
qarg = QBeforeFromAvails(source=cr0)
self.assertCountEqual(as_iter(qarg.get_items(
fm, [])), [Before(4), Before(5), Before(6)])
def test_pulse_slipnet(self) -> None:
fm = FARGModel(seed=1, slipnet=Slipnet(eqn_graph))
activations_in = {Before(4): 1.0, After(9): 1.0}
nodes = fm.pulse_slipnet(
activations_in=activations_in, # type: ignore[arg-type]
pred=Equation,
num_get=20)
self.assertTrue(all(isinstance(node, Equation) for node in nodes))
self.assertTrue(Equation.make([5, 4], plus) in nodes)
def test_mk_slipnet_args_exclude_existing(self) -> None:
fm = FARGModel(slipnet=Slipnet(eqn_graph))
kwargs = fm.mk_slipnet_args((Equation.make(
[4, 1], plus), ExcludeExisting(), SearchFor(Equation)), None)
self.assertCountEqual(kwargs['pred'], (ExcludeExisting(), Equation))
alog = fm.start_alog('Unit Test')
got = fm.pulse_slipnet(alog=alog, **kwargs)
#alog.see()
self.assertCountEqual(got, [Equation.make([4, 1], plus)])
def test_slipnet_kwargs1(self) -> None:
fm = FARGModel()
qargs = (Before(4), After(11), SearchFor(Equation))
self.assertEqual(
fm.mk_slipnet_args(qargs, []),
dict(activations_in=dict(((Before(4), 1.0), (After(11), 1.0))),
pred=(Equation, ),
k=20,
num_get=1))
def test_codelet_args(self) -> None:
fm = FARGModel()
#codelet: Codelet = fm.replace_refs(ag.born, ag) # type: ignore[arg-type]
codelet: Codelet = ag.born # type: ignore[assignment]
self.assertEqual(
fm.mk_func_args(codelet.run, ag),
dict(fm=fm, late_bound='FROM AGENT')
# This dict holds the arguments to ag.born's .run() method
)
def also_tag(cls, fm: FARGModel, node: Node) -> Iterable[Node]:
'''Returns nodes that also need tagging if 'node' is tagged, but does
not recurse. So, if 'node' necessitates tagging node A, and node A
necessitates tagging node B, then also_needs_tagging1 will return
node A but not node B.'''
if isinstance(node, CellRef):
yield from fm.painters_of(node, node.value)
elif isinstance(node, Painter):
yield from fm.behalf_of(node)
def test_litpainter(self):
fm = FARGModel()
ca = fm.build(SeqCanvas([SeqState((4, 5, 6), None)]))
cr = CellRef(ca, 1) # pointer to 2nd cell on canvas
state1 = SeqState((9, 6), ArithDelta((4, 5), 9, plus))
lp = fm.build(LitPainter(cr, state1))
lp.go(fm) # TODO Call fm.go() and let it fill in args?
# TODO A threshold for painting
self.assertEqual(ca[1], state1)
self.assertTrue(fm.is_mutual_support(lp, cr))
def run( # type: ignore[override]
self,
fm: FARGModel,
running_agent: Optional[Agent]
) -> CodeletResults:
if running_agent:
fm.set_state(fm.behalf_of(running_agent), Delegate_succeeded)
return NewState(running_agent, Succeeded)
else:
return None
def test_query_slipnet_for_delegate(self) -> None:
graph = Graph.with_features(
Consumer.make_table(range(1, 20), range(1, 20),
[plus, minus, times]))
fm = FARGModel(slipnet=Slipnet(graph))
ca = fm.build(self.pons_start_canvas())
cr0 = fm.build(CellRef(ca, 0))
# succeed
codelet = QuerySlipnetForDelegate(qargs=(QBeforeFromAvails(),
QAfter(15),
SearchFor(Consumer)))
#t0 = process_time()
fm.run_codelet_and_follow_ups(codelet, {'source': cr0})
#print('RUN1', process_time() - t0)
delegate = fm.the(Consumer)
self.assertIsNotNone(delegate)
# fail
codelet = QuerySlipnetForDelegate(qargs=(QBeforeFromAvails(),
QAfter(15),
SearchFor(DummyAgent)))
#t0 = process_time()
with self.assertRaises(NoResultFromSlipnet):
fm.run_codelet_and_follow_ups(codelet, {'source': cr0})
def test_variant_maker(self) -> None:
fm = FARGModel()
ca = fm.build(self.pons_start_canvas())
cr0 = fm.build(CellRef(ca, 0))
ag1 = fm.build(Consumer(
operator=plus,
operands=(4, 4),
source=cr0
))
ag2 = fm.build(VariantMakerFromAvails(
agent=ag1,
cellref=cr0,
avails=(4, None),
unavails=(None, 4)
))
# The VariantMakerFromAvails should make a new Consumer, one whose
# operands include 4 and another real avail, i.e. 5 or 6.
#lenable(Agent, Codelet, Fizzle)
#pr(fm)
fm.run_agent(ag2)
new_consumer = first(fm.nodes((Consumer, Exclude(ag1))))
#ldisable_all()
self.assertTrue(
match_wo_none(new_consumer, Consumer.make(plus, (4, 5)))
or
match_wo_none(new_consumer, Consumer.make(plus, (4, 6)))
)
def test_buildlitpainter(self) -> None:
fm = FARGModel()
ca = fm.build(self.pons_start_canvas())
cr1 = fm.build(CellRef(ca, 1))
codelet = BuildLitPainter(dest=cr1, value=self.step1)
fm.run_codelet(codelet)
lp: LitPainter = fm.the(LitPainter) # type: ignore[assignment]
self.assertIsNotNone(lp)
fm.run_agent(lp)
self.assertEqual(ca[1], self.step1)
self.assertEqual(fm.agent_state(lp), Succeeded)
def run( # type: ignore[override]
self,
fm: FARGModel,
value: Value,
dest: CellRef,
running_agent: Optional[Agent]
) -> CodeletResults:
fm.build(
Agents.LitPainter(value=value, dest=dest),
builder=running_agent
)
return None
def test_no_duplicate(self):
fm = FARGModel()
ca = fm.build(SeqCanvas([SeqState((4, 5, 6), None)]))
cr = CellRef(ca, 1) # pointer to 2nd cell on canvas
state1 = SeqState((9, 6), ArithDelta((4, 5), 9, plus))
lp1a = fm.build(LitPainter(cr, state1))
lp1b = fm.build(LitPainter(cr, state1))
self.assertIs(lp1a, lp1b)
state2 = SeqState((10, 5), ArithDelta((4, 6), 10, plus))
lp2 = fm.build(LitPainter(cr, state2))
self.assertIsNot(lp1a, lp2)
def test_sleep_codelet(self) -> None:
fm = FARGModel()
ca = fm.build(self.pons_start_canvas())
cr0 = fm.build(CellRef(ca, 0))
cr1 = fm.build(CellRef(ca, 1))
lp = fm.build(LitPainter(dest=cr1, value=self.step1))
self.assertFalse(fm.is_sleeping(lp))
fm.run_codelet(Sleep(agent=lp, sleep_duration=10))
self.assertTrue(fm.is_sleeping(lp))
def test_slipnet_kwargs2(self) -> None:
fm = FARGModel()
ca = fm.build(self.pons_start_canvas())
cr0 = CellRef(ca, 0)
qargs = (QBeforeFromAvails(), QAfter(), SearchFor())
sources = dict(source=cr0, features=15, type=Equation)
self.assertEqual(
fm.mk_slipnet_args(qargs, sources),
dict(activations_in=dict(((Before(4), 1.0), (Before(5), 1.0),
(Before(6), 1.0), (After(15), 1.0))),
pred=(Equation, ),
k=20,
num_get=1))
def test_add_tag(self) -> None:
fm = FARGModel()
ca = fm.build(self.pons_start_canvas())
cr0 = fm.build(CellRef(ca, 0))
self.assertFalse(fm.has_tag(cr0, UTTag))
#fm.add_tag(cr0, UTTag())
fm.run_codelet(AddTag(tag=UTTag, taggee=cr0))
self.assertTrue(fm.has_tag(cr0, UTTag))
self.assertTrue(match_wo_none(UTTag(), UTTag()))
self.assertTrue(fm.has_node(UTTag()))
def test_build_codelet(self) -> None:
fm = FARGModel()
dag = fm.build(DummyAgent())
self.assertEqual(fm.agent_state(dag), Born)
bc = Build(to_build=DummyCompanion())
sources = fm.run_codelet(bc, agent=dag)
self.assertTrue(fm.has_node(DummyCompanion()))
companion = fm.the(DummyCompanion)
self.assertEqual(fm.ae_weight(dag, companion), 1.0)
self.assertEqual(fm.builder_of(companion), dag)
self.assertIn(companion, fm.look_up_by_name('built', sources))
def run( # type: ignore[override]
self,
fm: FARGModel,
exctype: Type[Exception],
sources: Sources
) -> CodeletResults:
raise exctype(**fm.mk_func_args(exctype, sources)) # type: ignore[call-arg]
def test_actioncanvas(self) -> None:
ca = ActionCanvas.make(Avails(4, 5, 6), Plus(4, 5))
self.assertEqual(pss(ca), '[ avails=(4, 5, 6) / 4 + 5 ]')
fm = FARGModel()
ca = fm.build(ca)
#ps(ca)
got = ca.run()
self.assertEqual(got, Produced(Avails(6, 9)))
#got = fm.run(ca)
#self.assertEqual(got, Produced(Avails(6, 9)))
self.assertEqual(
pss(ca), '[ avails=(4, 5, 6) / 4 + 5 ][ avails=(6, 9) / None ]')
def test_agent_replace_refs(self) -> None:
fm = FARGModel()
ag1 = ag.replace_refs(fm, None)
self.assertEqual(
ag1,
DummyAgent(agstr='FROM AGENT',
born=DummyCodelet(late_bound=Ref('agstr'))))
def run( # type: ignore[override]
self,
fm: FARGModel,
taggee: Node,
tag: Node,
sources: Sources
) -> CodeletResults:
if not fm.has_node(taggee):
if isinstance(taggee, CellRef): # HACKish and needs UT
sources = fm.run_codelet_and_follow_ups(
Build(to_build=taggee),
sources
)
if fm.has_node(taggee):
if isclass(tag):
# TODO Supply arguments to tag ctor
tag = tag() # type: ignore[operator]
sources = fm.run_codelet_and_follow_ups(
Build(to_build=tag),
sources
)
tag = first(fm.look_up_by_name('built', sources))
# TODO What if tag is None now?
fm.add_tag(taggee, tag)
else:
raise TaggeeDoesNotExist(taggee=taggee)
return None
def test_run_agent(self) -> None:
fm = FARGModel()
DummyCodelet.depository = ''
fm.run_agent(ag, Born) # ag does not exist yet
self.assertEqual(DummyCodelet.depository, '')
agent = fm.build(ag)
fm.run_agent(agent, Born)
self.assertEqual(DummyCodelet.depository, 'FROM AGENT')
def run( # type: ignore[override]
self,
fm: FARGModel,
builder: Optional[Actor],
to_build: Nodes,
sources: Sources
) -> CodeletResults:
built: List[Node] = []
for node in as_iter(to_build):
node = fm.replace_refs(node, sources)
node = fm.build(node, builder=builder)
built.append(node)
'''
if builder:
return NewState(builder, Wake)
else:
return None
'''
return {'built': set(built)}
def test_litpainter(self) -> None:
fm = FARGModel()
ca = fm.build(self.pons_start_canvas())
cr1 = CellRef(ca, 1)
lp = fm.build(LitPainter(dest=cr1, value=self.step1))
fm.run_agent(lp)
self.assertEqual(ca[1], self.step1)
self.assertEqual(fm.agent_state(lp), Succeeded)
def see_query(q: Iterable[Node] = (Before(4), After(9)),
pred: WSPred = Consumer,
seed: int = 1,
sngraphs: Union[Graph, Iterable[Graph]] = eqn_graph) -> None:
global fm, ls, nodes, activations_in
fm = FARGModel(seed=seed,
slipnet=Slipnet(Graph.augment(*as_iter(sngraphs))))
activations_in = dict((node, 1.0) for node in q)
lenable(LogAdjustedDeltas)
nodes = fm.pulse_slipnet(
activations_in=activations_in, # type: ignore[arg-type]
pred=pred,
k=5,
num_get=3,
alog=fm.start_alog((None, None)))
ls = list(fm.alogs.logs.values())
print('\nPlotted, final activations:')
ls[0].plot(n=15, pr=True)
print('\nNodes chosen:')
pts(nodes, key=short)
def test_snag_tag_and_no_result_from_slipnet(self) -> None:
fm = FARGModel()
ca = fm.build(self.pons_start_canvas())
cr0 = CellRef(ca, 0)
cr1 = CellRef(ca, 1)
ag = fm.build(Consumer(
operator=plus,
operands=(3, 5), # 3 is not avail, so this Consumer must fail
source=cr0,
#dest=cr1
))
fm.run_agent(ag)
snag_tag = fm.the(Fizzle)
self.assertIsNotNone(snag_tag)
self.assertEqual(fm.builder_of(snag_tag), ag)
self.assertEqual(fm.agent_state(ag), Snag)
def run(bricks: Sequence[int],
target: int,
seed: int = 1,
num_slipnet_iterations: Optional[int] = None,
paint_threshold: float = 0.1) -> None:
global fm, ca, cr0, cr1, cr2, cr3, wa
lenable(Agent, Codelet, Fizzle) #, log_pulse)
fm = FARGModel(slipnet=Slipnet(Graph.augment(eqn_graph, desnaggers_graph)),
seed=seed,
num_slipnet_iterations=num_slipnet_iterations,
paint_threshold=paint_threshold)
ca = fm.build(StepCanvas([Step(tuple(bricks))]))
cr0 = CellRef(ca, 0)
cr1 = CellRef(ca, 1)
cr2 = CellRef(ca, 2)
cr3 = CellRef(ca, 3)
wa = fm.build(
Want(startcell=cr0,
target=target,
on_success=RaiseException(SolvedPuzzle)))
# try:
fm.do_timestep(num=40) # 20
# except Exception as exc:
# print(exc)
pr(fm, extra=True)
def test_paint_codelet(self) -> None:
fm = FARGModel()
ca = fm.build(self.pons_start_canvas())
cr1 = fm.build(CellRef(ca, 1))
fm.run_codelet(Paint(cr1, self.step1))
self.assertEqual(ca[1], self.step1)
