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_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_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_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 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 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_data(): """test data""" pm = PackageManager() pm.init() assert pm['pkg_test']['file1.txt'] assert pm['pkg_test']['file2.txt']
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_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 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_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_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 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 _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_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 __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 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_search(): pkgman = PackageManager() pkgman.load_directory("./") assert 'Test' in pkgman res = pkgman.search_node("sum") print res assert "sum" in res[0].name
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_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 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 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 graph_add_annotation(self, position=None): scene = self.master.get_graph_scene() # Add new node pkgmanager = PackageManager() pkg = pkgmanager["System"] factory = pkg.get_factory("annotation") realGraph = scene.get_graph() node = factory.instantiate([realGraph.factory.get_id()]) node.get_ad_hoc_dict().set_metadata("visualStyle", 1) scene.add_vertex(node, position=[position.x(), position.y()])
def __init__(self, wf, pmanager=None): """ Export a workflow into OpenAlea. :Parameters: - wf : an OpenAlea workflow (factory) """ self.wf = wf if pmanager is None: self.pmanager = PackageManager() else: self.pmanager = pmanager
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 get_pkg(self): """todo""" if(self.__pkg__): port = self.__pkg__() else: port = None # Test if pkg has been reloaded # In this case the weakref is not valid anymore if(not port and self.__pkg_id__): from openalea.core.pkgmanager import PackageManager port = self.set_pkg(PackageManager()[self.__pkg_id__]) return port