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
