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_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 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'] == {}