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_recursion_factory(self):
""" Test Recursion detection"""
pm = self.pm
#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_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_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_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_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_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_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_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_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():
""" 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_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 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_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_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_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_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_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 set_code(self, code):
self._initial_code = code
if not code:
self._workflow = CompositeNodeFactory(self.name).instantiate()
elif isinstance(code, CompositeNodeFactory):
# hakishhh
# CompositeNodeFactory.instantiate_node = monkey_patch_instantiate_node
self._workflow = code.instantiate()
else:
# Access to the current project
cnf = eval(code, globals(), locals())
# hakishhh
CompositeNodeFactory.instantiate_node = monkey_patch_instantiate_node
# raise IOError(cnf)
self._workflow = cnf.instantiate()
def instantiate_widget(self):
self._widget = dataflowview.GraphicalGraph.create_view(self.model._workflow, clone=True)
self._clipboard = CompositeNodeFactory("Clipboard")
from openalea.core.service.ipython import interpreter
interp = interpreter()
GraphOperator.globalInterpreter = interp
self._operator = GraphOperator(graph=self.model._workflow,
graphScene=self._widget.scene(),
clipboard=self._clipboard,
)
self._widget.mainMenu = types.MethodType(mainMenu, self._widget)
self._widget.applet = self
self._widget._actions = None
methods = {}
methods['actions'] = actions
methods['mainMenu'] = mainMenu
methods['display_help'] = _display_help
self._widget = adapt_widget(self._widget, methods)
if not VIEWER3D_SET:
_set_viewer3d()
# todo: use services
self.widget().scene().focusedItemChanged.connect(self.item_focus_change)
return self.widget()
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 __get_current_factory(self, name):
""" Build a temporary factory for current workspace
Return (node, factory)
"""
master = self.master
tempfactory = CompositeNodeFactory(name=name)
graph = master.get_graph()
graph.to_factory(tempfactory)
return (graph, tempfactory)
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 __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 repr_code(self):
"""
:return: a string representation of model to save it on disk
"""
name = self.name
if name[-3:] in ".py":
name = name[-3:]
elif name[-4:] in ".wpy":
name = name[-4:]
cn = self._workflow
cnf = CompositeNodeFactory(name)
cn.to_factory(cnf)
repr_wf = repr(cnf.get_writer())
# hack to allow eval rather than exec...
# TODO: change the writer
repr_wf = (" = ").join(repr_wf.split(" = ")[1:])
return repr_wf
def repr_code(self):
"""
:return: a string representation of model to save it on disk
"""
name = self.name
if name[-3:] in '.py':
name = name[-3:]
elif name[-4:] in '.wpy':
name = name[-4:]
cn = self._workflow
cnf = CompositeNodeFactory(name)
cn.to_factory(cnf)
repr_wf = repr(cnf.get_writer())
# hack to allow eval rather than exec...
# TODO: change the writer
repr_wf = (' = ').join(repr_wf.split(' = ')[1:])
return repr_wf
def set_code(self, code):
self._initial_code = code
if not code:
self._workflow = CompositeNodeFactory(self.name).instantiate()
elif isinstance(code, CompositeNodeFactory):
# hakishhh
# CompositeNodeFactory.instantiate_node = monkey_patch_instantiate_node
self._workflow = code.instantiate()
else:
# Access to the current project
cnf = eval(code, globals(), locals())
# hakishhh
CompositeNodeFactory.instantiate_node = monkey_patch_instantiate_node
# raise IOError(cnf)
self._workflow = cnf.instantiate()
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 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 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 __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 __init__(self,
graph,
graphScene=None,
clipboard=None,
siblings=None,
interpreter=None,
graphAdapter=None):
Observed.__init__(self)
do_imports()
configure_dataflow_types()
self.__ops = [
dataflow.DataflowOperators(self),
layout.LayoutOperators(self),
color.ColorOperators(self),
vertex.VertexOperators(self),
port.PortOperators(self),
anno.AnnotationOperators(self)
]
self.__availableNames = {}
for operator in self.__ops:
for meth in dir(operator):
self.__availableNames[meth] = getattr(operator, meth)
self.__graph = graph
self.__adapter = graphAdapter
self.__scene = graphScene
self.__clipboard = clipboard or CompositeNodeFactory("Clipboard")
self.__siblings = siblings or []
self.__interpreter = interpreter or GraphOperator.globalInterpreter
# when working on current item these can be set
self.__vertexItem = None
self.__annotationItem = None
self.__portItem = None
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
class Session(Observed):
"""
A session is composed by different workspaces, and an user package.
A workspace is an open node
A session can be saved on disk.
"""
USR_PKG_NAME = "__my package__"
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()
# gengraph
def simulate_workspace_addition(self):
for ws in self.workspaces:
self.notify_listeners(("workspace_added", ws))
#/gengraph
def get_current_workspace(self, ):
""" Return the current workspace object """
return self.workspaces[self.cworkspace]
ws = property(get_current_workspace)
def get_graph_views(self):
return self.graphViews.keys()
def add_graph_view(self, view):
self.graphViews[view] = None
def add_workspace(self, compositenode=None, notify=True):
"""
Open a new workspace in the session
if compositenode = None, create a new empty compositenode
"""
if compositenode is None:
compositenode = self.empty_cnode_factory.instantiate()
compositenode.set_caption("")
self.workspaces.append(compositenode)
elif(compositenode not in self.workspaces):
self.workspaces.append(compositenode)
else:
return compositenode
if(notify):
self.notify_listeners(("workspace_added", compositenode))
return compositenode
def close_workspace(self, index, notify=True):
""" Close workspace at index """
del self.workspaces[index]
if(notify):
self.notify_listeners()
def init(self, create_workspace=True):
""" Init the Session """
self.session_filename = None
#self.workspaces = []
# init pkgmanager
self.pkgmanager.find_and_register_packages()
# Create user package if needed
if (not self.pkgmanager.has_key(self.USR_PKG_NAME)):
try:
self.pkgmanager.create_user_package(self.USR_PKG_NAME, {})
except:
pass
if (create_workspace):
self.add_workspace()
self.cworkspace = 0
load_interfaces()
self.notify_listeners()
def clear(self, create_workspace=True):
""" Reinit Session """
self.datapool.clear()
self.pkgmanager.clear()
self.init(create_workspace)
def save(self, filename=None):
"""
Save session in filename
user_pkg and workspaces data are saved
Be careful, this method do not work very well if data are not
persistent.
"""
if (filename):
self.session_filename = filename
d = shelve.open(self.session_filename, writeback=True)
# modules
modules_path = []
for k in sys.modules.keys():
m = sys.modules[k]
if hasattr(m, '__file__'):
modules_path.append((m.__name__, os.path.abspath(m.__file__)))
d['__modules__'] = modules_path
d.sync()
# datapool
d['datapool'] = {}
for key in self.datapool:
try:
d['datapool'][key] = self.datapool[key]
d.sync()
except Exception, e:
print e
print "Unable to save %s in the datapool..." % str(key)
del d['datapool'][key]
# workspaces
d['workspaces'] = []
for cpt, ws in enumerate(self.workspaces):
try:
d['workspaces'].append(ws)
d.sync()
except Exception, e:
print e
print "Unable to save workspace %i. Skip this." % (cpt, )
print " WARNING: Your session is not saved. Please save your dataflow as a composite node !!!!!"
d['workspaces'].pop()
def __init__(self, **kwargs):
name = kwargs.get("name", "Workflow")
kwargs["name"] = name
self._workflow = CompositeNodeFactory(name).instantiate()
super(VisualeaModel, self).__init__(**kwargs)
class VisualeaModel(Model):
default_name = "Workflow"
default_file_name = "workflow.wpy"
pattern = "*.wpy"
extension = "wpy"
icon = ":/images/resources/openalealogo.png"
dtype = default_name
mimetype = "text/x-visualea"
def __init__(self, **kwargs):
name = kwargs.get("name", "Workflow")
kwargs["name"] = name
self._workflow = CompositeNodeFactory(name).instantiate()
super(VisualeaModel, self).__init__(**kwargs)
def get_documentation(self):
"""
:return: docstring of current workflow
"""
if hasattr(self._workflow, "get_tip"):
self._doc = self._workflow.get_tip()
return self._doc
def repr_code(self):
"""
:return: a string representation of model to save it on disk
"""
name = self.name
if name[-3:] in ".py":
name = name[-3:]
elif name[-4:] in ".wpy":
name = name[-4:]
cn = self._workflow
cnf = CompositeNodeFactory(name)
cn.to_factory(cnf)
repr_wf = repr(cnf.get_writer())
# hack to allow eval rather than exec...
# TODO: change the writer
repr_wf = (" = ").join(repr_wf.split(" = ")[1:])
return repr_wf
def eval_value(self, value):
return value
def _outputs(self):
outputs = []
for i, outobj in enumerate(self.outputs_info):
out = self._workflow.get_output(i)
outputs.append(out)
self._ns[outobj.name] = out
if len(outputs) == 0:
return None
elif len(outputs) == 1:
return outputs[0]
else:
return outputs
def _set_inputs(self, *args, **kwargs):
self._ns = self.inputs_from_ns(self.inputs_info, self._ns, *args, **kwargs)
for i, inp in enumerate(self.inputs_info):
self._workflow.set_input(i, self._ns[inp.name])
def run(self, *args, **kwargs):
"""
execute entire model
"""
self.init(*args, **kwargs)
self._workflow.eval()
outputs = self._outputs()
return outputs
def namespace(self, **kwargs):
from openalea.core.service.run import namespace
return namespace(self, **kwargs)
def init(self, *args, **kwargs):
"""
go back to initial step
"""
user_ns = kwargs.pop("namespace", {})
self._ns = user_ns
self._ns.update(self.namespace())
self._set_inputs(*args, **kwargs)
return self._outputs()
def step(self, *args, **kwargs):
"""
execute only one step of the model
"""
raise NotImplementedError
self._set_inputs()
self._workflow.eval_as_expression()
return self._outputs()
def stop(self, *args, **kwargs):
"""
stop execution
"""
# TODO : to implement
pass
def animate(self, *args, **kwargs):
"""
run model step by step
"""
return self._workflow.eval()
def execute(self, code=None):
"""
In other paradigms: Execute code (str).
Here this method does not have signification (only for "script-like" paradigm), so, it make a **run**.
"""
return self.run()
def set_code(self, code):
self._initial_code = code
if not code:
self._workflow = CompositeNodeFactory(self.name).instantiate()
elif isinstance(code, CompositeNodeFactory):
# hakishhh
# CompositeNodeFactory.instantiate_node = monkey_patch_instantiate_node
self._workflow = code.instantiate()
else:
# Access to the current project
cnf = eval(code, globals(), locals())
# hakishhh
CompositeNodeFactory.instantiate_node = monkey_patch_instantiate_node
# raise IOError(cnf)
self._workflow = cnf.instantiate()
@property
def inputs_info(self):
inputs = []
for inp in self._workflow.input_desc:
inpobj = InputObj()
inpobj.name = inp.get("name", None)
inpobj.interface = inp.get("interface", None)
inpobj.default = inp.get("value", None)
inputs.append(inpobj)
return inputs
@inputs_info.setter
def inputs_info(self, inputs):
self._workflow.clear_inputs()
for inp in inputs:
self._workflow.add_input(name=inp.name, value=inp.default, interface=inp.interface)
@property
def outputs_info(self):
outputs = []
for out in self._workflow.output_desc:
outobj = OutputObj()
outobj.name = out.get("name", None)
outobj.interface = out.get("interface", None)
outobj.default = out.get("value", None)
outputs.append(outobj)
return outputs
@outputs_info.setter
def outputs_info(self, outputs):
self._workflow.clear_outputs()
for out in outputs:
self._workflow.add_output(name=out.name, value=out.default, interface=out.interface)
def __init__(self, **kwargs):
name = kwargs.get('name', 'Workflow')
kwargs['name'] = name
self._workflow = CompositeNodeFactory(name).instantiate()
super(VisualeaModel, self).__init__(**kwargs)
class VisualeaModel(Model):
default_name = "Workflow"
default_file_name = "workflow.wpy"
pattern = "*.wpy"
extension = "wpy"
icon = ":/images/resources/openalealogo.png"
dtype = default_name
mimetype = "text/x-visualea"
def __init__(self, **kwargs):
name = kwargs.get('name', 'Workflow')
kwargs['name'] = name
self._workflow = CompositeNodeFactory(name).instantiate()
super(VisualeaModel, self).__init__(**kwargs)
def get_documentation(self):
"""
:return: docstring of current workflow
"""
if hasattr(self._workflow, "get_tip"):
self._doc = self._workflow.get_tip()
return self._doc
def repr_code(self):
"""
:return: a string representation of model to save it on disk
"""
name = self.name
if name[-3:] in '.py':
name = name[-3:]
elif name[-4:] in '.wpy':
name = name[-4:]
cn = self._workflow
cnf = CompositeNodeFactory(name)
cn.to_factory(cnf)
repr_wf = repr(cnf.get_writer())
# hack to allow eval rather than exec...
# TODO: change the writer
repr_wf = (' = ').join(repr_wf.split(' = ')[1:])
return repr_wf
def eval_value(self, value):
return value
def _outputs(self):
outputs = []
for i, outobj in enumerate(self.outputs_info):
out = self._workflow.get_output(i)
outputs.append(out)
self._ns[outobj.name] = out
if len(outputs) == 0:
return None
elif len(outputs) == 1:
return outputs[0]
else:
return outputs
def _set_inputs(self, *args, **kwargs):
self._ns = self.inputs_from_ns(self.inputs_info, self._ns, *args, **kwargs)
for i, inp in enumerate(self.inputs_info):
self._workflow.set_input(i, self._ns[inp.name])
def run(self, *args, **kwargs):
"""
execute entire model
"""
self.init(*args, **kwargs)
self._workflow.eval()
outputs = self._outputs()
return outputs
def namespace(self, **kwargs):
from openalea.core.service.run import namespace
return namespace(self, **kwargs)
def init(self, *args, **kwargs):
"""
go back to initial step
"""
user_ns = kwargs.pop('namespace', {})
self._ns = user_ns
self._ns.update(self.namespace())
self._set_inputs(*args, **kwargs)
return self._outputs()
def step(self, *args, **kwargs):
"""
execute only one step of the model
"""
raise NotImplementedError
self._set_inputs()
self._workflow.eval_as_expression()
return self._outputs()
def stop(self, *args, **kwargs):
"""
stop execution
"""
# TODO : to implement
pass
def animate(self, *args, **kwargs):
"""
run model step by step
"""
return self._workflow.eval()
def execute(self, code=None):
"""
In other paradigms: Execute code (str).
Here this method does not have signification (only for "script-like" paradigm), so, it make a **run**.
"""
return self.run()
def set_code(self, code):
self._initial_code = code
if not code:
self._workflow = CompositeNodeFactory(self.name).instantiate()
elif isinstance(code, CompositeNodeFactory):
# hakishhh
# CompositeNodeFactory.instantiate_node = monkey_patch_instantiate_node
self._workflow = code.instantiate()
else:
# Access to the current project
cnf = eval(code, globals(), locals())
# hakishhh
CompositeNodeFactory.instantiate_node = monkey_patch_instantiate_node
# raise IOError(cnf)
self._workflow = cnf.instantiate()
@property
def inputs_info(self):
inputs = []
for inp in self._workflow.input_desc:
inpobj = InputObj()
inpobj.name = inp.get('name', None)
inpobj.interface = inp.get('interface', None)
inpobj.default = inp.get('value', None)
inputs.append(inpobj)
return inputs
@inputs_info.setter
def inputs_info(self, inputs):
self._workflow.clear_inputs()
for inp in inputs:
self._workflow.add_input(name=inp.name, value=inp.default, interface=inp.interface)
@property
def outputs_info(self):
outputs = []
for out in self._workflow.output_desc:
outobj = OutputObj()
outobj.name = out.get('name', None)
outobj.interface = out.get('interface', None)
outobj.default = out.get('value', None)
outputs.append(outobj)
return outputs
@outputs_info.setter
def outputs_info(self, outputs):
self._workflow.clear_outputs()
for out in outputs:
self._workflow.add_output(name=out.name, value=out.default, interface=out.interface)
def new(self):
iname = self.__name__
node = CompositeNodeFactory(iname).instantiate()
node.set_caption(iname)
return self.wrap_data(node.caption, node)
def start(self):
from openalea.visualea.graph_operator import GraphOperator
self.__clipboard = CompositeNodeFactory("Clipboard")
self.__siblings = SiblingList(CompositeNode.mimetype)
class Session(Observed):
"""
A session is composed by different workspaces, and an user package.
A workspace is an open node
A session can be saved on disk.
"""
USR_PKG_NAME = "__my package__"
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()
# gengraph
def simulate_workspace_addition(self):
for ws in self.workspaces:
self.notify_listeners(("workspace_added", ws))
#/gengraph
def get_current_workspace(self, ):
""" Return the current workspace object """
return self.workspaces[self.cworkspace]
ws = property(get_current_workspace)
def get_graph_views(self):
return self.graphViews.keys()
def add_graph_view(self, view):
self.graphViews[view] = None
def add_workspace(self, compositenode=None, notify=True):
"""
Open a new workspace in the session
if compositenode = None, create a new empty compositenode
"""
if compositenode is None:
compositenode = self.empty_cnode_factory.instantiate()
compositenode.set_caption("")
self.workspaces.append(compositenode)
elif (compositenode not in self.workspaces):
self.workspaces.append(compositenode)
else:
return compositenode
if (notify):
self.notify_listeners(("workspace_added", compositenode))
return compositenode
def close_workspace(self, index, notify=True):
""" Close workspace at index """
del self.workspaces[index]
if (notify):
self.notify_listeners()
def init(self, create_workspace=True):
""" Init the Session """
self.session_filename = None
#self.workspaces = []
# init pkgmanager
self.pkgmanager.find_and_register_packages()
# Create user package if needed
if (not self.pkgmanager.has_key(self.USR_PKG_NAME)):
try:
self.pkgmanager.create_user_package(self.USR_PKG_NAME, {})
except:
pass
if (create_workspace):
self.add_workspace()
self.cworkspace = 0
load_interfaces()
self.notify_listeners()
def clear(self, create_workspace=True):
""" Reinit Session """
self.datapool.clear()
self.pkgmanager.clear()
self.init(create_workspace)
def save(self, filename=None):
"""
Save session in filename
user_pkg and workspaces data are saved
Be careful, this method do not work very well if data are not
persistent.
"""
if (filename):
self.session_filename = filename
d = shelve.open(self.session_filename, writeback=True)
# modules
modules_path = []
for k in sys.modules.keys():
m = sys.modules[k]
if hasattr(m, '__file__'):
modules_path.append((m.__name__, os.path.abspath(m.__file__)))
d['__modules__'] = modules_path
d.sync()
# datapool
d['datapool'] = {}
for key in self.datapool:
try:
d['datapool'][key] = self.datapool[key]
d.sync()
except Exception, e:
print e
print "Unable to save %s in the datapool..." % str(key)
del d['datapool'][key]
# workspaces
d['workspaces'] = []
for cpt, ws in enumerate(self.workspaces):
try:
d['workspaces'].append(ws)
d.sync()
except Exception, e:
print e
print "Unable to save workspace %i. Skip this." % (cpt, )
print " WARNING: Your session is not saved. Please save your dataflow as a composite node !!!!!"
d['workspaces'].pop()