def test_recursion_factory(): """ Test Recursion detection""" pm = PackageManager() pm.init() pkg = Package("compositenode", {}) sgfactory1 = CompositeNodeFactory("graph1") sgfactory2 = CompositeNodeFactory("graph2") map(pkg.add_factory, (sgfactory1, sgfactory2)) assert len(pkg.get_names()) == 2 pm.add_package(pkg) n1 = sgfactory1.instantiate() n2 = sgfactory1.instantiate() # build the compositenode factory n1.add_node(n2) n2.add_node(n1) n1.to_factory(sgfactory1) n2.to_factory(sgfactory2) #sgfactory1.add_nodefactory ( ("compositenode", "graph2")) #sgfactory2.add_nodefactory ( ("compositenode", "graph1")) try: sg = sgfactory1.instantiate() assert False except RecursionError: assert True
def test_to_factory(): """ Create a compositenode, generate its factory and reintantiate it """ pm = PackageManager() pm.init() sg = CompositeNode() n1 = pm.get_node("Catalog.Data", "float") n2 = pm.get_node("Catalog.Data", "float") e1 = sg.add_node(n1) e2 = sg.add_node(n2) sg.connect(e1, 0, e2, 0) n1.set_input(0, 34.) sg() assert n2.get_output(0)==34. sgfactory = CompositeNodeFactory("factorytest") sg.to_factory(sgfactory) sg2 = sgfactory.instantiate() assert len(list(sg2.vertices()))==2+2 # two nodes + in/ou assert len(list(sg2.edges()))==1 sg2.node(e1).set_input(0, 3.) sg2() assert sg2.node(e2).get_output(0)==3. return pm, sg, sgfactory
def test1(directory): from openalea.core.pkgmanager import PackageManager pm = PackageManager() pm.init(verbose=False) obj = vlab_object(directory, pm) pkg = obj.get_package() pkg.write()
def test_to_factory(): """ Create a compositenode, generate its factory and reintantiate it """ pm = PackageManager() pm.init() sg = CompositeNode() n1 = pm.get_node("Catalog.Data", "float") n2 = pm.get_node("Catalog.Data", "float") e1 = sg.add_node(n1) e2 = sg.add_node(n2) sg.connect(e1, 0, e2, 0) n1.set_input(0, 34.) sg() assert n2.get_output(0) == 34. sgfactory = CompositeNodeFactory("factorytest") sg.to_factory(sgfactory) sg2 = sgfactory.instantiate() assert len(list(sg2.vertices())) == 2 + 2 # two nodes + in/ou assert len(list(sg2.edges())) == 1 sg2.node(e1).set_input(0, 3.) sg2() assert sg2.node(e2).get_output(0) == 3. return pm, sg, sgfactory
def test_auto_io(): """ Test auto io""" pm = PackageManager() pm.init() sg = CompositeNode() # build the compositenode factory val1id = sg.add_node(pm.get_node("Catalog.Data", "string")) val2id = sg.add_node(pm.get_node("Catalog.Data", "string")) val3id = sg.add_node(pm.get_node("Catalog.Data", "string")) sg.connect(val1id, 0, val3id, 0) sg.connect(val2id, 0, val3id, 0) sgfactory = CompositeNodeFactory("testlautoio") sg.to_factory(sgfactory, listid=[val1id, val2id, val3id], auto_io=True) # allocate the compositenode sg = sgfactory.instantiate() assert sg.get_nb_input() == 2 assert sg.get_nb_output() == 1 sg.set_input(0, "to") sg.set_input(1, "to") sg() res = sg.get_output(0) assert ''.join(eval(res)) == "toto"
def test_multi_in_eval(): """ Test multiple out connection""" pm = PackageManager() pm.init() sg = CompositeNode() # build the compositenode factory val1id = sg.add_node(pm.get_node("Catalog.Data", "string")) val2id = sg.add_node(pm.get_node("Catalog.Data", "string")) val3id = sg.add_node(pm.get_node("Catalog.Data", "string")) sg.connect(val1id, 0, val3id, 0) sg.connect(val2id, 0, val3id, 0) sgfactory = CompositeNodeFactory("testlazyeval") sg.to_factory(sgfactory) # allocate the compositenode sg = sgfactory.instantiate() sg.node(val1id).set_input(0, "teststring1") sg.node(val2id).set_input(0, "teststring2") sg() assert (sg.node(val3id).get_output(0) == "['teststring1', 'teststring2']")\ or \ (sg.node(val3id).get_output(0) == "['teststring2', 'teststring1']")
def test_instantiate_compositenode(): """test instantiation""" pm = PackageManager() pm.init() sg = CompositeNode() # build the compositenode factory addid = sg.add_node(pm.get_node("Catalog.Math", "+")) val1id = sg.add_node(pm.get_node("Catalog.Data", "float")) val2id = sg.add_node(pm.get_node("Catalog.Data", "float")) val3id = sg.add_node(pm.get_node("Catalog.Data", "float")) sg.connect(val1id, 0, addid, 0) sg.connect(val2id, 0, addid, 1) sg.connect(addid, 0, val3id, 0) sgfactory = CompositeNodeFactory("addition") sg.to_factory(sgfactory) # allocate the compositenode sg = sgfactory.instantiate() sg.node(val1id).set_input(0, 2.) sg.node(val2id).set_input(0, 3.) # evaluation sg() assert sg.node(val3id).get_output(0) == 5.
def test_data(): """test data""" pm = PackageManager() pm.init() assert pm['pkg_test']['file1.txt'] assert pm['pkg_test']['file2.txt']
def _test_lambda(): """ Test for lambda functions""" pm = PackageManager() pm.init() import testnodes testnodes.register_packages(pm) for t, id, res in ( ('LambdaFactoriel', 2, 362880), ('testlambdaFor', 3, 12), ('testlambdaFor', 9, [12, 5]), ('testorder', 4, [1., 2.]), ('TestLambda', 3, map(lambda x: (x+5)*5, range(10))), ('testlambda2', 10, filter(lambda x: x>=2 and x <= 7, range(10))), ('testlambda3', 3, map(lambda y: filter(lambda x: x>=7, y), \ [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], \ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], \ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]])), ('test_str', 5, ['toto', 'toto']), ): n = pm.get_node("TestLambda", t) n() print n.node(id).get_output(0), res assert n.node(id).get_output(0) == res
def test_nodewriter(): """test node writer""" pm = PackageManager() pm.clear() pm.init() # Package metainfo = { 'version': '0.0.1', 'license': 'CECILL-C', 'authors': 'OpenAlea Consortium', 'institutes': 'INRIA/CIRAD', 'description': 'Base library.', 'url': 'http://openalea.gforge.inria.fr' } package1 = pm.create_user_package("MyTestPackage", metainfo, tmp_dir) assert package1 is not None nf = package1.create_user_node( name="mynode", category='test', description="descr", inputs=(), outputs=(), ) package1.write() pm.init() newsg = pm.get_node('MyTestPackage', 'mynode') package1.remove_files()
def test_multi_out_eval(): """ Test multiple out connection""" pm = PackageManager() pm.init() sg = CompositeNode() # build the compositenode factory val1id = sg.add_node(pm.get_node("Catalog.Data", "string")) val2id = sg.add_node(pm.get_node("Catalog.Data", "string")) val3id = sg.add_node(pm.get_node("Catalog.Data", "string")) sg.connect(val1id, 0, val2id, 0) sg.connect(val1id, 0, val3id, 0) sgfactory = CompositeNodeFactory("testlazyeval") sg.to_factory(sgfactory) # allocate the compositenode sg = sgfactory.instantiate() sg.node(val1id).set_input(0, "teststring") sg() assert sg.node(val2id).get_output(0) == "teststring" assert sg.node(val3id).get_output(0) == "teststring" #partial evaluation sg.node(val1id).set_input(0, "teststring2") sg.eval_as_expression(val2id) assert sg.node(val2id).get_output(0) == "teststring2" sg.eval_as_expression(val3id) assert sg.node(val3id).get_output(0) == "teststring2"
def test_save_workspace(): pm = PackageManager() pm.init() asession = Session() import sys sgfactory = CompositeNodeFactory(name="SubGraphExample", description= "Examples", category = "Examples", ) sg= CompositeNode() # build the subgraph factory addid = sg.add_node(pm.get_node("pkg_test", "float")) sg.to_factory(sgfactory) instance = sgfactory.instantiate() instance.actor(addid).set_input(0, 3) asession.add_workspace(instance) asession.save('test.pic') asession.workspaces = [] asession.load('test.pic') try: os.remove('test.pic') except: os.remove('test.pic.db') i = asession.workspaces[0] assert type(i) == type(instance)
def test_nodewriter(): """test node writer""" setup_module() pm = PackageManager() pm.clear() pm.init() # Package metainfo = {'version': '0.0.1', 'license': 'CECILL-C', 'authors': 'OpenAlea Consortium', 'institutes': 'INRIA/CIRAD', 'description': 'Base library.', 'url': 'http://openalea.gforge.inria.fr'} package1 = pm.create_user_package("MyTestPackage", \ metainfo, os.path.curdir) assert package1 != None nf = package1.create_user_node(name="mynode", category='test', description="descr", inputs=(), outputs=(), ) package1.write() pm.init() newsg = pm.get_node('MyTestPackage', 'mynode') package1.remove_files()
def _test_lambda(): """ Test for lambda functions""" pm = PackageManager() pm.init() from . import testnodes testnodes.register_packages(pm) for t, id, res in ( ('LambdaFactoriel', 2, 362880), ('testlambdaFor', 3, 12), ('testlambdaFor', 9, [12, 5]), ('testorder', 4, [1., 2.]), ('TestLambda', 3, [(x+5)*5 for x in range(10)]), ('testlambda2', 10, [x for x in range(10) if x>=2 and x <= 7]), ('testlambda3', 3, [[x for x in y if x>=7] for y in [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], \ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], \ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]]]), ('test_str', 5, ['toto', 'toto']), ): n = pm.get_node("TestLambda", t) n() print((n.node(id).get_output(0), res)) assert n.node(id).get_output(0) == res
def test_save_workspace(): pm = PackageManager() pm.init() asession = Session() import sys sgfactory = CompositeNodeFactory( name="SubGraphExample", description="Examples", category="Examples", ) sg = CompositeNode() # build the subgraph factory addid = sg.add_node(pm.get_node("pkg_test", "float")) sg.to_factory(sgfactory) instance = sgfactory.instantiate() instance.actor(addid).set_input(0, 3) asession.add_workspace(instance) asession.save('test.pic') asession.workspaces = [] asession.load('test.pic') try: os.remove('test.pic') except: os.remove('test.pic.db') i = asession.workspaces[0] assert type(i) == type(instance)
def test_compositenodewriter(): setup_module() pm = PackageManager() pm.init() sg = CompositeNode(inputs=[dict(name="%d" % i) for i in xrange(3)], outputs=[dict(name="%d" % i) for i in xrange(4)], ) # build the compositenode factory addid = sg.add_node(pm.get_node("pkg_test", "+")) val1id = sg.add_node(pm.get_node("pkg_test", "float")) val2id = sg.add_node(pm.get_node("pkg_test", "float")) val3id = sg.add_node(pm.get_node("pkg_test", "float")) sg.connect(val1id, 0, addid, 0) sg.connect(val2id, 0, addid, 1) sg.connect(addid, 0, val3id, 0) sg.connect(val3id, 0, sg.id_out, 0) sgfactory = CompositeNodeFactory("addition") sg.to_factory(sgfactory) # Package metainfo = {'version': '0.0.1', 'license': 'CECILL-C', 'authors': 'OpenAlea Consortium', 'institutes': 'INRIA/CIRAD', 'description': 'Base library.', 'url': 'http://openalea.gforge.inria.fr'} package1 = pm.create_user_package("MyTestPackage", metainfo, os.path.curdir) package1.add_factory(sgfactory) print package1.keys() assert 'addition' in package1 package1.write() sg = sgfactory.instantiate() sg.node(val1id).set_input(0, 2.) sg.node(val2id).set_input(0, 3.) # evaluation sg() print sg.node(val3id).get_output(0) assert sg.node(val3id).get_output(0) == 5. print "nb vertices", len(sg) assert len(sg) == 6 pm.init() newsg = pm.get_node('MyTestPackage', 'addition') print "nb vertices", len(newsg) assert len(newsg) == 6
def test_category(): pkgman = PackageManager() pkgman.init() pkgman.find_and_register_packages() # test if factory are dedoubled for cat in pkgman.category.values(): s = set() for factory in cat: assert not factory in s s.add(factory)
def load_package_manager(*args): """ Return the package manager :param pkg_id: package id :param node_id: node id :returns: package manager """ pm = PackageManager() pm.init(verbose=False) return pm
def test_compositenodeio(): """ Test IO""" pm = PackageManager() pm.init() pkg = Package("compositenode", {}) # create a compositenode with 2 in and 1 out # the compositenode does an addition sg = CompositeNode(inputs=(dict(name="in1", interface=None, value=None),\ dict(name="in2", interface=None, value=None)), outputs=(dict(name="out", interface=None), ), ) addid = sg.add_node(pm.get_node("Catalog.Math", "+")) sg.connect(sg.id_in, 0, addid, 0) sg.connect(sg.id_in, 1, addid, 1) sg.connect(addid, 0, sg.id_out, 0) sgfactory = CompositeNodeFactory("additionsg") sg.to_factory(sgfactory) sg1= sgfactory.instantiate() sg1.set_input(0, 2.) sg1.set_input(1, 3.) sg1() assert sg1.get_output(0)==5. pkg.add_factory(sgfactory) pm.add_package(pkg) sg = CompositeNode() addid = sg.add_node(pm.get_node("compositenode", "additionsg")) val1id = sg.add_node(pm.get_node("Catalog.Data", "float")) val2id = sg.add_node(pm.get_node("Catalog.Data", "float")) val3id = sg.add_node(pm.get_node("Catalog.Data", "float")) sg.connect(val1id, 0, addid, 0) sg.connect(val2id, 0, addid, 1) sg.connect(addid, 0, val3id, 0) sgfactory2 = CompositeNodeFactory("testio") sg.to_factory(sgfactory2) # allocate the compositenode sg = sgfactory2.instantiate() sg.node(val1id).set_input(0, 2.) sg.node(val2id).set_input(0, 3.) # evaluation sg() assert sg.node(val3id).get_output(0)==5.
def test_compositenodeio(): """ Test IO""" pm = PackageManager() pm.init() pkg = Package("compositenode", {}) # create a compositenode with 2 in and 1 out # the compositenode does an addition sg = CompositeNode(inputs=(dict(name="in1", interface=None, value=None),\ dict(name="in2", interface=None, value=None)), outputs=(dict(name="out", interface=None), ), ) addid = sg.add_node(pm.get_node("Catalog.Math", "+")) sg.connect(sg.id_in, 0, addid, 0) sg.connect(sg.id_in, 1, addid, 1) sg.connect(addid, 0, sg.id_out, 0) sgfactory = CompositeNodeFactory("additionsg") sg.to_factory(sgfactory) sg1 = sgfactory.instantiate() sg1.set_input(0, 2.) sg1.set_input(1, 3.) sg1() assert sg1.get_output(0) == 5. pkg.add_factory(sgfactory) pm.add_package(pkg) sg = CompositeNode() addid = sg.add_node(pm.get_node("compositenode", "additionsg")) val1id = sg.add_node(pm.get_node("Catalog.Data", "float")) val2id = sg.add_node(pm.get_node("Catalog.Data", "float")) val3id = sg.add_node(pm.get_node("Catalog.Data", "float")) sg.connect(val1id, 0, addid, 0) sg.connect(val2id, 0, addid, 1) sg.connect(addid, 0, val3id, 0) sgfactory2 = CompositeNodeFactory("testio") sg.to_factory(sgfactory2) # allocate the compositenode sg = sgfactory2.instantiate() sg.node(val1id).set_input(0, 2.) sg.node(val2id).set_input(0, 3.) # evaluation sg() assert sg.node(val3id).get_output(0) == 5.
def test_case_1(self): metainfo = {'version': '0.0.1', 'license': 'CECILL-C', 'authors': 'OpenAlea Consortium', 'institutes': 'INRIA/CIRAD', 'description': 'Base library.', 'url': 'http://openalea.gforge.inria.fr', 'icon': ''} path = os.path.join(os.path.curdir, "tstpkg") mypackage = UserPackage("DummyPkg", metainfo, path) factory = mypackage.create_user_node("TestFact", "category test", "this is a test", gen_port_list(3), gen_port_list(2)) assert path in factory.search_path assert len(factory.inputs)==3 assert len(factory.outputs)==2 assert os.path.exists("tstpkg/TestFact.py") execfile("tstpkg/TestFact.py") mypackage.write() assert os.path.exists("tstpkg/__wralea__.py") assert os.path.exists("tstpkg/__init__.py") execfile("tstpkg/__wralea__.py") # Test_clone_package path = os.path.join(os.path.curdir, "clonepkg") pkg2 = UserPackage("ClonePkg", metainfo, path) print pkg2.wralea_path # todo this is not working !! from openalea.core.pkgmanager import PackageManager pm = PackageManager() pm.add_wralea_path(path, pm.temporary_wralea_paths) pm.init() pkg2.clone_from_package(mypackage) pkg2.write() assert len(pkg2) == 1 assert len(pkg2["TestFact"].inputs) == 3 assert id(pkg2["TestFact"]) != id(mypackage["TestFact"]) assert os.path.exists(path) assert os.path.exists(os.path.join(path, '__wralea__.py')) assert os.path.exists(os.path.join(path, '__init__.py')) assert os.path.exists(os.path.join(path, 'TestFact.py'))
def test_load_pm(): pkgman = PackageManager() pkgman.init() simpleop = pkgman["openalea.flow control"] assert simpleop addfactory = simpleop.get_factory('command') assert addfactory != None assert addfactory.instantiate() valfactory = simpleop.get_factory('rendez vous') assert valfactory != None
def test_case_1(self): metainfo = { 'version': '0.0.1', 'license': 'CECILL-C', 'authors': 'OpenAlea Consortium', 'institutes': 'INRIA/CIRAD', 'description': 'Base library.', 'url': 'http://openalea.gforge.inria.fr', 'icon': '' } path = os.path.join(os.path.curdir, "tstpkg") mypackage = UserPackage("DummyPkg", metainfo, path) factory = mypackage.create_user_node("TestFact", "category test", "this is a test", gen_port_list(3), gen_port_list(2)) assert path in factory.search_path assert len(factory.inputs) == 3 assert len(factory.outputs) == 2 assert os.path.exists("tstpkg/TestFact.py") execfile("tstpkg/TestFact.py") mypackage.write() assert os.path.exists("tstpkg/__wralea__.py") assert os.path.exists("tstpkg/__init__.py") execfile("tstpkg/__wralea__.py") # Test_clone_package path = os.path.join(os.path.curdir, "clonepkg") pkg2 = UserPackage("ClonePkg", metainfo, path) print pkg2.wralea_path # todo this is not working !! from openalea.core.pkgmanager import PackageManager pm = PackageManager() pm.add_wralea_path(path, pm.temporary_wralea_paths) pm.init() pkg2.clone_from_package(mypackage) pkg2.write() assert len(pkg2) == 1 assert len(pkg2["TestFact"].inputs) == 3 assert id(pkg2["TestFact"]) != id(mypackage["TestFact"]) assert os.path.exists(path) assert os.path.exists(os.path.join(path, '__wralea__.py')) assert os.path.exists(os.path.join(path, '__init__.py')) assert os.path.exists(os.path.join(path, 'TestFact.py'))
def test_compositenodewriter(): pm = PackageManager() pm.init() sg = CompositeNode( inputs=[dict(name="%d" % i) for i in xrange(3)], outputs=[dict(name="%d" % i) for i in xrange(4)], ) # build the compositenode factory addid = sg.add_node(pm.get_node("pkg_test", "+")) val1id = sg.add_node(pm.get_node("pkg_test", "float")) val2id = sg.add_node(pm.get_node("pkg_test", "float")) val3id = sg.add_node(pm.get_node("pkg_test", "float")) sg.connect(val1id, 0, addid, 0) sg.connect(val2id, 0, addid, 1) sg.connect(addid, 0, val3id, 0) sg.connect(val3id, 0, sg.id_out, 0) sgfactory = CompositeNodeFactory("addition") sg.to_factory(sgfactory) # Package metainfo = { 'version': '0.0.1', 'license': 'CECILL-C', 'authors': 'OpenAlea Consortium', 'institutes': 'INRIA/CIRAD', 'description': 'Base library.', 'url': 'http://openalea.gforge.inria.fr' } package1 = pm.create_user_package("MyTestPackage", metainfo, tmp_dir) package1.add_factory(sgfactory) assert 'addition' in package1 package1.write() sg = sgfactory.instantiate() sg.node(val1id).set_input(0, 2.) sg.node(val2id).set_input(0, 3.) # evaluation sg() assert sg.node(val3id).get_output(0) == 5. assert len(sg) == 6 pm.init() newsg = pm.get_node('MyTestPackage', 'addition') assert len(newsg) == 6
def worker_task_bruteval(ident, broker_port, broker_addr, package, wf, ssh_pkey, *args, **kwargs): ######################"" time_initialization = time.time() pkg = PackageManager() pkg.init() wf_factory = pkg[package][wf] wf = wf_factory.instantiate() wf.eval_algo = "BrutEvaluation" time_initialization = time.time() - time_initialization # home = expanduser("~") # wfpath = os.path.join(home, "workflow") # with open(wfpath, "r") as f: # wf = dill.load(f) ##############################"" try: site_name = ident[:ident.find("_")] except: site_name = "siteUnknown" socket = zmq.Context().socket(zmq.REQ) socket.identity = u"Worker-{}".format(ident).encode("ascii") if str(broker_addr) == "localhost": socket.connect("tcp://"+str(broker_addr)+":"+str(broker_port)) else: server = start_sshtunnel(broker_addr=broker_addr, broker_port=broker_port, ssh_pkey=ssh_pkey) socket.connect("tcp://127.0.0.1:"+str(server.local_bind_port)) print("Worker-{} successfully connected to broker, from site : ".format(ident).encode("ascii") + site_name) # Tell broker we're ready for work socket.send(b"READY") # Do work while True: address, empty, request = socket.recv_multipart() # print("{}: {}".format(socket.identity.decode("ascii"), # request.decode("ascii"))) request = dill.loads(request) num_p = request.get("num_plant", 0) try: wf.node(33).set_input(0, num_p) wf.eval(time_initialization=time_initialization, **kwargs) socket.send_multipart([address, b"", b"success"]) except: socket.send_multipart([address, b"", b"fail"])
def oa_pm(root): """Create openalea PackageManager and initialize it with given directory. Args: root (str): valid path to a directory Returns: (PackageManager) """ pm = PackageManager() if os.path.exists(os.path.join(root, "src")): root = os.path.join(root, "src") pm.init(root, verbose=True) return pm
def worker_task_fragmenteval(ident, broker_port, broker_addr, package, wf, ssh_pkey): ######################"" pkg = PackageManager() pkg.init() wf_factory = pkg[package][wf] wf = wf_factory.instantiate() wf.eval_algo = "FragmentEvaluation" ##############################"" socket = zmq.Context().socket(zmq.REQ) socket.identity = u"Worker-{}".format(ident).encode("ascii") if str(broker_addr) == "localhost": socket.connect("tcp://" + str(broker_addr) + ":" + str(broker_port)) else: server = start_sshtunnel(broker_addr=broker_addr, broker_port=broker_port, ssh_pkey=ssh_pkey) socket.connect("tcp://127.0.0.1:" + str(server.local_bind_port)) # Tell broker we're ready for work socket.send(b"READY") # Do work while True: address, empty, request = socket.recv_multipart() # print("{}: {}".format(socket.identity.decode("ascii"), # request.decode("ascii"))) request = dill.loads(request) if 'output_path' in request: out_path = request['output_path'] else: out_path = "" try: frag = request['fragment'] for i, vid in enumerate([v[0] for v in frag['outputs_vid']]): wf.eval_as_expression(vtx_id=vid, record_provenance=False, fragment_infos=frag, tmp_path=out_path) socket.send_multipart([address, b"", b"success"]) except: socket.send_multipart([address, b"", b"fail"])
def test_tutorial(): #app = QtGui.QApplication(sys.argv) path = os.path.join( os.path.abspath(os.path.dirname(__file__)), "tutorial_standbuilder") image = os.path.join(path, "stand.csv.png") try: os.remove(image) except: pass pm = PackageManager() pm.init() pm.load_directory(path) n = pm.get_node("tutorial_standbuilder", "gen_images") print path n.actor(4).set_input(0, path)
def test_tutorial(): #app = QtGui.QApplication(sys.argv) path = os.path.join(os.path.abspath(os.path.dirname(__file__)), "tutorial_standbuilder") image = os.path.join(path, "stand.csv.png") try: os.remove(image) except: pass pm = PackageManager() pm.init() pm.load_directory(path) n = pm.get_node("tutorial_standbuilder", "gen_images") print(path) n.actor(4).set_input(0, path)
def test_compositenode_creation_without_edges(): """test compositenode creation without edges""" pm = PackageManager() pm.init() sg = CompositeNode() # build the compositenode factory addid = sg.add_node(pm.get_node("Catalog.Math", "+")) val1id = sg.add_node(pm.get_node("Catalog.Data", "float")) val2id = sg.add_node(pm.get_node("Catalog.Data", "float")) val3id = sg.add_node(pm.get_node("Catalog.Data", "float")) sgfactory = CompositeNodeFactory("addition") sg.to_factory(sgfactory) # allocate the compositenode sg = sgfactory.instantiate() assert len(sg) == 4+2
def test_compositenode_creation_without_edges(): """test compositenode creation without edges""" pm = PackageManager() pm.init() sg = CompositeNode() # build the compositenode factory addid = sg.add_node(pm.get_node("Catalog.Math", "+")) val1id = sg.add_node(pm.get_node("Catalog.Data", "float")) val2id = sg.add_node(pm.get_node("Catalog.Data", "float")) val3id = sg.add_node(pm.get_node("Catalog.Data", "float")) sgfactory = CompositeNodeFactory("addition") sg.to_factory(sgfactory) # allocate the compositenode sg = sgfactory.instantiate() assert len(sg) == 4 + 2
def test_srcedit(): """ Test src edition """ # Change src pm = PackageManager() pm.wraleapath = "." pm.init(".") factory = pm["TestPackage"]["test"] node1 = factory.instantiate() assert node1.func((1, 2, 3)) == (1, 2, 3) src = factory.get_node_src() assert src newsrc = src.replace("return inputs", "return sum(inputs)") assert newsrc factory.apply_new_src(newsrc) node2 = factory.instantiate() assert node2.func((1, 2, 3)) == 6 factory.save_new_src(newsrc) src = factory.get_node_src() print src return # Reinit src pm = PackageManager() pm.wraleapath = "." pm.init() factory = pm["TestPackage"]["test"] node = factory.instantiate() assert node(((1, 2, 3),)) == 6
def test_srcedit(): """ Test src edition """ # Change src pm = PackageManager() pm.wraleapath = '.' pm.init('.') factory = pm['TestPackage']['test'] node1 = factory.instantiate() assert node1.func((1, 2, 3)) == (1, 2, 3) src = factory.get_node_src() assert src newsrc = src.replace("return inputs", "return sum(inputs)") assert newsrc factory.apply_new_src(newsrc) node2 = factory.instantiate() assert node2.func((1, 2, 3)) == 6 factory.save_new_src(newsrc) src = factory.get_node_src() print src return # Reinit src pm = PackageManager() pm.wraleapath = '.' pm.init() factory = pm['TestPackage']['test'] node = factory.instantiate() assert node(((1, 2, 3), )) == 6
def test_catalog(): """test_catalog: test init catalog in PackageManager""" pkgman = PackageManager() pkgman.init(verbose=False) assert pkgman["catalog.data"]["int"] is \ pkgman["openalea.data structure"]["int"]
"""pybase node Tests""" __license__ = "Cecill-C" __revision__ = " $Id$" from openalea.core.alea import run from openalea.core.pkgmanager import PackageManager from random import random, randint """ A unique PackageManager is created for all test of dataflow """ pm = PackageManager() pm.init(verbose=False) def test_ifelse(): """ Test of node ifelse """ res = run(('openalea.python method', 'ifelse'),\ inputs={'c': True, 'a': 'a', 'b': 'b'}, pm=pm) assert res[0] == 'a' res = run(('openalea.python method', 'ifelse'),\ inputs={'c': False, 'a': 'a', 'b': 'b'}, pm=pm) assert res[0] == 'b' def test_getitem(): """ Test of node getitem """ res = run(('openalea.python method', 'getitem'),\ inputs={'obj': {'a': 1, 'b': 2}, 'key': 'a'}, pm=pm) assert res[0] == 1 res = run(('openalea.python method', 'getitem'),\ inputs={'obj': range(10), 'key': 2}, pm=pm)
"""pybase node Tests""" __license__ = "Cecill-C" __revision__ = " $Id$" from openalea.core.alea import run from openalea.core.pkgmanager import PackageManager """ A unique PackageManager is created for all test of dataflow """ pm = PackageManager() pm.init(verbose=True) def test_read_csv_from_file(): """ Test of node read_csv""" res = run(('openalea.csv', 'read csv'),\ inputs={'text': '1 1 2 3', 'separator': ' '}, pm=pm) test_read_csv_from_file()
from openalea.oalab.paradigm.python import PythonModelController from openalea.oalab.paradigm.visualea import VisualeaModelController from openalea.core.world.world import World from openalea.oalab.service.paradigm import paradigm_controller from openalea.vpltk.qt import QtGui from openalea.core.service.ipython import interpreter interp = interpreter() interp.user_ns['interp'] = interp pm = PackageManager() pm.init() def composite_node(): inputs = [] outputs = [] for io in list('abcd'): inputs.append({'name': io, 'desc': 'Input %s' % io.upper(), 'value': 0}) outputs.append({'name': io, 'desc': 'Input %s' % io.upper()}) sg = CompositeNode(inputs=inputs, outputs=outputs) for i in range(len(inputs)): sg.connect(sg.id_in, i, sg.id_out, i) sgfactory = CompositeNodeFactory("addition")
# -*- python -*- # # OpenAlea.OALab: Multi-Paradigm GUI # # Copyright 2013 INRIA - CIRAD - INRA # # File author(s): Julien Coste <*****@*****.**> # # File contributor(s): # # Distributed under the Cecill-C License. # See accompanying file LICENSE.txt or copy at # http://www.cecill.info/licences/Licence_CeCILL-C_V1-en.html # # OpenAlea WebSite : http://openalea.gforge.inria.fr # ############################################################################### __revision__ = "" from openalea.core.pkgmanager import PackageManager package_manager = PackageManager() package_manager.init(verbose=False)
"""adel dataflow Tests""" __license__ = "Cecill-C" __revision__ = " $Id: $" from openalea.core.alea import run from openalea.core.pkgmanager import PackageManager from random import random, randint """ A unique PackageManager is created for all test of dataflow """ pm = PackageManager() pm.init(verbose=False) def test_adelr1(): """ Test AdelR MonoRun """ res = run(('alinea.adel.tutorials', 'AdelR MonoRun'), inputs={}, pm=pm, vtx_id=13) # to be repaired # def test_adelr2(): # """ Test AdelR MonoRun """ # res = run(('alinea.adel.tutorials', 'AdelR MonoRun'), # inputs={}, pm=pm, vtx_id=39) # # # def test_arvalis(): # """ Test Leaf db Explorer """ # res = run(('alinea.adel.tutorials', 'Leaf db Explorer'),
from openalea.core.service.model import ModelFactory from openalea.oalab.gui.paradigm.python import PythonModelController from openalea.oalab.gui.paradigm.visualea import VisualeaModelController from openalea.oalab.world.world import World from openalea.oalab.service.paradigm import paradigm_controller from openalea.vpltk.qt import QtGui from openalea.core.service.ipython import interpreter interp = interpreter() interp.user_ns['interp'] = interp pm = PackageManager() pm.init() def composite_node(): inputs = [] outputs = [] for io in list('abcd'): inputs.append({ 'name': io, 'desc': 'Input %s' % io.upper(), 'value': 0 }) outputs.append({'name': io, 'desc': 'Input %s' % io.upper()}) sg = CompositeNode(inputs=inputs, outputs=outputs)
def retrievePackage(self, name): pm = PackageManager() pm.init(self.dir, False) pkg = pm[name] return pkg