def test_probe_building_disabled(self, recwarn):
"""Test that build methods are not called and that a warning is raised
if probe building is disabled.
"""
# Create test network
with nengo.Network() as network:
a = nengo.Ensemble(100, 2)
p_a = nengo.Probe(a, label="Output")
# Create a model
model = Model()
# Dummy neurons builder
ens_build = mock.Mock(name="ensemble builder")
# Define a probe build function
build_ens_probe = mock.Mock()
# Build the model
probe_builders = {nengo.Ensemble: build_ens_probe}
with patch.object(model, "builders", new={nengo.Ensemble: ens_build}),\
patch.object(model, "probe_builders", new=probe_builders):
model.build(network, build_probes=False)
# Assert the probes were NOT built
assert p_a not in model.seeds
assert build_ens_probe.call_count == 0
# And that a warning was raised
w = recwarn.pop()
assert "Probes" in str(w.message)
assert "disabled" in str(w.message)
def test_make_connection_no_signal(self, source_getter, sink_getter):
"""Test that building connections adds a new signal to the model."""
model = Model()
class A(object):
pass
# Create a connection from a to b
connection = mock.Mock()
connection.pre_obj = A()
connection.post_obj = A()
# Create a mock network
network = mock.Mock()
network.seed = None
network.connections = [connection]
network.ensembles = []
network.nodes = []
network.networks = []
network.probes = []
# Patch the getters, add a null builder
with patch.object(model, "source_getters", {A: source_getter}), \
patch.object(model, "sink_getters", {A: sink_getter}), \
patch.object(model, "connection_parameter_builders",
{A: mock.Mock()}):
# Build the network
model.build(network)
# Assert that no signal exists
assert connection not in model.connections_signals
def test_builds_hierarchy(self):
"""Test that networks are built hierarchically.
"""
class A(object):
seed = 101
class B(object):
pass
builders = {A: mock.Mock()}
extra_builders = {B: mock.Mock()}
a = A()
b = B()
network_a = mock.Mock()
network_a.seed = None
network_a.connections = []
network_a.ensembles = [a]
network_a.nodes = []
network_a.networks = []
network_a.probes = []
network_a.config = mock.Mock(name="config")
network_b = mock.Mock()
network_b.seed = None
network_b.connections = []
network_b.ensembles = []
network_b.nodes = [b]
network_b.networks = []
network_b.probes = []
network_b.config = mock.Mock(name="config")
network = mock.Mock()
network.seed = None
network.connections = []
network.ensembles = []
network.nodes = []
network.networks = [network_a, network_b]
network.probes = []
network.config = mock.Mock(name="config")
# Patch the default builders
with patch.object(Model, "builders", new=builders):
# Create a model and build the mock network
model = Model()
model.build(network, extra_builders=extra_builders)
# Assert that the config was stored in the model
assert model.config is network.config
# Assert that seeds were supplied
assert model.seeds[a] == a.seed
assert model.seeds[b] is not None
# Assert the builders got called
builders[A].assert_called_once_with(model, a)
extra_builders[B].assert_called_once_with(model, b)
def test_builds_hierarchy(self):
"""Test that networks are built hierarchically.
"""
class A(object):
seed = 101
class B(object):
pass
builders = {A: mock.Mock()}
extra_builders = {B: mock.Mock()}
a = A()
b = B()
network_a = mock.Mock()
network_a.seed = None
network_a.connections = []
network_a.ensembles = [a]
network_a.nodes = []
network_a.networks = []
network_a.probes = []
network_a.config = mock.Mock(name="config")
network_b = mock.Mock()
network_b.seed = None
network_b.connections = []
network_b.ensembles = []
network_b.nodes = [b]
network_b.networks = []
network_b.probes = []
network_b.config = mock.Mock(name="config")
network = mock.Mock()
network.seed = None
network.connections = []
network.ensembles = []
network.nodes = []
network.networks = [network_a, network_b]
network.probes = []
network.config = mock.Mock(name="config")
# Patch the default builders
with patch.object(Model, "builders", new=builders):
# Create a model and build the mock network
model = Model()
model.build(network, extra_builders=extra_builders)
# Assert that the config was stored in the model
assert model.config is network.config
# Assert that seeds were supplied
assert model.seeds[a] == a.seed
assert model.seeds[b] is not None
# Assert the builders got called
builders[A].assert_called_once_with(model, a)
extra_builders[B].assert_called_once_with(model, b)
def test_builder_dictionaries_are_combined(self, use_make_object):
"""Test that the builder and extra_builders dictionaries are combined
and that a mrolookupdict is used.
"""
class A(object):
seed = 101
class B(object):
pass
builders = {A: mock.Mock()}
extra_builders = {B: mock.Mock()}
a = A()
b = B()
network = mock.Mock()
network.seed = None
network.connections = []
network.ensembles = [a]
network.nodes = [b]
network.networks = []
network.probes = []
network.config = mock.Mock(name="config")
if not use_make_object:
# Patch the default builders
with patch.object(Model, "builders", new=builders):
# Create a model and build the mock network
model = Model()
model.build(network, extra_builders=extra_builders)
# Assert that the config was stored in the model
assert model.config is network.config
else:
# Create the model
model = Model()
model.rng = np.random
# When using `make_object` directly `_builders` should be defined
# and used.
model._builders.update(builders)
model._builders.update(extra_builders)
# Build the objects
model.make_object(a)
model.make_object(b)
# Assert that seeds were supplied
assert model.seeds[a] == a.seed
assert model.seeds[b] is not None
# Assert the builders got called
builders[A].assert_called_once_with(model, a)
extra_builders[B].assert_called_once_with(model, b)
def test_builder_dictionaries_are_combined(self, use_make_object):
"""Test that the builder and extra_builders dictionaries are combined
and that a mrolookupdict is used.
"""
class A(object):
seed = 101
class B(object):
pass
builders = {A: mock.Mock()}
extra_builders = {B: mock.Mock()}
a = A()
b = B()
network = mock.Mock()
network.seed = None
network.connections = []
network.ensembles = [a]
network.nodes = [b]
network.networks = []
network.probes = []
network.config = mock.Mock(name="config")
if not use_make_object:
# Patch the default builders
with patch.object(Model, "builders", new=builders):
# Create a model and build the mock network
model = Model()
model.build(network, extra_builders=extra_builders)
# Assert that the config was stored in the model
assert model.config is network.config
else:
# Create the model
model = Model()
model.rng = np.random
# When using `make_object` directly `_builders` should be defined
# and used.
model._builders.update(builders)
model._builders.update(extra_builders)
# Build the objects
model.make_object(a)
model.make_object(b)
# Assert that seeds were supplied
assert model.seeds[a] == a.seed
assert model.seeds[b] is not None
# Assert the builders got called
builders[A].assert_called_once_with(model, a)
extra_builders[B].assert_called_once_with(model, b)
def test_standard(self, use_arguments, with_slice):
# Create test network
with nengo.Network() as network:
a = nengo.Ensemble(100, 2)
if not with_slice:
p_a = nengo.Probe(a)
else:
p_a = nengo.Probe(a[0])
p_n = nengo.Probe(a.neurons)
# Create a model
model = Model()
# Dummy neurons builder
ens_build = mock.Mock(name="ensemble builder")
# Define two different probe build functions
def build_ens_probe_fn(model, probe):
assert ens_build.called
assert model is model
assert probe is p_a
build_ens_probe = mock.Mock(wraps=build_ens_probe_fn)
def build_neurons_probe_fn(model, probe):
assert ens_build.called
assert model is model
assert probe is p_n
build_neurons_probe = mock.Mock(wraps=build_neurons_probe_fn)
# Build the model
probe_builders = {
nengo.Ensemble: build_ens_probe,
nengo.ensemble.Neurons: build_neurons_probe
}
with patch.object(model, "builders", new={nengo.Ensemble: ens_build}):
if not use_arguments:
with patch.object(model, "probe_builders", new=probe_builders):
model.build(network)
else:
with patch.object(model, "probe_builders", new={}):
model.build(network, extra_probe_builders=probe_builders)
# Assert the probe functions were built
assert p_a in model.seeds
assert p_n in model.seeds
assert build_ens_probe.call_count == 1
assert build_neurons_probe.call_count == 1
def test_standard(self, use_arguments, with_slice):
# Create test network
with nengo.Network() as network:
a = nengo.Ensemble(100, 2)
if not with_slice:
p_a = nengo.Probe(a)
else:
p_a = nengo.Probe(a[0])
p_n = nengo.Probe(a.neurons)
# Create a model
model = Model()
# Dummy neurons builder
ens_build = mock.Mock(name="ensemble builder")
# Define two different probe build functions
def build_ens_probe_fn(model, probe):
assert ens_build.called
assert model is model
assert probe is p_a
build_ens_probe = mock.Mock(wraps=build_ens_probe_fn)
def build_neurons_probe_fn(model, probe):
assert ens_build.called
assert model is model
assert probe is p_n
build_neurons_probe = mock.Mock(wraps=build_neurons_probe_fn)
# Build the model
probe_builders = {nengo.Ensemble: build_ens_probe,
nengo.ensemble.Neurons: build_neurons_probe}
with patch.object(model, "builders", new={nengo.Ensemble: ens_build}):
if not use_arguments:
with patch.object(model, "probe_builders", new=probe_builders):
model.build(network)
else:
with patch.object(model, "probe_builders", new={}):
model.build(network, extra_probe_builders=probe_builders)
# Assert the probe functions were built
assert p_a in model.seeds
assert p_n in model.seeds
assert build_ens_probe.call_count == 1
assert build_neurons_probe.call_count == 1
def test_make_connections(self, use_registered_dicts, seed):
"""Test that building connections adds a new signal to the model."""
# TODO Test that the connection is fully built
model = Model()
class A(object):
pass
class B(object):
pass
a = A()
b = B()
# Create a connection from a to b
connection = mock.Mock()
connection.seed = seed
connection.pre_obj = a
connection.post_obj = b
# Create getter methods
source = ObjectPort(mock.Mock(), None)
sink = ObjectPort(mock.Mock(), None)
def source_getter_fn(m, c):
assert m is model
assert c is connection
return spec(source)
source_getter = mock.Mock(wraps=source_getter_fn)
def sink_getter_fn(m, c):
assert m is model
assert c is connection
return spec(sink)
sink_getter = mock.Mock(wraps=sink_getter_fn)
# Create a method to build the connection
built_connection = mock.Mock(name="built connection")
def connection_builder_fn(m, c):
assert m is model
assert c is connection
return built_connection
connection_builder_a = mock.Mock(wraps=connection_builder_fn)
connection_builder_b = mock.Mock(wraps=connection_builder_fn)
# Create a mock network
network = mock.Mock()
network.seed = None
network.connections = [connection]
network.ensembles = []
network.nodes = []
network.networks = []
network.probes = []
if use_registered_dicts:
# Patch the getters, add a null builder
with patch.object(model, "source_getters", {A: source_getter}), \
patch.object(model, "sink_getters", {B: sink_getter}), \
patch.object(model, "connection_parameter_builders",
{A: connection_builder_a,
B: connection_builder_b}):
# Build the network
model.build(network)
else:
model.build(network,
extra_source_getters={A: source_getter},
extra_sink_getters={B: sink_getter},
extra_connection_parameter_builders={
A: connection_builder_a,
B: connection_builder_b,
})
# Check that seeds were provided
if seed is not None:
assert model.seeds[connection] == seed
else:
assert model.seeds[connection] is not None
# Assert the getters were called
assert source_getter.call_count == 1
assert sink_getter.call_count == 1
# Assert that the connection parameter builder was called
assert connection_builder_a.call_count == 1
assert connection_builder_b.call_count == 0
# Assert that the parameters were saved
assert model.params[connection] is built_connection
# Assert that the signal exists
signal = model.connections_signals[connection]
assert signal.source is source
assert signal.sinks == [sink]
def test_standard(self, use_make_connection):
"""Test building a single connection, ensure that all appropriate
methods are called and that the signal is added to the connection map.
"""
class A(object):
pass
# Create the connection (as a mock)
connection_source = A()
connection_sink = A()
connection = mock.Mock()
connection.pre_obj = connection_source
connection.post_obj = connection_sink
# Create the Model which we'll build with
m = Model()
# Modify the Model so that we can interpret calls to the connection map
m.connection_map = mock.Mock(name="ConnectionMap")
m.connection_map.insert_and_stack_interposers = mock.Mock(
return_value=([], m.connection_map) # NOP
)
source = mock.Mock(name="Source Object")
source_port = mock.Mock(name="Source Port")
sink = mock.Mock(name="Sink Object")
sink_port = mock.Mock(name="Sink Port")
# Add some build methods
def source_getter(model, conn):
assert model is m
assert conn is connection
return spec(ObjectPort(source, source_port))
def sink_getter(model, conn):
assert model is m
assert conn is connection
return spec(ObjectPort(sink, sink_port))
source_getters = {A: mock.Mock(side_effect=source_getter)}
sink_getters = {A: mock.Mock(side_effect=sink_getter)}
transmission_parameters = mock.Mock(name="Transmission Params")
def transmission_builder(model, conn):
assert model is m
assert conn is connection
return transmission_parameters
reception_parameters = mock.Mock(name="Reception Params")
def reception_builder(model, conn):
assert model is m
assert conn is connection
return reception_parameters
transmission_parameter_builders = {
A: mock.Mock(side_effect=transmission_builder)
}
reception_parameter_builders = {
A: mock.Mock(side_effect=reception_builder)
}
# Make the connection
if use_make_connection:
# Set an RNG to build with
m.rng = np.random
# Set the builders
m._source_getters = source_getters
m._sink_getters = sink_getters
m._transmission_parameter_builders = \
transmission_parameter_builders
m._reception_parameter_builders = reception_parameter_builders
# Build the connection directly
m.make_connection(connection)
else:
# Embed the connection in a mock Nengo network and build that
# instead.
network = mock.Mock()
network.seed = None
network.connections = [connection]
network.ensembles = []
network.nodes = []
network.networks = []
network.probes = []
# Build this (having overridden the builders)
with mock.patch.object(m, "source_getters", source_getters), \
mock.patch.object(m, "sink_getters", sink_getters), \
mock.patch.object(m, "transmission_parameter_builders",
transmission_parameter_builders), \
mock.patch.object(m, "reception_parameter_builders",
reception_parameter_builders):
m.build(network)
# Assert the connection map received an appropriate call
m.connection_map.add_connection.assert_called_once_with(
source, source_port, SignalParameters(),
transmission_parameters, sink, sink_port, reception_parameters
)
def test_standard(self, use_make_connection):
"""Test building a single connection, ensure that all appropriate
methods are called and that the signal is added to the connection map.
"""
class A(object):
pass
# Create the connection (as a mock)
connection_source = A()
connection_sink = A()
connection = mock.Mock()
connection.pre_obj = connection_source
connection.post_obj = connection_sink
# Create the Model which we'll build with
m = Model()
# Modify the Model so that we can interpret calls to the connection map
m.connection_map = mock.Mock(name="ConnectionMap")
m.connection_map.insert_and_stack_interposers = mock.Mock(
return_value=([], m.connection_map) # NOP
)
source = mock.Mock(name="Source Object")
source_port = mock.Mock(name="Source Port")
sink = mock.Mock(name="Sink Object")
sink_port = mock.Mock(name="Sink Port")
# Add some build methods
def source_getter(model, conn):
assert model is m
assert conn is connection
return spec(ObjectPort(source, source_port))
def sink_getter(model, conn):
assert model is m
assert conn is connection
return spec(ObjectPort(sink, sink_port))
source_getters = {A: mock.Mock(side_effect=source_getter)}
sink_getters = {A: mock.Mock(side_effect=sink_getter)}
transmission_parameters = mock.Mock(name="Transmission Params")
def transmission_builder(model, conn):
assert model is m
assert conn is connection
return transmission_parameters
reception_parameters = mock.Mock(name="Reception Params")
def reception_builder(model, conn):
assert model is m
assert conn is connection
return reception_parameters
transmission_parameter_builders = {
A: mock.Mock(side_effect=transmission_builder)
}
reception_parameter_builders = {
A: mock.Mock(side_effect=reception_builder)
}
# Make the connection
if use_make_connection:
# Set an RNG to build with
m.rng = np.random
# Set the builders
m._source_getters = source_getters
m._sink_getters = sink_getters
m._transmission_parameter_builders = \
transmission_parameter_builders
m._reception_parameter_builders = reception_parameter_builders
# Build the connection directly
m.make_connection(connection)
else:
# Embed the connection in a mock Nengo network and build that
# instead.
network = mock.Mock()
network.seed = None
network.connections = [connection]
network.ensembles = []
network.nodes = []
network.networks = []
network.probes = []
# Build this (having overridden the builders)
with mock.patch.object(m, "source_getters", source_getters), \
mock.patch.object(m, "sink_getters", sink_getters), \
mock.patch.object(m, "transmission_parameter_builders",
transmission_parameter_builders), \
mock.patch.object(m, "reception_parameter_builders",
reception_parameter_builders):
m.build(network)
# Assert the connection map received an appropriate call
m.connection_map.add_connection.assert_called_once_with(
source, source_port, SignalParameters(), transmission_parameters,
sink, sink_port, reception_parameters)
