def test_nodespace_removal(fixed_nodenet):
res, uid = micropsi.add_nodespace(fixed_nodenet, [100, 100], nodespace=None, name="testspace")
res, n1_uid = micropsi.add_node(fixed_nodenet, 'Register', [100, 100], nodespace=uid, name="sub1")
res, n2_uid = micropsi.add_node(fixed_nodenet, 'Register', [100, 200], nodespace=uid, name="sub2")
micropsi.add_link(fixed_nodenet, n1_uid, 'gen', n2_uid, 'gen', weight=1, certainty=1)
res, sub_uid = micropsi.add_nodespace(fixed_nodenet, [100, 100], nodespace=uid, name="subsubspace")
micropsi.delete_nodespace(fixed_nodenet, uid)
# assert that the nodespace is gone
assert not micropsi.nodenets[fixed_nodenet].is_nodespace(uid)
assert uid not in micropsi.nodenets[fixed_nodenet].data['nodespaces']
# assert that the nodes it contained are gone
assert not micropsi.nodenets[fixed_nodenet].is_node(n1_uid)
assert n1_uid not in micropsi.nodenets[fixed_nodenet].data['nodes']
assert not micropsi.nodenets[fixed_nodenet].is_node(n2_uid)
assert n2_uid not in micropsi.nodenets[fixed_nodenet].data['nodes']
# assert that the links between the deleted nodes are gone
linked_node_uids = []
for uid, link in micropsi.nodenets[fixed_nodenet].data['links'].items():
linked_node_uids.append(link['source_node_uid'])
linked_node_uids.append(link['target_node_uid'])
assert n1_uid not in linked_node_uids
assert n2_uid not in linked_node_uids
# assert that sub-nodespaces are gone as well
assert not micropsi.nodenets[fixed_nodenet].is_nodespace(sub_uid)
assert sub_uid not in micropsi.nodenets[fixed_nodenet].data['nodespaces']
def test_node_parameters_none(fixed_nodenet):
nodenet = micropsi.nodenets[fixed_nodenet]
micropsi.add_node(fixed_nodenet, 'Trigger', [30, 30], uid='testtrigger', name='test')
node = nodenet.netapi.get_node('testtrigger')
micropsi.set_node_parameters(fixed_nodenet, node.uid, {'response': '', 'timeout': 0})
assert node.get_parameter('response') is None
assert node.get_parameter('timeout') == 0
def test_nodespace_removal(fixed_nodenet):
res, uid = micropsi.add_nodespace(fixed_nodenet, [100, 100],
nodespace=None,
name="testspace")
res, n1_uid = micropsi.add_node(fixed_nodenet,
'Register', [100, 100],
nodespace=uid,
name="sub1")
res, n2_uid = micropsi.add_node(fixed_nodenet,
'Register', [100, 200],
nodespace=uid,
name="sub2")
micropsi.add_link(fixed_nodenet,
n1_uid,
'gen',
n2_uid,
'gen',
weight=1,
certainty=1)
res, sub_uid = micropsi.add_nodespace(fixed_nodenet, [100, 100],
nodespace=uid,
name="subsubspace")
micropsi.delete_nodespace(fixed_nodenet, uid)
# assert that the nodespace is gone
assert not micropsi.nodenets[fixed_nodenet].is_nodespace(uid)
assert uid not in micropsi.nodenets[fixed_nodenet].get_data()['nodespaces']
# assert that the nodes it contained are gone
assert not micropsi.nodenets[fixed_nodenet].is_node(n1_uid)
assert n1_uid not in micropsi.nodenets[fixed_nodenet].get_data()['nodes']
assert not micropsi.nodenets[fixed_nodenet].is_node(n2_uid)
assert n2_uid not in micropsi.nodenets[fixed_nodenet].get_data()['nodes']
# assert that sub-nodespaces are gone as well
assert not micropsi.nodenets[fixed_nodenet].is_nodespace(sub_uid)
assert sub_uid not in micropsi.nodenets[fixed_nodenet].get_data(
)['nodespaces']
def test_gate_defaults_change_with_nodetype(fixed_nodenet, resourcepath):
# gate_parameters are a property of the nodetype, and should change with
# the nodetype definition if not explicitly overwritten for a given node
from os import path
with open(path.join(resourcepath, 'nodetypes.json'), 'w') as fp:
fp.write('{"Testnode": {\
"name": "Testnode",\
"slottypes": ["gen", "foo", "bar"],\
"nodefunction_name": "testnodefunc",\
"gatetypes": ["gen", "foo", "bar"],\
"symbol": "t",\
"gate_defaults":{\
"foo": {\
"amplification": 13\
}\
}}}')
with open(path.join(resourcepath, 'nodefunctions.py'), 'w') as fp:
fp.write("def testnodefunc(netapi, node=None, **prams):\r\n return 17")
micropsi.reload_native_modules(fixed_nodenet)
micropsi.add_node(fixed_nodenet, "Testnode", [10, 10], uid="Testnode", name="Testnode")
with open(path.join(resourcepath, 'nodetypes.json'), 'w') as fp:
fp.write('{"Testnode": {\
"name": "Testnode",\
"slottypes": ["gen", "foo", "bar"],\
"nodefunction_name": "testnodefunc",\
"gatetypes": ["gen", "foo", "bar"],\
"symbol": "t",\
"gate_defaults":{\
"foo": {\
"amplification": 5\
}\
}}}')
micropsi.reload_native_modules(fixed_nodenet)
params = micropsi.nodenets[fixed_nodenet].get_node("Testnode").get_gate_parameters()
assert params["foo"]["amplification"] == 5
def test_non_standard_gate_defaults(fixed_nodenet):
nodenet = micropsi.nodenets[fixed_nodenet]
micropsi.add_node(fixed_nodenet, 'Trigger', [30, 30], uid='testtrigger', name='test')
node = nodenet.netapi.get_node('testtrigger')
params = node.get_gate_parameters()
genparams = params['gen']
genparams['maximum'] = 1
micropsi.set_gate_parameters(nodenet.uid, node.uid, 'gen', genparams)
assert node.clone_non_default_gate_parameters()['gen']['maximum'] == 1
def prepare_nodenet(test_nodenet):
res, node_a_uid = micropsi.add_node(test_nodenet, "Pipe", (200, 250), None, state=None, name="A")
res, node_b_uid = micropsi.add_node(test_nodenet, "Pipe", (500, 350), None, state=None, name="B")
res, node_c_uid = micropsi.add_node(test_nodenet, "Pipe", (300, 150), None, state=None, name="C")
res, node_s_uid = micropsi.add_node(test_nodenet, "Sensor", (200, 450), None, state=None, name="S")
return {
'a': node_a_uid,
'b': node_b_uid,
'c': node_c_uid,
's': node_s_uid
}
def test_nodenet(request):
global nn_uid
nodenets = micropsi.get_available_nodenets("Pytest User") or {}
if nn_uid not in nodenets:
success, nn_uid = micropsi.new_nodenet("Testnet", worldadapter="Default", owner="Pytest User", world_uid=world_uid, uid='Testnet')
micropsi.add_node(nn_uid, 'Concept', [10, 10], uid='N1', name='N1')
micropsi.add_link(nn_uid, 'N1', 'gen', 'N1', 'gen')
micropsi.save_nodenet(nn_uid)
def fin():
micropsi.revert_nodenet(nn_uid)
request.addfinalizer(fin)
return nn_uid
def test_gate_defaults_change_with_nodetype(fixed_nodenet, resourcepath, nodetype_def, nodefunc_def):
# gate_parameters are a property of the nodetype, and should change with
# the nodetype definition if not explicitly overwritten for a given node
with open(nodetype_def, 'w') as fp:
fp.write('{"Testnode": {\
"name": "Testnode",\
"slottypes": ["gen", "foo", "bar"],\
"nodefunction_name": "testnodefunc",\
"gatetypes": ["gen", "foo", "bar"],\
"symbol": "t",\
"gate_defaults":{\
"foo": {\
"amplification": 13\
}\
}}}')
with open(nodefunc_def, 'w') as fp:
fp.write("def testnodefunc(netapi, node=None, **prams):\r\n return 17")
micropsi.reload_native_modules()
res, uid = micropsi.add_node(fixed_nodenet, "Testnode", [10, 10], name="Testnode")
with open(nodetype_def, 'w') as fp:
fp.write('{"Testnode": {\
"name": "Testnode",\
"slottypes": ["gen", "foo", "bar"],\
"nodefunction_name": "testnodefunc",\
"gatetypes": ["gen", "foo", "bar"],\
"symbol": "t",\
"gate_defaults":{\
"foo": {\
"amplification": 5\
}\
}}}')
micropsi.reload_native_modules()
params = micropsi.nodenets[fixed_nodenet].get_node(uid).get_gate_parameters()
assert params["foo"]["amplification"] == 5
def test_remove_and_reload_native_module(fixed_nodenet, resourcepath):
import os
nodetype_file = os.path.join(resourcepath, 'Test', 'nodetypes.json')
nodefunc_file = os.path.join(resourcepath, 'Test', 'nodefunctions.py')
with open(nodetype_file, 'w') as fp:
fp.write('{"Testnode": {\
"name": "Testnode",\
"slottypes": ["gen", "foo", "bar"],\
"nodefunction_name": "testnodefunc",\
"gatetypes": ["gen", "foo", "bar"],\
"symbol": "t",\
"gate_defaults":{\
"foo": {\
"amplification": 13\
}\
}}}')
with open(nodefunc_file, 'w') as fp:
fp.write("def testnodefunc(netapi, node=None, **prams):\r\n return 17")
micropsi.reload_native_modules()
res, uid = micropsi.add_node(fixed_nodenet, "Testnode", [10, 10, 10], name="Testnode")
os.remove(nodetype_file)
os.remove(nodefunc_file)
micropsi.reload_native_modules()
assert 'Testnode' not in micropsi.get_available_native_module_types(fixed_nodenet)
def test_node_parameters_from_persistence(fixed_nodenet, resourcepath):
import os
nodetype_file = os.path.join(resourcepath, 'Test', 'nodetypes.json')
nodefunc_file = os.path.join(resourcepath, 'Test', 'nodefunctions.py')
with open(nodetype_file, 'w') as fp:
fp.write('{"Testnode": {\
"name": "Testnode",\
"slottypes": ["gen", "foo", "bar"],\
"gatetypes": ["gen", "foo", "bar"],\
"nodefunction_name": "testnodefunc",\
"parameters": ["testparam"],\
"parameter_defaults": {\
"testparam": 13\
}\
}}')
with open(nodefunc_file, 'w') as fp:
fp.write("def testnodefunc(netapi, node=None, **prams):\r\n return 17")
micropsi.reload_native_modules()
res, uid = micropsi.add_node(fixed_nodenet, "Testnode", [10, 10, 10], name="Test")
node = micropsi.nodenets[fixed_nodenet].get_node(uid)
node.set_parameter("testparam", 42)
micropsi.save_nodenet(fixed_nodenet)
micropsi.revert_nodenet(fixed_nodenet)
node = micropsi.nodenets[fixed_nodenet].get_node(uid)
assert node.get_parameter("testparam") == 42
def test_node_parameters_none_resets_to_default(fixed_nodenet):
nodenet = micropsi.nodenets[fixed_nodenet]
res, uid = micropsi.add_node(fixed_nodenet, 'Pipe', [30, 30], name='test')
node = nodenet.netapi.get_node(uid)
micropsi.set_node_parameters(fixed_nodenet, node.uid, {'expectation': '', 'wait': 0})
assert node.get_parameter('expectation') == 1
assert node.get_parameter('wait') == 0
def test_node_parameters(fixed_nodenet, resourcepath):
import os
nodetype_file = os.path.join(resourcepath, 'Test', 'nodetypes.json')
nodefunc_file = os.path.join(resourcepath, 'Test', 'nodefunctions.py')
with open(nodetype_file, 'w') as fp:
fp.write('{"Testnode": {\
"name": "Testnode",\
"slottypes": ["gen", "foo", "bar"],\
"gatetypes": ["gen", "foo", "bar"],\
"nodefunction_name": "testnodefunc",\
"parameters": ["linktype", "threshold", "protocol_mode"],\
"parameter_values": {\
"linktype": ["catexp", "subsur"],\
"protocol_mode": ["all_active", "most_active_one"]\
},\
"parameter_defaults": {\
"linktype": "catexp",\
"protocol_mode": "all_active"\
}}\
}')
with open(nodefunc_file, 'w') as fp:
fp.write("def testnodefunc(netapi, node=None, **prams):\r\n return 17")
assert micropsi.reload_native_modules()
res, uid = micropsi.add_node(fixed_nodenet, "Testnode", [10, 10], name="Test", parameters={"linktype": "catexp", "threshold": "", "protocol_mode": "all_active"})
# nativemodule = micropsi.nodenets[fixed_nodenet].get_node(uid)
assert micropsi.save_nodenet(fixed_nodenet)
def node(request, test_nodenet):
"""
Fixture: A Pipe node with a genloop
"""
res, uid = micropsi.add_node(test_nodenet, 'Pipe', [10, 10, 10], name='N1')
micropsi.add_link(test_nodenet, uid, 'gen', uid, 'gen')
return uid
def test_nodespace_removal(fixed_nodenet):
res, uid = micropsi.add_node(fixed_nodenet, 'Nodespace', [100,100], nodespace="Root", name="testspace", uid='ns1')
res, n1_uid = micropsi.add_node(fixed_nodenet, 'Register', [100,100], nodespace=uid, name="sub1", uid='sub1')
res, n2_uid = micropsi.add_node(fixed_nodenet, 'Register', [100,200], nodespace=uid, name="sub2", uid='sub2')
micropsi.add_link(fixed_nodenet, n1_uid, 'gen', n2_uid, 'gen', weight=1, certainty=1)
res, sub_uid = micropsi.add_node(fixed_nodenet, 'Nodespace', [100,100], nodespace=uid, name="subsubspace", uid='ns2')
micropsi.delete_node(fixed_nodenet, uid)
assert not micropsi.nodenets[fixed_nodenet].is_nodespace(uid)
assert uid not in micropsi.nodenets[fixed_nodenet].data['nodespaces']
assert not micropsi.nodenets[fixed_nodenet].is_node(n1_uid)
assert n1_uid not in micropsi.nodenets[fixed_nodenet].data['nodes']
assert not micropsi.nodenets[fixed_nodenet].is_node(n2_uid)
assert n2_uid not in micropsi.nodenets[fixed_nodenet].data['nodes']
assert 'sub1-sub2' not in micropsi.nodenets[fixed_nodenet].data['links']
assert not micropsi.nodenets[fixed_nodenet].is_nodespace(sub_uid)
assert sub_uid not in micropsi.nodenets[fixed_nodenet].data['nodespaces']
def test_node_parameters(fixed_nodenet, resourcepath):
import os
nodetype_file = os.path.join(resourcepath, 'Test', 'nodetypes.json')
nodefunc_file = os.path.join(resourcepath, 'Test', 'nodefunctions.py')
with open(nodetype_file, 'w') as fp:
fp.write('{"Testnode": {\
"name": "Testnode",\
"slottypes": ["gen", "foo", "bar"],\
"gatetypes": ["gen", "foo", "bar"],\
"nodefunction_name": "testnodefunc",\
"parameters": ["linktype", "threshold", "protocol_mode"],\
"parameter_values": {\
"linktype": ["catexp", "subsur"],\
"protocol_mode": ["all_active", "most_active_one"]\
},\
"parameter_defaults": {\
"linktype": "catexp",\
"protocol_mode": "all_active"\
}}\
}')
with open(nodefunc_file, 'w') as fp:
fp.write(
"def testnodefunc(netapi, node=None, **prams):\r\n return 17")
assert micropsi.reload_native_modules()
res, uid = micropsi.add_node(fixed_nodenet,
"Testnode", [10, 10],
name="Test",
parameters={
"linktype": "catexp",
"threshold": "",
"protocol_mode": "all_active"
})
# nativemodule = micropsi.nodenets[fixed_nodenet].get_node(uid)
assert micropsi.save_nodenet(fixed_nodenet)
def test_user_prompt(fixed_nodenet, resourcepath):
import os
nodetype_file = os.path.join(resourcepath, 'Test', 'nodetypes.json')
nodefunc_file = os.path.join(resourcepath, 'Test', 'nodefunctions.py')
with open(nodetype_file, 'w') as fp:
fp.write('{"Testnode": {\
"name": "Testnode",\
"slottypes": ["gen", "foo", "bar"],\
"gatetypes": ["gen", "foo", "bar"],\
"nodefunction_name": "testnodefunc",\
"parameters": ["testparam"],\
"parameter_defaults": {\
"testparam": 13\
}\
}}')
with open(nodefunc_file, 'w') as fp:
fp.write(
"def testnodefunc(netapi, node=None, **prams):\r\n return 17")
micropsi.reload_native_modules()
res, uid = micropsi.add_node(fixed_nodenet,
"Testnode", [10, 10],
name="Test")
nativemodule = micropsi.nodenets[fixed_nodenet].get_node(uid)
options = [{
'key': 'foo_parameter',
'label': 'Please give value for "foo"',
'values': [23, 42]
}]
micropsi.nodenets[fixed_nodenet].netapi.ask_user_for_parameter(
nativemodule, "foobar", options)
result, data = micropsi.get_calculation_state(fixed_nodenet, nodenet={})
assert 'user_prompt' in data
assert data['user_prompt']['msg'] == 'foobar'
assert data['user_prompt']['node']['uid'] == uid
assert data['user_prompt']['options'] == options
# response
micropsi.user_prompt_response(fixed_nodenet, uid, {'foo_parameter': 42},
True)
assert micropsi.nodenets[fixed_nodenet].get_node(uid).get_parameter(
'foo_parameter') == 42
assert micropsi.nodenets[fixed_nodenet].is_active
from micropsi_core.nodenet import nodefunctions
tmp = nodefunctions.concept
nodefunc = mock.Mock()
nodefunctions.concept = nodefunc
micropsi.nodenets[fixed_nodenet].step()
foo = micropsi.nodenets[fixed_nodenet].get_node('n0001').clone_parameters()
foo.update({'foo_parameter': 42})
assert nodefunc.called_with(
micropsi.nodenets[fixed_nodenet].netapi,
micropsi.nodenets[fixed_nodenet].get_node('n0001'), foo)
micropsi.nodenets[fixed_nodenet].get_node('n0001').clear_parameter(
'foo_parameter')
assert micropsi.nodenets[fixed_nodenet].get_node('n0001').get_parameter(
'foo_parameter') is None
nodefunctions.concept = tmp
def test_nodespace_removal(fixed_nodenet):
res, uid = micropsi.add_nodespace(fixed_nodenet, [100, 100], nodespace=None, name="testspace")
res, n1_uid = micropsi.add_node(fixed_nodenet, 'Register', [100, 100], nodespace=uid, name="sub1")
res, n2_uid = micropsi.add_node(fixed_nodenet, 'Register', [100, 200], nodespace=uid, name="sub2")
micropsi.add_link(fixed_nodenet, n1_uid, 'gen', n2_uid, 'gen', weight=1, certainty=1)
res, sub_uid = micropsi.add_nodespace(fixed_nodenet, [100, 100], nodespace=uid, name="subsubspace")
micropsi.delete_nodespace(fixed_nodenet, uid)
# assert that the nodespace is gone
assert not micropsi.nodenets[fixed_nodenet].is_nodespace(uid)
assert uid not in micropsi.nodenets[fixed_nodenet].get_data()['nodespaces']
# assert that the nodes it contained are gone
assert not micropsi.nodenets[fixed_nodenet].is_node(n1_uid)
assert n1_uid not in micropsi.nodenets[fixed_nodenet].get_data()['nodes']
assert not micropsi.nodenets[fixed_nodenet].is_node(n2_uid)
assert n2_uid not in micropsi.nodenets[fixed_nodenet].get_data()['nodes']
# assert that sub-nodespaces are gone as well
assert not micropsi.nodenets[fixed_nodenet].is_nodespace(sub_uid)
assert sub_uid not in micropsi.nodenets[fixed_nodenet].get_data()['nodespaces']
def test_non_standard_gate_defaults(fixed_nodenet):
nodenet = micropsi.nodenets[fixed_nodenet]
res, uid = micropsi.add_node(fixed_nodenet, 'Register', [30, 30], name='test')
node = nodenet.netapi.get_node(uid)
genparams = {'maximum': 0.5}
micropsi.set_gate_parameters(nodenet.uid, node.uid, 'gen', genparams)
assert node.clone_non_default_gate_parameters()['gen']['maximum'] == 0.5
assert node.data['gate_parameters'] == {'gen': {'maximum': 0.5}}
assert nodenet.data['nodes'][uid]['gate_parameters'] == {'gen': {'maximum': 0.5}}
data = micropsi.get_nodenet_data(fixed_nodenet, None, step=-1, include_links=False)
assert data['nodes'][uid]['gate_parameters'] == {'gen': {'maximum': 0.5}}
def test_nodespace_removal(fixed_nodenet):
res, uid = micropsi.add_nodespace(fixed_nodenet, [100, 100],
nodespace=None,
name="testspace")
res, n1_uid = micropsi.add_node(fixed_nodenet,
'Register', [100, 100],
nodespace=uid,
name="sub1")
res, n2_uid = micropsi.add_node(fixed_nodenet,
'Register', [100, 200],
nodespace=uid,
name="sub2")
micropsi.add_link(fixed_nodenet,
n1_uid,
'gen',
n2_uid,
'gen',
weight=1,
certainty=1)
res, sub_uid = micropsi.add_nodespace(fixed_nodenet, [100, 100],
nodespace=uid,
name="subsubspace")
micropsi.delete_nodespace(fixed_nodenet, uid)
# assert that the nodespace is gone
assert not micropsi.nodenets[fixed_nodenet].is_nodespace(uid)
assert uid not in micropsi.nodenets[fixed_nodenet].data['nodespaces']
# assert that the nodes it contained are gone
assert not micropsi.nodenets[fixed_nodenet].is_node(n1_uid)
assert n1_uid not in micropsi.nodenets[fixed_nodenet].data['nodes']
assert not micropsi.nodenets[fixed_nodenet].is_node(n2_uid)
assert n2_uid not in micropsi.nodenets[fixed_nodenet].data['nodes']
# assert that the links between the deleted nodes are gone
linked_node_uids = []
for uid, link in micropsi.nodenets[fixed_nodenet].data['links'].items():
linked_node_uids.append(link['source_node_uid'])
linked_node_uids.append(link['target_node_uid'])
assert n1_uid not in linked_node_uids
assert n2_uid not in linked_node_uids
# assert that sub-nodespaces are gone as well
assert not micropsi.nodenets[fixed_nodenet].is_nodespace(sub_uid)
assert sub_uid not in micropsi.nodenets[fixed_nodenet].data['nodespaces']
def test_modulators_sensor_actor_connection(test_nodenet, test_world):
nodenet = micropsi.get_nodenet(test_nodenet)
micropsi.set_nodenet_properties(test_nodenet, worldadapter="Braitenberg", world_uid=test_world)
res, s1_id = micropsi.add_node(test_nodenet, "Sensor", [10, 10], None, name="brightness_l", parameters={'datasource': 'brightness_l'})
res, s2_id = micropsi.add_node(test_nodenet, "Sensor", [20, 20], None, name="emo_activation", parameters={'datasource': 'emo_activation'})
res, a1_id = micropsi.add_node(test_nodenet, "Actor", [30, 30], None, name="engine_l", parameters={'datatarget': 'engine_l'})
res, a2_id = micropsi.add_node(test_nodenet, "Actor", [40, 40], None, name="base_importance_of_intention", parameters={'datatarget': 'base_importance_of_intention'})
res, r1_id = micropsi.add_node(test_nodenet, "Register", [10, 30], None, name="r1")
res, r2_id = micropsi.add_node(test_nodenet, "Register", [10, 30], None, name="r2")
s1 = nodenet.get_node(s1_id)
s2 = nodenet.get_node(s2_id)
r1 = nodenet.get_node(r1_id)
r2 = nodenet.get_node(r2_id)
s2.set_gate_parameter('gen', 'maximum', 999)
micropsi.add_link(test_nodenet, r1_id, 'gen', a1_id, 'gen')
micropsi.add_link(test_nodenet, r2_id, 'gen', a2_id, 'gen')
r1.activation = 0.3
r2.activation = 0.7
emo_val = nodenet.get_modulator("emo_activation")
# patch reset method, to check if datatarget was written
def nothing():
pass
nodenet.worldadapter_instance.reset_datatargets = nothing
nodenet.step()
assert round(nodenet.worldadapter_instance.datatargets['engine_l'], 3) == 0.3
assert round(s1.activation, 3) == round(nodenet.worldadapter_instance.get_datasource_value('brightness_l'), 3)
assert round(s2.activation, 3) == round(emo_val, 3)
assert round(nodenet.get_modulator('base_importance_of_intention'), 3) == 0.7
assert round(nodenet.worldadapter_instance.datatargets['engine_l'], 3) == 0.3
emo_val = nodenet.get_modulator("emo_activation")
nodenet.step()
assert round(s2.activation, 3) == round(emo_val, 3)
def test_remove_and_reload_native_module(fixed_nodenet, resourcepath):
from os import path, remove
with open(path.join(resourcepath, 'nodetypes.json'), 'w') as fp:
fp.write('{"Testnode": {\
"name": "Testnode",\
"slottypes": ["gen", "foo", "bar"],\
"nodefunction_name": "testnodefunc",\
"gatetypes": ["gen", "foo", "bar"],\
"symbol": "t",\
"gate_defaults":{\
"foo": {\
"amplification": 13\
}\
}}}')
with open(path.join(resourcepath, 'nodefunctions.py'), 'w') as fp:
fp.write("def testnodefunc(netapi, node=None, **prams):\r\n return 17")
micropsi.reload_native_modules(fixed_nodenet)
micropsi.add_node(fixed_nodenet, "Testnode", [10, 10], uid="Testnode", name="Testnode")
remove(path.join(resourcepath, 'nodetypes.json'))
remove(path.join(resourcepath, 'nodefunctions.py'))
micropsi.reload_native_modules(fixed_nodenet)
assert micropsi.get_available_native_module_types(fixed_nodenet) == {}
def test_clone_nodes_to_new_nodespace(fixed_nodenet):
nodenet = micropsi.get_nodenet(fixed_nodenet)
micropsi.add_node(fixed_nodenet, 'Nodespace', [100, 100], nodespace="Root", name="testspace", uid='ns1')
success, result = micropsi.clone_nodes(fixed_nodenet, ['A1', 'A2'], 'internal', nodespace='ns1')
assert success
assert len(result['nodes']) == 2
assert len(result['links']) == 1
if result['nodes'][0]['name'] == 'A1_copy':
a1_copy = result['nodes'][0]
a2_copy = result['nodes'][1]
else:
a1_copy = result['nodes'][1]
a2_copy = result['nodes'][0]
a1_copy = nodenet.get_node(a1_copy['uid'])
a2_copy = nodenet.get_node(a2_copy['uid'])
assert a1_copy.parent_nodespace == 'ns1'
assert a2_copy.parent_nodespace == 'ns1'
def test_user_prompt(fixed_nodenet, resourcepath):
import os
nodetype_file = os.path.join(resourcepath, 'Test', 'nodetypes.json')
nodefunc_file = os.path.join(resourcepath, 'Test', 'nodefunctions.py')
with open(nodetype_file, 'w') as fp:
fp.write('{"Testnode": {\
"name": "Testnode",\
"slottypes": ["gen", "foo", "bar"],\
"gatetypes": ["gen", "foo", "bar"],\
"nodefunction_name": "testnodefunc",\
"parameters": ["testparam"],\
"parameter_defaults": {\
"testparam": 13\
}\
}}')
with open(nodefunc_file, 'w') as fp:
fp.write("def testnodefunc(netapi, node=None, **prams):\r\n return 17")
micropsi.reload_native_modules()
res, uid = micropsi.add_node(fixed_nodenet, "Testnode", [10, 10], name="Test")
nativemodule = micropsi.nodenets[fixed_nodenet].get_node(uid)
options = [{'key': 'foo_parameter', 'label': 'Please give value for "foo"', 'values': [23, 42]}]
micropsi.nodenets[fixed_nodenet].netapi.ask_user_for_parameter(
nativemodule,
"foobar",
options
)
result, data = micropsi.get_calculation_state(fixed_nodenet, nodenet={})
assert 'user_prompt' in data
assert data['user_prompt']['msg'] == 'foobar'
assert data['user_prompt']['node']['uid'] == uid
assert data['user_prompt']['options'] == options
# response
micropsi.user_prompt_response(fixed_nodenet, uid, {'foo_parameter': 42}, True)
assert micropsi.nodenets[fixed_nodenet].get_node(uid).get_parameter('foo_parameter') == 42
assert micropsi.nodenets[fixed_nodenet].is_active
from micropsi_core.nodenet import nodefunctions
tmp = nodefunctions.concept
nodefunc = mock.Mock()
nodefunctions.concept = nodefunc
micropsi.nodenets[fixed_nodenet].step()
foo = micropsi.nodenets[fixed_nodenet].get_node('n0001').clone_parameters()
foo.update({'foo_parameter': 42})
assert nodefunc.called_with(micropsi.nodenets[fixed_nodenet].netapi, micropsi.nodenets[fixed_nodenet].get_node('n0001'), foo)
micropsi.nodenets[fixed_nodenet].get_node('n0001').clear_parameter('foo_parameter')
assert micropsi.nodenets[fixed_nodenet].get_node('n0001').get_parameter('foo_parameter') is None
nodefunctions.concept = tmp
def test_add_node(test_nodenet):
micropsi.load_nodenet(test_nodenet)
# make sure nodenet is empty
nodespace = micropsi.get_nodes(test_nodenet)
try:
for i in nodespace["nodes"]:
micropsi.delete_node(test_nodenet, i)
except:
pass
nodespace = micropsi.get_nodes(test_nodenet)
assert len(nodespace.get("nodes", [])) == 0
res, uid = micropsi.add_node(test_nodenet, "Pipe", [200, 250, 10], None, state=None, name="A")
nodespace = micropsi.get_nodes(test_nodenet)
assert len(nodespace["nodes"]) == 1
node1 = nodespace["nodes"][uid]
assert node1["name"] == "A"
assert node1["position"] == [200, 250, 10]
def test_add_node(test_nodenet):
micropsi.load_nodenet(test_nodenet)
# make sure nodenet is empty
nodespace = micropsi.get_nodenet_data(test_nodenet, None)
try:
for i in nodespace["nodes"]:
micropsi.delete_node(test_nodenet, i)
except:
pass
nodespace = micropsi.get_nodenet_data(test_nodenet, None)
assert len(nodespace.get("nodes", [])) == 0
assert len(nodespace.get("links", [])) == 0
res, uid = micropsi.add_node(test_nodenet, "Pipe", (200, 250), None, state=None, name="A")
nodespace = micropsi.get_nodenet_data(test_nodenet, None)
assert len(nodespace["nodes"]) == 1
node1 = nodespace["nodes"][uid]
assert node1["name"] == "A"
assert node1["position"] == (200, 250)
def test_node_parameter_defaults(fixed_nodenet, resourcepath, nodetype_def, nodefunc_def):
with open(nodetype_def, 'w') as fp:
fp.write('{"Testnode": {\
"name": "Testnode",\
"slottypes": ["gen", "foo", "bar"],\
"gatetypes": ["gen", "foo", "bar"],\
"nodefunction_name": "testnodefunc",\
"parameters": ["testparam"],\
"parameter_defaults": {\
"testparam": 13\
}\
}}')
with open(nodefunc_def, 'w') as fp:
fp.write("def testnodefunc(netapi, node=None, **prams):\r\n return 17")
micropsi.reload_native_modules()
data = micropsi.get_nodenet_data(fixed_nodenet, None)
res, uid = micropsi.add_node(fixed_nodenet, "Testnode", [10, 10], name="Test")
node = micropsi.nodenets[fixed_nodenet].get_node(uid)
assert node.get_parameter("testparam") == 13
def test_user_operation(test_nodenet, resourcepath):
import os
os.makedirs(os.path.join(resourcepath, 'operations', 'foobar'))
with open(os.path.join(resourcepath, 'operations', 'foobar', 'somoperation.py'), 'w+') as fp:
fp.write("""
def delete_nodes(netapi, selection):
for uid in selection:
netapi.delete_node(netapi.get_node(uid))
delete_nodes.selectioninfo = {
'nodetypes': [],
'mincount': 1,
'maxcount': -1
}""")
runtime.reload_code()
ops = runtime.get_available_operations()
assert ops['delete_nodes']['category'] == 'foobar'
res, uid = runtime.add_node(test_nodenet, "Neuron", [10, 10], None)
runtime.run_operation(test_nodenet, "delete_nodes", {}, [uid])
assert uid not in runtime.nodenets[test_nodenet].get_node_uids()
def test_user_operation(test_nodenet, resourcepath):
import os
os.makedirs(os.path.join(resourcepath, 'foobar'))
with open(os.path.join(resourcepath, 'foobar', 'operations.py'),
'w+') as fp:
fp.write("""
def delete_nodes(netapi, selection):
for uid in selection:
netapi.delete_node(netapi.get_node(uid))
delete_nodes.selectioninfo = {
'nodetypes': [],
'mincount': 1,
'maxcount': -1
}""")
runtime.reload_native_modules()
ops = runtime.get_available_operations()
assert ops['delete_nodes']['category'] == 'foobar'
res, uid = runtime.add_node(test_nodenet, "Register", [10, 10], None)
runtime.run_operation(test_nodenet, "delete_nodes", {}, [uid])
assert uid not in runtime.nodenets[test_nodenet].get_node_uids()
def test_add_node(test_nodenet):
micropsi.load_nodenet(test_nodenet)
# make sure nodenet is empty
nodespace = micropsi.get_nodespace(test_nodenet, "Root", -1)
try:
for i in nodespace["nodes"]:
micropsi.delete_node(test_nodenet, i)
except:
pass
nodespace = micropsi.get_nodespace(test_nodenet, "Root", -1)
assert len(nodespace.get("nodes", [])) == 0
assert len(nodespace.get("links", [])) == 0
micropsi.add_node(test_nodenet, "Concept", (200, 250), "Root", state=None, uid="node_a", name="A")
nodespace = micropsi.get_nodespace(test_nodenet, "Root", -1)
assert len(nodespace["nodes"]) == 1
node1 = nodespace["nodes"]["node_a"]
assert node1["name"] == "A"
assert node1["position"] == (200, 250)
micropsi.add_node(test_nodenet, "Concept", (500, 350), "Root", state=None, uid="node_b", name="B")
micropsi.add_node(test_nodenet, "Concept", (300, 150), "Root", state=None, uid="node_c", name="C")
micropsi.add_node(test_nodenet, "Sensor", (200, 450), "Root", state=None, uid="node_s", name="S")
def test_remove_and_reload_native_module(fixed_nodenet, resourcepath, nodetype_def, nodefunc_def):
from os import remove
with open(nodetype_def, 'w') as fp:
fp.write('{"Testnode": {\
"name": "Testnode",\
"slottypes": ["gen", "foo", "bar"],\
"nodefunction_name": "testnodefunc",\
"gatetypes": ["gen", "foo", "bar"],\
"symbol": "t",\
"gate_defaults":{\
"foo": {\
"amplification": 13\
}\
}}}')
with open(nodefunc_def, 'w') as fp:
fp.write("def testnodefunc(netapi, node=None, **prams):\r\n return 17")
micropsi.reload_native_modules()
res, uid = micropsi.add_node(fixed_nodenet, "Testnode", [10, 10], name="Testnode")
remove(nodetype_def)
remove(nodefunc_def)
micropsi.reload_native_modules()
assert micropsi.get_available_native_module_types(fixed_nodenet) == {}
def node(request, test_nodenet):
res, uid = micropsi.add_node(test_nodenet, 'Pipe', [10, 10], name='N1')
micropsi.add_link(test_nodenet, uid, 'gen', uid, 'gen')
return uid
def add_node(nodenet_uid, type, position, nodespace, state=None, name="", parameters={}):
return runtime.add_node(nodenet_uid, type, position, nodespace, state=state, name=name, parameters=parameters)
def node(request, test_nodenet):
res, uid = micropsi.add_node(test_nodenet, 'Pipe', [10, 10], name='N1')
micropsi.add_link(test_nodenet, uid, 'gen', uid, 'gen')
return uid
def test_modulators_sensor_actor_connection(test_nodenet, test_world):
nodenet = micropsi.get_nodenet(test_nodenet)
micropsi.set_nodenet_properties(test_nodenet,
worldadapter="Braitenberg",
world_uid=test_world)
res, s1_id = micropsi.add_node(test_nodenet,
"Sensor", [10, 10],
None,
name="brightness_l",
parameters={'datasource': 'brightness_l'})
res, s2_id = micropsi.add_node(test_nodenet,
"Sensor", [20, 20],
None,
name="emo_activation",
parameters={'datasource': 'emo_activation'})
res, a1_id = micropsi.add_node(test_nodenet,
"Actor", [30, 30],
None,
name="engine_l",
parameters={'datatarget': 'engine_l'})
res, a2_id = micropsi.add_node(
test_nodenet,
"Actor", [40, 40],
None,
name="base_importance_of_intention",
parameters={'datatarget': 'base_importance_of_intention'})
res, r1_id = micropsi.add_node(test_nodenet,
"Register", [10, 30],
None,
name="r1")
res, r2_id = micropsi.add_node(test_nodenet,
"Register", [10, 30],
None,
name="r2")
s1 = nodenet.get_node(s1_id)
s2 = nodenet.get_node(s2_id)
r1 = nodenet.get_node(r1_id)
r2 = nodenet.get_node(r2_id)
s2.set_gate_parameter('gen', 'maximum', 999)
micropsi.add_link(test_nodenet, r1_id, 'gen', a1_id, 'gen')
micropsi.add_link(test_nodenet, r2_id, 'gen', a2_id, 'gen')
r1.activation = 0.3
r2.activation = 0.7
emo_val = nodenet.get_modulator("emo_activation")
# patch reset method, to check if datatarget was written
def nothing():
pass
nodenet.worldadapter_instance.reset_datatargets = nothing
nodenet.step()
assert round(nodenet.worldadapter_instance.datatargets['engine_l'],
3) == 0.3
assert round(s1.activation, 3) == round(
nodenet.worldadapter_instance.get_datasource_value('brightness_l'), 3)
assert round(s2.activation, 3) == round(emo_val, 3)
assert round(nodenet.get_modulator('base_importance_of_intention'),
3) == 0.7
assert round(nodenet.worldadapter_instance.datatargets['engine_l'],
3) == 0.3
emo_val = nodenet.get_modulator("emo_activation")
nodenet.step()
assert round(s2.activation, 3) == round(emo_val, 3)
def test_copy_nodes():
success, nodenet_uid1 = micropsi.new_nodenet("Origin_Nodenet", "Default", owner="tester")
success, nodenet_uid2 = micropsi.new_nodenet("Target_Nodenet", "Default", owner="tester")
# create a few nodes
assert nodenet_uid1 not in micropsi.nodenets
micropsi.load_nodenet(nodenet_uid1)
assert nodenet_uid1 in micropsi.nodenets
micropsi.load_nodenet(nodenet_uid2)
assert nodenet_uid1 in micropsi.nodenets
assert nodenet_uid2 in micropsi.nodenets
micropsi.add_node(nodenet_uid1, "Nodespace", (100, 150), "Root", uid="ns1")
micropsi.add_node(nodenet_uid1, "Nodespace", (200, 150), "Root", uid="confl")
micropsi.add_node(nodenet_uid1, "Nodespace", (400, 150), "Root", uid="ns2")
micropsi.add_node(nodenet_uid2, "Nodespace", (200, 150), "Root", uid="confl")
micropsi.add_node(nodenet_uid1, "Register", (300, 140), "Root", uid="n1")
micropsi.add_node(nodenet_uid1, "Register", (300, 240), "Root", uid="n2")
micropsi.add_node(nodenet_uid1, "Register", (300, 340), "Root", uid="associated_node")
micropsi.add_node(nodenet_uid1, "Register", (400, 240), "ns1", uid="n3")
micropsi.add_node(nodenet_uid1, "Register", (400, 240), "ns2", uid="n4")
micropsi.add_node(nodenet_uid1, "Register", (100, 240), "confl", uid="n5")
micropsi.add_node(nodenet_uid2, "Register", (100, 140), "Root", uid="n1")
micropsi.add_node(nodenet_uid2, "Register", (150, 240), "Root", uid="nt2")
micropsi.add_link(nodenet_uid1, "n1", "gen", "n2", "gen", uid="l1")
micropsi.add_link(nodenet_uid1, "n2", "gen", "n3", "gen", uid="l2")
micropsi.add_link(nodenet_uid1, "n1", "gen", "associated_node", "gen", uid="la")
micropsi.add_link(nodenet_uid1, "n3", "gen", "n1", "gen", uid="l3")
micropsi.add_link(nodenet_uid1, "n4", "gen", "n1", "gen", uid="l4")
micropsi.add_link(nodenet_uid2, "n1", "gen", "nt2", "gen", uid="l1")
# now copy stuff between nodespaces
micropsi.copy_nodes( ["n1", "n2", "n3", "n5", "ns1", "confl"], nodenet_uid1, nodenet_uid2)
micropsi.save_nodenet(nodenet_uid1)
micropsi.save_nodenet(nodenet_uid2)
target = micropsi.get_nodespace(nodenet_uid2, "Root", -1)
assert len(target["nodes"]) == 4 + 2
assert len(target["nodespaces"]) == 2 + 2
assert "n1" in target["nodes"]
assert "n2" in target["nodes"]
assert "n3" in target["nodes"]
assert "associated_node" not in target["nodes"]
assert "n4" not in target["nodes"]
assert "n5" in target["nodes"]
assert "nt2" in target["nodes"]
assert "ns1" in target["nodespaces"]
assert "ns2" not in target["nodespaces"]
assert "confl" in target["nodespaces"]
assert len(target["links"]) == 3 + 1
assert "l1" in target["links"]
assert "l2" in target["links"]
assert "l3" in target["links"]
assert "l4" not in target["links"]
# we should also test for parentage and link connectivity
# TODO now test copying within the same nodenet
micropsi.copy_nodes( ["n1", "n2", "n3", "n5", "ns1", "confl"], nodenet_uid1, nodenet_uid1, target_nodespace_uid="ns2" )
micropsi.save_nodenet(nodenet_uid1)
# delete_nodenets
micropsi.delete_nodenet(nodenet_uid1)
micropsi.delete_nodenet(nodenet_uid2)
def add_node(nodenet_uid, type, pos, nodespace, state=None, uid=None, name="", parameters={}):
result, uid = runtime.add_node(nodenet_uid, type, pos, nodespace, state=state, uid=uid, name=name, parameters=parameters)
if result:
return dict(status="success", uid=uid)
else:
return dict(status="error", msg=uid)
def test_position_always_3d(test_nodenet):
res, nuid = micropsi.add_node(test_nodenet, "Pipe", [200], None, state=None, name="A")
res, nsuid = micropsi.add_nodespace(test_nodenet, [200, 125, 0, 134], None, name="NS")
data = micropsi.get_nodes(test_nodenet)
assert data['nodes'][nuid]['position'] == [200, 0, 0]
assert data['nodespaces'][nsuid]['position'] == [200, 125, 0]
def test_get_nodespace_list_with_empty_nodespace(test_nodenet):
micropsi.add_node(test_nodenet, "Nodespace", (200, 250), "Root", state=None, uid="foospace", name="Foospace")
data = micropsi.get_nodespace_list(test_nodenet)
assert data["foospace"]['nodes'] == {}
