def test_compositenodeio(self):
""" Test IO"""
pm = self.pm
# 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(self.plus_node)
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(self.float_node)
val2id = sg.add_node(self.float_node)
val3id = sg.add_node(self.float_node)
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_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_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(self):
""" Test multiple out connection"""
sg = CompositeNode()
# build the compositenode factory
val1id = sg.add_node(self.string_node)
val2id = sg.add_node(self.string_node)
val3id = sg.add_node(self.string_node)
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_to_factory(self):
""" Create a compositenode, generate its factory and reintantiate it """
sg = CompositeNode()
n1 = self.float_node
n2 = self.float_node
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 sg, sgfactory
def test_auto_io(self):
""" Test auto io"""
sg = CompositeNode()
# build the compositenode factory
val1id = sg.add_node(self.string_node)
val2id = sg.add_node(self.string_node)
val3id = sg.add_node(self.string_node)
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_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_instantiate_compositenode(self):
"""test instantiation"""
#pm = PackageManager()
#pm.init()
sg = CompositeNode()
# build the compositenode factory
addid = sg.add_node(self.plus_node)
val1id = sg.add_node(self.float_node)
val2id = sg.add_node(self.float_node)
val3id = sg.add_node(self.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)
# 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(self):
""" Test multiple out connection"""
sg = CompositeNode()
# build the compositenode factory
val1id = sg.add_node(self.string_node)
val2id = sg.add_node(self.string_node)
val3id = sg.add_node(self.string_node)
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_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_addnode(self):
"""Test node addition"""
sg = CompositeNode()
# build the compositenode factory
val1id = sg.add_node(self.float_node)
val2id = sg.add_node(self.float_node)
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(self.plus_node)
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_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 test_change_io(self):
""" Test set_io"""
ins = [dict(name="in1"), dict(name="in2")]
outs = [dict(name="out1"), dict(name="out2")]
sg = CompositeNode(ins, outs)
assert sg.get_nb_input() == 2
assert sg.get_nb_output() == 2
ins = [dict(name="in1")]
outs = [dict(name="out1"), dict(name="out2"), dict(name="out3")]
sg.set_io(ins, outs)
assert sg.get_nb_input() == 1
assert sg.get_nb_output() == 3
def test_compositenode_creation_without_edges(self):
"""test compositenode creation without edges"""
sg = CompositeNode()
# build the compositenode factory
addid = sg.add_node(self.plus_node)
val1id = sg.add_node(self.float_node)
val2id = sg.add_node(self.float_node)
val3id = sg.add_node(self.float_node)
sgfactory = CompositeNodeFactory("addition")
sg.to_factory(sgfactory)
# allocate the compositenode
sg = sgfactory.instantiate()
assert len(sg) == 4+2
def read_specification(self):
spec = self.dir / 'specifications'
from openalea.core.compositenode import CompositeNodeFactory
from openalea.core.compositenode import CompositeNode
f = spec.open()
self.sg = CompositeNode()
#name = self.dir.basename().split('-')[-1]
name = self.dir.basename()
self.sgfactory = CompositeNodeFactory(name)
self.read_files(f)
self.read_commands(f)
self.process_files()
self.build_graph()
f.close()
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 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")
sg.to_factory(sgfactory)
return sgfactory
def composite_node(a=1, b=2):
pkg = package()
plus_node = pkg['plus'].instantiate()
int_node = pkg['int'].instantiate()
if a is None:
input_a = {'interface': IInt, 'name': 'a', 'desc': ''}
else:
input_a = {'interface': IInt, 'name': 'a', 'value': a, 'desc': ''}
if b is None:
input_b = {'interface': IInt, 'name': 'b', 'desc': ''}
else:
input_b = {'interface': IInt, 'name': 'b', 'value': b, 'desc': ''}
sg = CompositeNode(
inputs=[input_a, input_b],
outputs=[{
'interface': IInt,
'name': 'a',
'desc': 'result'
}],
)
# build the compositenode factory
addid = sg.add_node(plus_node)
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("addition")
sg.to_factory(sgfactory)
return sgfactory
