def test_data():
"""test data"""
pm = PackageManager()
pm.init()
assert pm['pkg_test']['file1.txt']
assert pm['pkg_test']['file2.txt']
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 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_data():
"""test data"""
pm = PackageManager()
pm.init()
assert pm['pkg_test']['file1.txt']
assert pm['pkg_test']['file2.txt']
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_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_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_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 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_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_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_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_addnode():
"""Test node addition"""
pm = PackageManager()
pm.init()
sg = CompositeNode()
# build the compositenode factory
val1id = sg.add_node(pm.get_node("Catalog.Data", "float"))
val2id = sg.add_node(pm.get_node("Catalog.Data", "float"))
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(pm.get_node("Catalog.Math", "+"))
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 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_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_search():
pkgman = PackageManager()
pkgman.load_directory("./")
assert 'Test' in pkgman
res = pkgman.search_node("sum")
print res
assert "sum" in res[0].name
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 __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 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 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_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_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 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(zip(names, filenames))
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 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 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 valid_search_path(self):
""" Set the search path in the package manager """
pkgmanager = PackageManager()
pkgmanager.user_wralea_path.clear()
for i in xrange(self.pathList.count()):
path = self.pathList.item(i).text()
pkgmanager.add_wralea_path(os.path.abspath(str(path)), pkgmanager.user_wralea_path)
pkgmanager.write_config()
def test_write_config():
pkgman = PackageManager()
pkgman.load_directory("./")
pkgman.write_config()
p = pkgman.user_wralea_path
s = Settings()
path = s.get("pkgmanager", "path")
paths = list(eval(path)) # path is a string
assert set(paths) == set(p)
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 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 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 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 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_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 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 __call__(self, inputs):
""" inputs is the list of input values
:param inputs: a package name
:returns: path of the package wralea
"""
pname = str(inputs[0])
from openalea.core.pkgmanager import PackageManager
pm = PackageManager()
pkg = pm.get(pname)
p = ''
if pkg:
p = pkg.path
return (p, )
def __call__(self, inputs):
""" inputs is the list of input values
:param inputs: a package name
:returns: path of the package wralea
"""
pname = str(inputs[0])
from openalea.core.pkgmanager import PackageManager
pm = PackageManager()
pkg = pm.get(pname)
p = ''
if pkg:
p = pkg.path
return (p, )
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 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 __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 test_export():
"""test export"""
d = {}
with open("catalog.py") as f:
code = compile(f.read(), "catalog.py", 'exec')
exec(code, globals(), d)
#execfile('catalog.py', globals(), d)
pkg = d['pkg']
plus_node = pkg['plus'].instantiate()
float_node = pkg['float'].instantiate()
int_node = pkg['int'].instantiate()
string_node = pkg['string'].instantiate()
pm = PackageManager()
pm.add_package(pkg)
sg = CompositeNode()
# build the compositenode factory
addid = sg.add_node(plus_node)
val1id = sg.add_node(float_node)
val2id = sg.add_node(float_node)
val3id = sg.add_node(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)
export_app.export_app("ADD", "app.py", sgfactory)
f = open("app.py")
assert f
import app
# requires X server
# app.main(sys.argv)
f.close()
os.remove("app.py")
try:
os.remove("app.pyc")
except:
pass
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 __call__(self, inputs):
"""
:param inputs: list of input values
:returns: The Path of the package wralea
"""
print "This node is DEPRECATED. Use %s instead" % \
"Catalog.File.PackageDir"
pname = str(inputs[0])
from openalea.core.pkgmanager import PackageManager
pm = PackageManager()
pkg = pm.get(pname)
path = ''
if pkg :
path = pkg.path
return (path, )
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 __call__(self, inputs):
"""
:param inputs: list of input values
:returns: The Path of the package wralea
"""
print "This node is DEPRECATED. Use %s instead" % \
"Catalog.File.PackageDir"
pname = str(inputs[0])
from openalea.core.pkgmanager import PackageManager
pm = PackageManager()
pkg = pm.get(pname)
path = ''
if pkg:
path = pkg.path
return (path, )
class DT_Text(DataReader):
__name__ = "Text"
__created_mimetype__ = "text/plain"
__opened_mimetypes__ = [
"text/plain", "application/x-qt-windows-mime;value=\"FileName\"",
NodeFactory.mimetype, CompositeNodeFactory.mimetype
]
__icon_rc__ = ":icons/text.png"
def __init__(self):
DataReader.__init__(self)
self.pm = PackageManager()
def new(self):
text = ""
name = self.__name__
return self.wrap_data(name, text)
def open_url(self, parsedUrl):
url = parsedUrl.geturl()
if parsedUrl.scheme == "oa":
fac = self.pm.get_factory_from_url(parsedUrl)
if isinstance(fac, CompositeNodeFactory):
pkg = self.pm.get_package_from_url(parsedUrl)[0]
name = pkg.get_wralea_path()
else:
mod_name = fac.get_node_module()
name = inspect.getsourcefile(mod_name)
f = open(name)
elif parsedUrl.scheme == "file":
name = file_url_to_path(url)
#name = parsedUrl.path#.strip("/")
f = open(name)
else:
f = urllib2.urlopen(url)
name = parsedUrl.path
text = f.read()
f.close()
return self.wrap_data(name, text)
class DT_Text(DataReader):
__name__ = "Text"
__created_mimetype__ = "text/plain"
__opened_mimetypes__ = ["text/plain",
"application/x-qt-windows-mime;value=\"FileName\"",
NodeFactory.mimetype,
CompositeNodeFactory.mimetype]
__icon_rc__ = ":icons/text.png"
def __init__(self):
DataReader.__init__(self)
self.pm = PackageManager()
def new(self):
text = ""
name = self.__name__
return self.wrap_data(name, text)
def open_url(self, parsedUrl):
url = parsedUrl.geturl()
if parsedUrl.scheme == "oa":
fac = self.pm.get_factory_from_url(parsedUrl)
if isinstance(fac, CompositeNodeFactory):
pkg = self.pm.get_package_from_url(parsedUrl)[0]
name = pkg.get_wralea_path()
else:
mod_name = fac.get_node_module()
name = inspect.getsourcefile(mod_name)
f = open(name)
elif parsedUrl.scheme == "file":
name = file_url_to_path(url)
#name = parsedUrl.path#.strip("/")
f = open(name)
else:
f = urllib2.urlopen(url)
name = parsedUrl.path
text = f.read()
f.close()
return self.wrap_data(name, text)
