def test_data(): """test data""" pm = PackageManager() pm.init() assert pm['pkg_test']['file1.txt'] assert pm['pkg_test']['file2.txt']
def test_register(): """Test register""" pkgmanager = PackageManager() register_packages(pkgmanager) assert "test" in pkgmanager.keys() pkg = pkgmanager["Test"] assert "sum" in pkg.keys() assert "userclass" in pkg.keys() assert "userfunc" in pkg.keys() fact = pkg["sum"] node = fact.instantiate() assert (node.get_nb_input() == 1) and (node.get_nb_output() == 1) fact = pkg["userfunc"] node = fact.instantiate() assert (node.get_nb_input() == 2) and (node.get_nb_output() == 1) fact = pkg["userclass"] node = fact.instantiate() assert (node.get_nb_input() == 2) and (node.get_nb_output() == 1)
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 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_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_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_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 mimeData(self, modelIndexes): item = self.itemFromIndex(modelIndexes[0]) mimeData = QtGui.QStandardItemModel.mimeData(self, modelIndexes) (pkg_id, factory_id, mimetype) = self.get_item_info(item) # -- marshall package and factory to the data stream, needed later -- itemData = QtCore.QByteArray() dataStream = QtCore.QDataStream(itemData, QtCore.QIODevice.WriteOnly) dataStream.writeString(pkg_id) dataStream.writeString(factory_id) mimeData.setData(mimetype, itemData) # -- build an url -- factory = PackageManager()[pkg_id][factory_id] if isinstance(factory, DataFactory): url = QtCore.QUrl.fromLocalFile(factory.get_pkg_data().repr) else: query = ["fac="+factory_id] ftname = type(factory).__name__ query.append("ft="+ftname) query = reduce(lambda x,y:"&".join((x,y)), query) url = QtCore.QUrl("oa://local/"+pkg_id+"?"+query) mimeData.setUrls([url]) return mimeData
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_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_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_addnode(): """Test node addition""" pm = PackageManager() pm.init() sg = CompositeNode() # build the compositenode factory val1id = sg.add_node(pm.get_node("Catalog.Data", "float")) val2id = sg.add_node(pm.get_node("Catalog.Data", "float")) sg.connect(val1id, 0, val2id, 0) sgfactory = CompositeNodeFactory("testaddnode") sg.to_factory(sgfactory) # allocate the compositenode sg = sgfactory.instantiate() sg.node(val1id).set_input(0, 2.) sg() assert sg.node(val2id).get_output(0)==2. # Add a new node addid = sg.add_node(pm.get_node("Catalog.Math", "+")) sg.connect(val1id, 0, addid, 0) sg.connect(val2id, 0, addid, 1) sg.to_factory(sgfactory) sg = sgfactory.instantiate() sg.node(val1id).set_input(0, 3.) sg() assert sg.node(addid).get_output(0)==6.
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_search(): pkgman = PackageManager() pkgman.load_directory("./") assert 'Test' in pkgman res = pkgman.search_node("sum") print res assert "sum" in res[0].name
def __init__(self, parent): from node_treeview import SearchListView, SearchModel qt.QtGui.QDialog.__init__(self, parent) ui_nodechooser.Ui_NodeChooser.__init__(self) self.setupUi(self) self.pman = PackageManager() self.map = {}
def test_alias(): """test_alias: aliases in PackageManager""" pkgman = PackageManager() pkgman.load_directory("pkg") assert pkgman["pkg_test"]["file2.txt"] assert pkgman["pkg_test"]["file2.txt"] is pkgman["pkg_test"]["f"] assert pkgman["pkg_test"]["file2.txt"] is pkgman["pkg_test"]["g"] assert pkgman["pkg_test"]["file1.txt"] assert pkgman["pkg_test"]["aliasf1"] is pkgman["pkg_test"]["file1.txt"]
def setup_method(self, testfun): d = {} exec(compile_file(pj(test_dir(), 'catalog.py')), globals(), d) self.pkg = d['pkg'] self.plus_node = self.pkg['plus'].instantiate() self.float_node = self.pkg['float'].instantiate() self.int_node = self.pkg['int'].instantiate() self.string_node = self.pkg['string'].instantiate() self.pm = PackageManager() self.pm.add_package(self.pkg)
def setUp(self): d= {} execfile('catalog.py', globals(), d) self.pkg = d['pkg'] self.plus_node= self.pkg['plus'].instantiate() self.float_node= self.pkg['float'].instantiate() self.int_node= self.pkg['int'].instantiate() self.string_node= self.pkg['string'].instantiate() self.pm = PackageManager() self.pm.add_package(self.pkg)
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_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 get_data(pattern='*.*', pkg_name=None, as_paths=False): """ Return all data that match the pattern """ from openalea.core.pkgmanager import PackageManager pm = PackageManager() result = pm.get_data(pattern, pkg_name, as_paths) nodes = [x.instantiate() for x in result] for node in nodes: node.eval() names = [x.name for x in result] filenames = [node.get_output(0) for node in nodes] return dict(zip(names, filenames))
def get_data(pattern='*.*', pkg_name=None, as_paths=False): """ Return all data that match the pattern """ from openalea.core.pkgmanager import PackageManager pm = PackageManager() result = pm.get_data(pattern, pkg_name, as_paths) nodes = [x.instantiate() for x in result] for node in nodes: node.eval() names = [x.name for x in result] filenames = [node.get_output(0) for node in nodes] return dict(list(zip(names, filenames)))
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_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 valid_search_path(self): """ Set the search path in the package manager """ pkgmanager = PackageManager() pkgmanager.user_wralea_path.clear() for i in xrange(self.pathList.count()): path = self.pathList.item(i).text() pkgmanager.add_wralea_path(os.path.abspath(str(path)), pkgmanager.user_wralea_path) pkgmanager.write_config()
def test_write_config(): pkgman = PackageManager() pkgman.load_directory("./") pkgman.write_config() p = pkgman.user_wralea_path s = Settings() path = s.get("pkgmanager", "path") paths = list(eval(path)) # path is a string assert set(paths) == set(p)
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 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 node_factory_drop_handler(self, event): """ Drag and Drop from the PackageManager """ mimedata = event.mimeData() if mimedata.hasFormat(NodeFactory.mimetype) or mimedata.hasFormat(CompositeNodeFactory.mimetype): format = NodeFactory.mimetype if mimedata.hasFormat( NodeFactory.mimetype) else CompositeNodeFactory.mimetype # -- retreive the data from the event mimeData -- pieceData = event.mimeData().data(format) dataStream = qt.QtCore.QDataStream(pieceData, qt.QtCore.QIODevice.ReadOnly) package_id = str(dataStream.readString()) factory_id = str(dataStream.readString()) # -- find node factory -- pkgmanager = PackageManager() pkg = pkgmanager[str(package_id)] factory = pkg.get_factory(str(factory_id)) # -- see if we can safely open this factory (with user input) -- if not self.__check_factory(factory): return # -- instantiate the new node at the given position -- position = self.mapToScene(event.pos()) self.__drop_from_factory(factory, [position.x(), position.y()]) event.setDropAction(qt.QtCore.Qt.MoveAction)
def instantiate_node(self, vid, call_stack=None): """ Partial instantiation instantiate only elt_id in CompositeNode :param call_stack: a list of parent id (to avoid infinite recursion) """ (package_id, factory_id) = self.elt_factory[vid] pkgmanager = PackageManager() pkg = pkgmanager[package_id] factory = pkg.get_factory(factory_id) node = factory.instantiate(call_stack) attributes = copy.deepcopy(self.elt_data[vid]) ad_hoc = copy.deepcopy(self.elt_ad_hoc.get(vid, None)) self.load_ad_hoc_data(node, attributes, ad_hoc) # copy node input data if any values = copy.deepcopy(self.elt_value.get(vid, ())) for vs in values: try: #the two first elements are the historical #values : port Id and port value #the values beyond are not used. port, v = vs[:2] node.set_input(port, eval(v)) node.input_desc[port].get_ad_hoc_dict().set_metadata( "hide", node.is_port_hidden(port)) except: continue return node
def monkey_patch_instantiate_node(self, vid, call_stack=None): (package_id, factory_id) = self.elt_factory[vid] # my temporary patch if package_id in (None, ":projectmanager.current"): factory = ModelNodeFactory(factory_id) else: pkgmanager = PackageManager() pkg = pkgmanager[package_id] factory = pkg.get_factory(factory_id) node = factory.instantiate(call_stack) if node is None: node = self.create_fake_node(vid) return node attributes = copy.deepcopy(self.elt_data[vid]) ad_hoc = copy.deepcopy(self.elt_ad_hoc.get(vid, None)) self.load_ad_hoc_data(node, attributes, ad_hoc) # copy node input data if any values = copy.deepcopy(self.elt_value.get(vid, ())) for vs in values: try: # the two first elements are the historical # values : port Id and port value # the values beyond are not used. port, v = vs[:2] node.set_input(port, eval(v)) node.input_desc[port].get_ad_hoc_dict().set_metadata("hide", node.is_port_hidden(port)) except: continue return node
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 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 __call__(self, inputs): """ inputs is the list of input values :param inputs: a package name :returns: path of the package wralea """ pname = str(inputs[0]) from openalea.core.pkgmanager import PackageManager pm = PackageManager() pkg = pm.get(pname) p = '' if pkg: p = pkg.path return (p, )
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 reopen_last(self, action): """Reopen a last open node. """ gr = str(action.text()).split(".") pkgid = ".".join(gr[:-1]) name = gr[-1] manager = PackageManager() factory = manager[pkgid][name] self.open_compositenode(factory)
def test_export(): """test export""" d = {} with open("catalog.py") as f: code = compile(f.read(), "catalog.py", 'exec') exec(code, globals(), d) #execfile('catalog.py', globals(), d) pkg = d['pkg'] plus_node = pkg['plus'].instantiate() float_node = pkg['float'].instantiate() int_node = pkg['int'].instantiate() string_node = pkg['string'].instantiate() pm = PackageManager() pm.add_package(pkg) sg = CompositeNode() # build the compositenode factory addid = sg.add_node(plus_node) val1id = sg.add_node(float_node) val2id = sg.add_node(float_node) val3id = sg.add_node(float_node) 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) export_app.export_app("ADD", "app.py", sgfactory) f = open("app.py") assert f import app # requires X server # app.main(sys.argv) f.close() os.remove("app.py") try: os.remove("app.pyc") except: pass
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 __call__(self, inputs): """ :param inputs: list of input values :returns: The Path of the package wralea """ print "This node is DEPRECATED. Use %s instead" % \ "Catalog.File.PackageDir" pname = str(inputs[0]) from openalea.core.pkgmanager import PackageManager pm = PackageManager() pkg = pm.get(pname) path = '' if pkg : path = pkg.path return (path, )
def __init__(self): Observed.__init__(self) self.workspaces = [] self.cworkspace = -1 # current workspace self.graphViews = weakref.WeakKeyDictionary() self.datapool = DataPool() # Use dictionary self.use_by_name = {} self.use_by_interface = {} self.pkgmanager = PackageManager() self.empty_cnode_factory = CompositeNodeFactory("Workspace") self.clipboard = CompositeNodeFactory("Clipboard") self.init()
def __call__(self, inputs): """ :param inputs: list of input values :returns: The Path of the package wralea """ print "This node is DEPRECATED. Use %s instead" % \ "Catalog.File.PackageDir" pname = str(inputs[0]) from openalea.core.pkgmanager import PackageManager pm = PackageManager() pkg = pm.get(pname) path = '' if pkg: path = pkg.path return (path, )
class DT_Text(DataReader): __name__ = "Text" __created_mimetype__ = "text/plain" __opened_mimetypes__ = [ "text/plain", "application/x-qt-windows-mime;value=\"FileName\"", NodeFactory.mimetype, CompositeNodeFactory.mimetype ] __icon_rc__ = ":icons/text.png" def __init__(self): DataReader.__init__(self) self.pm = PackageManager() def new(self): text = "" name = self.__name__ return self.wrap_data(name, text) def open_url(self, parsedUrl): url = parsedUrl.geturl() if parsedUrl.scheme == "oa": fac = self.pm.get_factory_from_url(parsedUrl) if isinstance(fac, CompositeNodeFactory): pkg = self.pm.get_package_from_url(parsedUrl)[0] name = pkg.get_wralea_path() else: mod_name = fac.get_node_module() name = inspect.getsourcefile(mod_name) f = open(name) elif parsedUrl.scheme == "file": name = file_url_to_path(url) #name = parsedUrl.path#.strip("/") f = open(name) else: f = urllib2.urlopen(url) name = parsedUrl.path text = f.read() f.close() return self.wrap_data(name, text)
class DT_Text(DataReader): __name__ = "Text" __created_mimetype__ = "text/plain" __opened_mimetypes__ = ["text/plain", "application/x-qt-windows-mime;value=\"FileName\"", NodeFactory.mimetype, CompositeNodeFactory.mimetype] __icon_rc__ = ":icons/text.png" def __init__(self): DataReader.__init__(self) self.pm = PackageManager() def new(self): text = "" name = self.__name__ return self.wrap_data(name, text) def open_url(self, parsedUrl): url = parsedUrl.geturl() if parsedUrl.scheme == "oa": fac = self.pm.get_factory_from_url(parsedUrl) if isinstance(fac, CompositeNodeFactory): pkg = self.pm.get_package_from_url(parsedUrl)[0] name = pkg.get_wralea_path() else: mod_name = fac.get_node_module() name = inspect.getsourcefile(mod_name) f = open(name) elif parsedUrl.scheme == "file": name = file_url_to_path(url) #name = parsedUrl.path#.strip("/") f = open(name) else: f = urllib2.urlopen(url) name = parsedUrl.path text = f.read() f.close() return self.wrap_data(name, text)