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_delete_nodespace_unlinks_native_module(test_nodenet, resourcepath): nodenet = micropsi.get_nodenet(test_nodenet) netapi = nodenet.netapi nodespace = netapi.create_nodespace(None, "foo") foopipe = netapi.create_node("Pipe", nodespace.uid, 'foopipe') 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"]}}') with open(nodefunc_file, 'w') as fp: fp.write("def testnodefunc(netapi, node=None, **prams):\r\n return 17") micropsi.reload_native_modules() testnode = netapi.create_node("Testnode", None, "test") netapi.link(testnode, 'foo', foopipe, 'sub') netapi.link(foopipe, 'sur', testnode, 'bar') micropsi.save_nodenet(test_nodenet) # I don't understand why, but this is necessary. micropsi.revert_nodenet(test_nodenet) netapi.delete_nodespace(nodespace) data = netapi.get_node(testnode.uid).get_data(include_links=True) assert data['links'] == {}
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_delete_nodespace_unlinks_native_module(test_nodenet, resourcepath): nodenet = micropsi.get_nodenet(test_nodenet) netapi = nodenet.netapi nodespace = netapi.create_nodespace(None, "foo") foopipe = netapi.create_node("Pipe", nodespace.uid, 'foopipe') 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"]}}') with open(nodefunc_file, 'w') as fp: fp.write( "def testnodefunc(netapi, node=None, **prams):\r\n return 17") micropsi.reload_native_modules() testnode = netapi.create_node("Testnode", None, "test") netapi.link(testnode, 'foo', foopipe, 'sub') netapi.link(foopipe, 'sur', testnode, 'bar') micropsi.save_nodenet(test_nodenet) # I don't understand why, but this is necessary. micropsi.revert_nodenet(test_nodenet) netapi.delete_nodespace(nodespace) data = netapi.get_node(testnode.uid).get_data(include_links=True) assert data['links'] == {}
def test_generate_netapi_fragment(test_nodenet, resourcepath): import os netapi = micropsi.nodenets[test_nodenet].netapi # create a bunch of nodes and link them linktypes = ['subsur', 'porret', 'catexp'] nodes = [] for t in linktypes: p1 = netapi.create_node('Pipe', None, t) p2 = netapi.create_node('Pipe', None, t + '2') nodes.extend([p1, p2]) netapi.link_with_reciprocal(p1, p2, t) reg = netapi.create_node('Register', None, 'reg') netapi.link(reg, 'gen', nodes[0], 'gen') ns = netapi.create_nodespace(None, 'ns1') nodes.extend([reg, ns]) # remember their names names = [n.name for n in nodes] fragment = micropsi.generate_netapi_fragment(test_nodenet, [n.uid for n in nodes]) micropsi.nodenets[test_nodenet].clear() code = "def foo(netapi):\n " + "\n ".join(fragment.split('\n')) # save the fragment as recipe & run with open(os.path.join(resourcepath, 'recipes.py'), 'w+') as fp: fp.write(code) micropsi.reload_native_modules() micropsi.run_recipe(test_nodenet, 'foo', {}) # assert that all the nodes are there again assert set(names) == set([n.name for n in netapi.get_nodes()] + ['ns1'])
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_multiple_nodenet_interference(engine, 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"\ }}') with open(nodefunc_file, 'w') as fp: fp.write( "def testnodefunc(netapi, node=None, **prams):\r\n node.get_gate('gen').gate_function(17)" ) micropsi.reload_native_modules() result, n1_uid = micropsi.new_nodenet('Net1', engine=engine, owner='Pytest User') result, n2_uid = micropsi.new_nodenet('Net2', engine=engine, owner='Pytest User') n1 = micropsi.nodenets[n1_uid] n2 = micropsi.nodenets[n2_uid] nativemodule = n1.netapi.create_node("Testnode", None, "Testnode") register1 = n1.netapi.create_node("Register", None, "Register1") n1.netapi.link(nativemodule, 'gen', register1, 'gen', weight=1.2) source2 = n2.netapi.create_node("Register", None, "Source2") register2 = n2.netapi.create_node("Register", None, "Register2") n2.netapi.link(source2, 'gen', source2, 'gen') n2.netapi.link(source2, 'gen', register2, 'gen', weight=0.9) source2.activation = 0.7 micropsi.step_nodenet(n2.uid) assert n1.current_step == 0 assert register1.activation == 0 assert register1.name == "Register1" assert nativemodule.name == "Testnode" assert round(register1.get_slot('gen').get_links()[0].weight, 2) == 1.2 assert register1.get_slot( 'gen').get_links()[0].source_node.name == 'Testnode' assert n1.get_node(register1.uid).name == "Register1" assert n2.current_step == 1 assert round(source2.activation, 2) == 0.7 assert round(register2.activation, 2) == 0.63 assert register2.name == "Register2" assert source2.name == "Source2" assert round(register2.get_slot('gen').get_links()[0].weight, 2) == 0.9 assert register2.get_slot( 'gen').get_links()[0].source_node.name == 'Source2' assert n2.get_node(register2.uid).name == "Register2"
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_reload_native_modules(fixed_nodenet): def hashlink(l): return "%s:%s:%s:%s" % (l['source_node_uid'], l['source_gate_name'], l['target_node_uid'], l['target_slot_name']) data_before = micropsi.nodenets[fixed_nodenet].export_json() links_before = set([hashlink(l) for l in data_before.pop('links')]) micropsi.reload_native_modules() data_after = micropsi.nodenets[fixed_nodenet].export_json() links_after = set([hashlink(l) for l in data_after.pop('links')]) assert data_before == data_after assert links_before == links_after
def test_run_recipe(fixed_nodenet, resourcepath, recipes_def): with open(recipes_def, 'w') as fp: fp.write(""" def testfoo(netapi, count=23): return {'count':count} """) micropsi.reload_native_modules() state, result = micropsi.run_recipe(fixed_nodenet, 'testfoo', {'count': 42}) assert state assert result['count'] == 42
def test_run_recipe(fixed_nodenet, resourcepath): import os recipe_file = os.path.join(resourcepath, 'Test', 'recipes.py') with open(recipe_file, 'w') as fp: fp.write(""" def testfoo(netapi, count=23): return {'count':count} """) micropsi.reload_native_modules() state, result = micropsi.run_recipe(fixed_nodenet, 'testfoo', {'count': 42}) assert state assert result['count'] == 42
def test_get_recipes(fixed_nodenet, resourcepath, recipes_def): with open(recipes_def, 'w') as fp: fp.write(""" def testfoo(netapi, count=23): return {'count':count} """) micropsi.reload_native_modules() recipes = micropsi.get_available_recipes() assert 'testfoo' in recipes assert len(recipes['testfoo']['parameters']) == 1 assert recipes['testfoo']['parameters'][0]['name'] == 'count' assert recipes['testfoo']['parameters'][0]['default'] == 23
def test_run_recipe(fixed_nodenet, resourcepath): from os import path, remove with open(path.join(resourcepath, 'recipes.py'), 'w') as fp: fp.write(""" def testfoo(netapi, count=23): return count """) micropsi.reload_native_modules(fixed_nodenet) state, result = micropsi.run_recipe(fixed_nodenet, 'testfoo', {'count': 42}) assert state assert result == 42 remove(path.join(resourcepath, 'recipes.py'))
def test_get_recipes(fixed_nodenet, resourcepath): from os import path, remove with open(path.join(resourcepath, 'recipes.py'), 'w') as fp: fp.write(""" def testfoo(netapi, count=23): return count """) micropsi.reload_native_modules(fixed_nodenet) recipes = micropsi.get_available_recipes() assert 'testfoo' in recipes assert len(recipes['testfoo']['parameters']) == 1 assert recipes['testfoo']['parameters'][0]['name'] == 'count' assert recipes['testfoo']['parameters'][0]['default'] == 23 remove(path.join(resourcepath, 'recipes.py'))
def test_multiple_nodenet_interference(engine, 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"\ }}') with open(nodefunc_file, 'w') as fp: fp.write("def testnodefunc(netapi, node=None, **prams):\r\n node.get_gate('gen').gate_function(17)") micropsi.reload_native_modules() result, n1_uid = micropsi.new_nodenet('Net1', engine=engine, owner='Pytest User') result, n2_uid = micropsi.new_nodenet('Net2', engine=engine, owner='Pytest User') n1 = micropsi.nodenets[n1_uid] n2 = micropsi.nodenets[n2_uid] nativemodule = n1.netapi.create_node("Testnode", None, "Testnode") register1 = n1.netapi.create_node("Register", None, "Register1") n1.netapi.link(nativemodule, 'gen', register1, 'gen', weight=1.2) source2 = n2.netapi.create_node("Register", None, "Source2") register2 = n2.netapi.create_node("Register", None, "Register2") n2.netapi.link(source2, 'gen', source2, 'gen') n2.netapi.link(source2, 'gen', register2, 'gen', weight=0.9) source2.activation = 0.7 micropsi.step_nodenet(n2.uid) assert n1.current_step == 0 assert register1.activation == 0 assert register1.name == "Register1" assert nativemodule.name == "Testnode" assert round(register1.get_slot('gen').get_links()[0].weight, 2) == 1.2 assert register1.get_slot('gen').get_links()[0].source_node.name == 'Testnode' assert n1.get_node(register1.uid).name == "Register1" assert n2.current_step == 1 assert round(source2.activation, 2) == 0.7 assert round(register2.activation, 2) == 0.63 assert register2.name == "Register2" assert source2.name == "Source2" assert round(register2.get_slot('gen').get_links()[0].weight, 2) == 0.9 assert register2.get_slot('gen').get_links()[0].source_node.name == 'Source2' assert n2.get_node(register2.uid).name == "Register2"
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 pytest_runtest_teardown(item, nextitem): if nextitem is None: print("DELETING ALL STUFF") shutil.rmtree(config['paths']['resource_path']) else: uids = list(micropsi.nodenets.keys()) for uid in uids: micropsi.delete_nodenet(uid) if os.path.isfile(nodetype_file): os.remove(nodetype_file) if os.path.isfile(nodefunc_file): os.remove(nodefunc_file) if os.path.isfile(recipes_file): os.remove(recipes_file) micropsi.reload_native_modules() set_logging_levels()
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_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 pytest_runtest_setup(item): engine_marker = item.get_marker("engine") if engine_marker is not None: engine_marker = engine_marker.args[0] if engine_marker != item.callspec.params['engine']: pytest.skip("test requires engine %s" % engine_marker) for item in os.listdir(testpath): if item != 'worlds' and item != 'nodenets': path = os.path.join(testpath, item) if os.path.isdir(path): shutil.rmtree(path) else: os.remove(path) os.mkdir(os.path.join(testpath, 'Test')) open(os.path.join(testpath, 'Test', '__init__.py'), 'w').close() micropsi.reload_native_modules() micropsi.logger.clear_logs() micropsi.set_runner_properties(1, 1) set_logging_levels()
def test_plot_from_nodefunc(test_nodenet, resourcepath): import os from random import random from time import sleep nodenet = micropsi.get_nodenet(test_nodenet) vizapi = nodenet.netapi.vizapi activations = [random() for i in range(256)] plot = vizapi.NodenetPlot(plotsize=(2, 2)) plot.add_activation_plot(activations) filepath = os.path.join(resourcepath, "plot.png") returnpath = plot.save_to_file(filepath) assert os.path.abspath(returnpath) == os.path.abspath(filepath) assert os.path.isfile(filepath) os.remove(filepath) os.mkdir(os.path.join(resourcepath, 'plotter')) nodetype_file = os.path.join(resourcepath, "plotter", "nodetypes.json") nodefunc_file = os.path.join(resourcepath, "plotter", "nodefunctions.py") with open(nodetype_file, 'w') as fp: fp.write("""{"Plotter": { "name": "Plotter", "slottypes": [], "nodefunction_name": "plotfunc", "gatetypes": [], "parameters": ["plotpath"]}}""") with open(nodefunc_file, 'w') as fp: fp.write(""" def plotfunc(netapi, node=None, **params): import os from random import random filepath = os.path.join(params['plotpath'], 'plot.png') activations = [random() for i in range(256)] plot = netapi.vizapi.NodenetPlot(plotsize=(2, 2)) plot.add_activation_plot(activations) plot.save_to_file(filepath) """) micropsi.reload_native_modules() node = nodenet.netapi.create_node("Plotter", None, name="Plotter") node.set_parameter("plotpath", resourcepath) micropsi.start_nodenetrunner(test_nodenet) sleep(2) micropsi.stop_nodenetrunner(test_nodenet) assert micropsi.MicropsiRunner.last_nodenet_exception == {} assert os.path.isfile(os.path.join(resourcepath, "plot.png"))
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_engine_specific_nodetype_theano(fixed_nodenet, resourcepath, nodetype_def, nodefunc_def): with open(nodetype_def, 'w') as fp: fp.write('{"Testnode": {\ "engine": "dict_engine",\ "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() data = micropsi.get_nodenet_data(fixed_nodenet, nodespace='Root') assert "Testnode" not in data['native_modules']
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_delete_partition_unlinks_native_module(test_nodenet, resourcepath): nodenet = micropsi.get_nodenet(test_nodenet) netapi = nodenet.netapi nodespace, source, register = prepare(netapi) 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"]}}') with open(nodefunc_file, 'w') as fp: fp.write("def testnodefunc(netapi, node=None, **prams):\r\n return 17") micropsi.reload_native_modules() testnode = netapi.create_node("Testnode", None, "test") netapi.link(testnode, 'foo', register, 'gen') netapi.link(register, 'gen', testnode, 'bar') netapi.delete_nodespace(nodespace) data = testnode.get_data(include_links=True) assert data['links'] == {}
def test_native_module_and_recipe_categories(fixed_nodenet, resourcepath): import os os.mkdir(os.path.join(resourcepath, 'Test', 'Test2')) nodetype_file = os.path.join(resourcepath, 'Test', 'nodetypes.json') nodefunc_file = os.path.join(resourcepath, 'Test', 'nodefunctions.py') recipe_file = os.path.join(resourcepath, 'Test', 'Test2', 'recipes.py') with open(nodetype_file, 'w') as fp: fp.write('{"Testnode": {\ "name": "Testnode",\ "slottypes": ["gen", "foo", "bar"],\ "nodefunction_name": "testnodefunc",\ "gatetypes": ["gen", "foo", "bar"]\ }}') with open(nodefunc_file, 'w') as fp: fp.write("def testnodefunc(netapi, node=None, **prams):\r\n return 17") with open(recipe_file, 'w') as fp: fp.write("def testrecipe(netapi):\r\n pass") micropsi.reload_native_modules() res = micropsi.get_available_native_module_types(fixed_nodenet) assert res['Testnode']['category'] == 'Test' res = micropsi.get_available_recipes() assert res['testrecipe']['category'] == 'Test/Test2'
def test_engine_specific_nodetype(fixed_nodenet, resourcepath): from os import path, remove with open(path.join(resourcepath, 'nodetypes.json'), 'w') as fp: fp.write('{"Testnode": {\ "engine": "theano_engine",\ "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) data = micropsi.get_nodenet_data(fixed_nodenet, nodespace='Root') assert "Testnode" not in data['native_modules'] remove(path.join(resourcepath, 'nodetypes.json')) remove(path.join(resourcepath, 'nodefunctions.py'))
def test_delete_partition_unlinks_native_module(test_nodenet, resourcepath): nodenet = micropsi.get_nodenet(test_nodenet) netapi = nodenet.netapi nodespace, source, register = prepare(netapi) 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"]}}') with open(nodefunc_file, 'w') as fp: fp.write( "def testnodefunc(netapi, node=None, **prams):\r\n return 17") micropsi.reload_native_modules() testnode = netapi.create_node("Testnode", None, "test") netapi.link(testnode, 'foo', register, 'gen') netapi.link(register, 'gen', testnode, 'bar') netapi.delete_nodespace(nodespace) data = testnode.get_data(include_links=True) assert data['links'] == {}
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 test_engine_specific_nodetype_theano(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": {\ "engine": "dict_engine",\ "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() data = micropsi.get_nodenet_metadata(fixed_nodenet) assert "Testnode" not in data['native_modules']
def reload_native_modules(): return runtime.reload_native_modules()
def reload_native_modules(nodenet_uid=None): return runtime.reload_native_modules(nodenet_uid)
def test_reload_native_modules(fixed_nodenet): data_before = micropsi.nodenets[fixed_nodenet].data micropsi.reload_native_modules() data_after = micropsi.nodenets[fixed_nodenet].data assert data_before == data_after