def test_transmit_selector_all_of_type(self):
net = models.Network()
self.db.add(net)
# Create a network of two biological nodes.
agent1 = nodes.ReplicatorAgent(network=net)
agent2 = nodes.ReplicatorAgent(network=net)
agent1.connect(direction="to", whom=agent2)
information.Meme(origin=agent1, contents="foo1")
information.Meme(origin=agent1, contents="foo2")
information.Meme(origin=agent1, contents="foo3")
information.Gene(origin=agent1, contents="bar")
assert len(agent1.infos(type=Meme)) == 3
assert len(agent2.infos(type=Meme)) == 0
assert len(agent1.infos(type=Gene)) == 1
assert len(agent2.infos(type=Gene)) == 0
# Transmit memes from agent 1 to 2.
agent1.transmit(what=information.Meme, to_whom=agent2)
# Receive the transmission.
agent2.receive()
# Make sure that Agent 2 has a blank memome and the right gene.
assert not agent2.infos(type=Gene)
assert len(agent2.infos(type=Meme)) == 3
def test_agent_transmit_no_connection(self):
net = models.Network()
self.db.add(net)
agent1 = nodes.ReplicatorAgent(network=net)
agent2 = nodes.ReplicatorAgent(network=net)
info = models.Info(origin=agent1, contents="foo")
agent1.transmit(what=info, to_whom=agent2)
def test_transmission_order(self, db_session):
net = models.Network()
db_session.add(net)
agent1 = nodes.ReplicatorAgent(network=net)
agent2 = nodes.ReplicatorAgent(network=net)
agent3 = nodes.ReplicatorAgent(network=net)
self.add(db_session, agent1, agent2, agent3)
db_session.commit()
agent1.connect(whom=agent2)
agent1.connect(whom=agent3)
self.add(db_session, agent1, agent2, agent3)
info1 = models.Info(origin=agent1, contents="foo")
info2 = models.Info(origin=agent1, contents="bar")
info3 = models.Info(origin=agent1, contents="baz")
info4 = models.Info(origin=agent1, contents="spam")
self.add(db_session, info1, info2, info3, info4)
agent1.transmit(what=info1, to_whom=agent2)
agent2.receive()
agent1.transmit(what=info2, to_whom=agent3)
agent3.receive()
agent1.transmit(what=info3, to_whom=agent2)
agent2.receive()
agent1.transmit(what=info4, to_whom=agent3)
agent3.receive()
db_session.commit()
transmissions = agent1.transmissions()
assert len(transmissions) == 4
assert transmissions[0].receive_time < transmissions[1].receive_time
assert transmissions[1].receive_time < transmissions[2].receive_time
assert transmissions[2].receive_time < transmissions[3].receive_time
def test_agent_transmit_everything_to_everyone(self):
net = models.Network()
self.db.add(net)
self.db.commit()
agent1 = nodes.ReplicatorAgent(network=net)
agent2 = nodes.ReplicatorAgent(network=net)
agent3 = nodes.ReplicatorAgent(network=net)
agent1.connect(direction="to", whom=agent2)
agent1.connect(direction="to", whom=agent3)
info = models.Info(origin=agent1, contents="foo")
agent1.transmit(what=models.Info, to_whom=nodes.Agent)
agent2.receive()
agent3.receive()
assert agent1.infos()[0].contents == agent2.infos()[0].contents
assert agent1.infos()[0].contents == agent3.infos()[0].contents
assert agent1.infos()[0].id != agent2.infos()[0].id != agent3.infos(
)[0].id
transmissions = info.transmissions()
assert len(transmissions) == 2
def test_random_walk_from_source(self):
net = models.Network()
self.db.add(net)
self.db.commit()
agent1 = nodes.ReplicatorAgent(network=net)
agent2 = nodes.ReplicatorAgent(network=net)
agent3 = nodes.ReplicatorAgent(network=net)
agent1.connect(whom=agent2)
agent2.connect(whom=agent3)
source = nodes.RandomBinaryStringSource(network=net)
from operator import attrgetter
source.connect(
whom=min(net.nodes(type=Agent), key=attrgetter('creation_time')))
source.create_information()
processes.random_walk(net)
agent1.receive()
msg = agent1.infos()[0].contents
processes.random_walk(net)
agent2.receive()
agent2.infos()[0].contents
processes.random_walk(net)
agent3.receive()
agent3.infos()[0].contents
assert msg == agent3.infos()[0].contents
def test_agent_transmit_invalid_info(self):
net = models.Network()
self.db.add(net)
agent1 = nodes.ReplicatorAgent(network=net)
agent2 = nodes.ReplicatorAgent(network=net)
agent1.connect(direction="to", whom=agent2)
info = models.Info(origin=agent2, contents="foo")
agent1.transmit(what=info, to_whom=agent2)
def test_transmit_raises_if_no_connection_to_destination(self, db_session):
net1 = models.Network()
net2 = models.Network()
agent1 = nodes.ReplicatorAgent(network=net1)
agent2 = nodes.ReplicatorAgent(network=net2)
info1 = models.Info(origin=agent1, contents="foo")
info2 = models.Info(origin=agent1, contents="bar")
self.add(db_session, info1, info2)
with raises(ValueError) as excinfo:
agent1.transmit(what=None, to_whom=agent2)
assert excinfo.match("cannot transmit to {}".format(agent2))
def test_transmit_to_class_finds_nodes_in_network(self, db_session):
net = models.Network()
agent1 = nodes.ReplicatorAgent(network=net)
agent2 = nodes.ReplicatorAgent(network=net)
agent1.connect(whom=agent2)
info1 = models.Info(origin=agent1, contents="foo")
self.add(db_session, info1)
transmissions = agent1.transmit(what=info1,
to_whom=nodes.ReplicatorAgent)
assert len(transmissions) == 1
assert transmissions[0].origin is agent1
assert transmissions[0].destination is agent2
def test_transmit_none_finds_all_infos(self, db_session):
net = models.Network()
agent1 = nodes.ReplicatorAgent(network=net)
agent2 = nodes.ReplicatorAgent(network=net)
agent1.connect(whom=agent2)
info1 = models.Info(origin=agent1, contents="foo")
info2 = models.Info(origin=agent1, contents="bar")
self.add(db_session, info1, info2)
transmissions = agent1.transmit(what=None, to_whom=agent2)
assert len(transmissions) == 2
for t in transmissions:
assert t.origin is agent1
assert t.destination is agent2
def test_network_downstream_nodes(self):
net = networks.Network()
self.db.add(net)
self.db.commit()
node1 = models.Node(network=net)
node2 = models.Node(network=net)
agent1 = nodes.Agent(network=net)
agent2 = nodes.ReplicatorAgent(network=net)
source1 = nodes.Source(network=net)
nodes.Source(network=net)
node1.connect(whom=[node2, agent1, agent2])
raises(TypeError, node1.connect, whom=source1)
assert set(node1.neighbors(direction="to")) == set(
[node2, agent1, agent2])
assert len(node1.vectors(direction="outgoing")) == 3
assert set(node1.neighbors(direction="to",
type=nodes.Agent)) == set([agent1, agent2])
agent1.fail()
agent2.fail()
raises(ValueError, node1.neighbors, direction="ghbhfgjd")
def test_moran_process_cultural(self, db_session):
# Create a fully-connected network.
net = models.Network()
db_session.add(net)
db_session.commit()
agent1 = nodes.ReplicatorAgent(network=net)
agent2 = nodes.ReplicatorAgent(network=net)
agent3 = nodes.ReplicatorAgent(network=net)
db_session.commit()
agent1.connect(whom=agent2)
agent1.connect(whom=agent3)
agent2.connect(whom=agent1)
agent2.connect(whom=agent3)
agent3.connect(whom=agent1)
agent3.connect(whom=agent2)
# Add a global source and broadcast to all the nodes.
source = nodes.RandomBinaryStringSource(network=net)
for agent in net.nodes(type=Agent):
source.connect(whom=agent)
source.transmit(to_whom=agent)
agent.receive()
# Run a Moran process for 100 steps.
for i in range(100):
processes.moran_cultural(net)
for agent in net.nodes(type=Agent):
agent.receive()
# Ensure that the process had reached fixation.
from operator import attrgetter
assert (max(agent1.infos(),
key=attrgetter("creation_time")).contents == max(
agent2.infos(),
key=attrgetter("creation_time")).contents)
assert (max(agent2.infos(),
key=attrgetter("creation_time")).contents == max(
agent3.infos(),
key=attrgetter("creation_time")).contents)
assert (max(agent3.infos(),
key=attrgetter("creation_time")).contents == max(
agent1.infos(),
key=attrgetter("creation_time")).contents)
def test_create_replicator_agent(self):
net = models.Network()
self.db.add(net)
agent = nodes.ReplicatorAgent(network=net)
assert len(agent.infos()) is 0
info = information.Info(origin=agent, contents="foo")
assert agent.infos()[0] == info
def test_agent_transmit(self):
net = models.Network()
self.db.add(net)
agent1 = nodes.ReplicatorAgent(network=net)
agent2 = nodes.ReplicatorAgent(network=net)
agent1.connect(direction="to", whom=agent2)
info = models.Info(origin=agent1, contents="foo")
agent1.transmit(what=agent1.infos()[0], to_whom=agent2)
agent2.receive()
assert agent1.infos()[0].contents == agent2.infos()[0].contents
assert agent1.infos()[0].id != agent2.infos()[0].id
transmission = info.transmissions()[0]
assert transmission.info_id == info.id
assert transmission.origin_id == agent1.id
assert transmission.destination_id == agent2.id
def test_moran_process_sexual(self):
# Create a fully-connected network.
net = networks.Network()
self.db.add(net)
self.db.commit()
agent1 = nodes.ReplicatorAgent(network=net)
agent2 = nodes.ReplicatorAgent(network=net)
agent3 = nodes.ReplicatorAgent(network=net)
agent1.connect(direction="both", whom=[agent2, agent3])
agent2.connect(direction="both", whom=agent3)
# Add a global source and broadcast to all the nodes.
source = nodes.RandomBinaryStringSource(network=net)
source.connect(direction="to", whom=net.nodes(type=Agent))
source.create_information()
for agent in net.nodes(type=Agent):
source.transmit(to_whom=agent)
agent.receive()
# Run a Moran process for 100 steps.
for i in range(100):
nodes.ReplicatorAgent(network=net)
processes.moran_sexual(net)
for agent in net.nodes(type=Agent):
agent.receive()
# Ensure that the process had reached fixation.
assert agent1.failed is True
assert agent2.failed is True
assert agent3.failed is True
for a in net.nodes(type=Agent):
for a2 in net.nodes(type=Agent):
assert a.infos()[0].contents == a2.infos()[0].contents
def test_broadcast_random_binary_string_source(self, db_session):
net = models.Network()
self.add(db_session, net)
source = nodes.RandomBinaryStringSource(network=net)
agent1 = nodes.ReplicatorAgent(network=net)
agent2 = nodes.ReplicatorAgent(network=net)
db_session.add(agent1)
db_session.add(agent2)
db_session.commit()
source.connect(whom=agent1)
source.connect(whom=agent2)
self.add(db_session, source, agent1, agent2)
source.transmit(what=source.create_information())
db_session.commit()
agent1.receive()
agent2.receive()
db_session.commit()
assert agent1.infos()[0].contents in ["00", "01", "10", "11"]
assert agent2.infos()[0].contents in ["00", "01", "10", "11"]
def test_create_environment_get_observed(self, db_session):
net = models.Network()
db_session.add(net)
environment = nodes.Environment(network=net)
information.State(origin=environment, contents="foo")
agent = nodes.ReplicatorAgent(network=net)
environment.connect(direction="to", whom=agent)
environment.transmit(to_whom=agent)
agent.receive()
assert agent.infos()[0].contents == "foo"
def test_node_incoming_transmissions(self):
net = models.Network()
self.db.add(net)
agent1 = nodes.ReplicatorAgent(network=net)
agent2 = nodes.ReplicatorAgent(network=net)
agent3 = nodes.ReplicatorAgent(network=net)
self.add(agent1, agent2, agent3)
self.db.commit()
agent1.connect(direction="from", whom=[agent2, agent3])
self.add(agent1, agent2, agent3)
info1 = models.Info(origin=agent2, contents="foo")
info2 = models.Info(origin=agent3, contents="bar")
self.add(info1, info2)
agent2.transmit(what=info1, to_whom=agent1)
agent3.transmit(what=info2, to_whom=agent1)
self.db.commit()
assert len(agent1.transmissions(direction="incoming")) == 2
assert len(agent2.transmissions(direction="incoming")) == 0
assert len(agent3.transmissions(direction="incoming")) == 0
def test_node_outgoing_transmissions(self, db_session):
net = models.Network()
db_session.add(net)
agent1 = nodes.ReplicatorAgent(network=net)
agent2 = nodes.ReplicatorAgent(network=net)
agent3 = nodes.ReplicatorAgent(network=net)
self.add(db_session, agent1, agent2, agent3)
db_session.commit()
agent1.connect(whom=agent2)
agent1.connect(whom=agent3)
self.add(db_session, agent1, agent2, agent3)
info1 = models.Info(origin=agent1, contents="foo")
info2 = models.Info(origin=agent1, contents="bar")
self.add(db_session, info1, info2)
agent1.transmit(what=info1, to_whom=agent2)
agent1.transmit(what=info2, to_whom=agent3)
db_session.commit()
assert len(agent1.transmissions(direction="outgoing")) == 2
assert len(agent2.transmissions(direction="outgoing")) == 0
assert len(agent3.transmissions(direction="outgoing")) == 0
def test_chain_repr(self):
net = networks.Chain()
self.db.add(net)
self.db.commit()
source = nodes.RandomBinaryStringSource(network=net)
net.add_node(source)
for i in range(4):
agent = nodes.ReplicatorAgent(network=net)
net.add_node(agent)
self.db.commit()
assert repr(net) == ("<Network-" + str(net.id) +
"-chain with 5 nodes, 4 vectors, "
"0 infos, 0 transmissions and 0 transformations>")
def test_transmit_random_binary_string_source(self, db_session):
net = models.Network()
self.add(db_session, net)
source = nodes.RandomBinaryStringSource(network=net)
agent = nodes.ReplicatorAgent(network=net)
db_session.add(source)
db_session.add(agent)
db_session.commit()
source.connect(whom=agent)
self.add(db_session, source, agent)
source.transmit(to_whom=agent)
db_session.commit()
agent.receive()
db_session.commit()
assert agent.infos()[0].contents in ["00", "01", "10", "11"]
