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 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_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_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_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_data():
"""test data"""
pm = PackageManager()
pm.init()
assert pm['pkg_test']['file1.txt']
assert pm['pkg_test']['file2.txt']
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_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_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_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_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_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_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)
"""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()
"""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 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"]
def retrievePackage(self, name):
pm = PackageManager()
pm.init(self.dir, False)
pkg = pm[name]
return pkg
