def start(self, *args, **kwargs):
"""
Load controls if available, execute all files in startup.
"""
self._load_controls()
self.started = True
self.ns.clear()
loading_code = [
'import sys',
'sys.path.insert(0, %r)' % str(self.path / 'lib')
]
loading_code = '\n'.join(loading_code)
loading = ModelFactory(mimetype='text/x-python')
ns = loading.run_code(loading_code, self.ns)
self.ns.update(ns)
self.ns['get_model'] = self.get_runnable_model
for startup in self.startup.values():
model = to_model(startup)
ns = model.run_code(startup.read(), self.ns)
self.ns.update(ns)
interpreter = kwargs.get('shell')
if interpreter:
#interpreter.shell.user_ns.clear()
interpreter.shell.init_user_ns()
interpreter.shell.user_ns.update(self.ns)
def __init__(self, **kwds):
self.parent = kwds.pop('parent', None)
self._widget = None
mode_name, name_value = check_mutually_exclusive(kwds, 'name', 'filepath')
mode_model, model_value = check_mutually_exclusive(kwds, 'model', 'data')
_, code = check_mutually_exclusive(kwds, 'code', 'content')
if name_value and model_value:
raise ValueError('model/data and filename/name/content/code are mutually exclusive')
if mode_name or mode_model:
self._type = Model
else:
self._type = Data
if name_value and self._type == Model:
self._obj = ModelFactory(name=name_value, mimetype=self.mimetype_model, code=code)
elif name_value and self._type == Data:
self._obj = DataFactory(path=name_value, mimetype=self.mimetype_data, default_content=code)
elif model_value:
self._obj = model_value
else:
self._obj = ModelFactory(name='NewModel', mimetype=self.mimetype_model)
self._type = Model
if self._type == Model:
self._model = self._obj
else:
self._model = to_model(self._obj)
def test_constructor():
model = ModelFactory(mimetype='text/x-python')
model.inputs_info = [InputObj('a'), InputObj('b')]
model.outputs_info = [OutputObj('c')]
model.set_step_code('c = a + b')
# Use a non existing directory to be sure data is not written on disk
data = DataFactory('/tmp/donotexists/test.py', default_content="print('I am a python file')")
c1 = "print('hello, I am a new model')"
c2 = "print('hello, I am a new data')"
kwds = [
dict(name='Model1', content=c1),
dict(filepath='/tmp/donotexists/test.py', content=c2),
dict(model=model),
dict(data=data),
]
controller = PythonModelController(**kwds[0])
assert controller.value() == c1
assert hasattr(controller.model, 'run')
controller = PythonModelController(**kwds[1])
assert controller.value() == c2
assert hasattr(controller.model, 'run')
assert hasattr(controller._obj, 'run') is False
controller = PythonModelController(**kwds[2])
assert controller._obj is model
assert hasattr(controller.model, 'run')
controller = PythonModelController(**kwds[3])
assert controller._obj is data
assert hasattr(controller.model, 'run')
def start(self, *args, **kwargs):
"""
Load controls if available, execute all files in startup.
"""
self._load_controls()
self.started = True
self.ns.clear()
loading_code = [
'import sys',
'sys.path.insert(0, %r)' % str(self.path / 'lib')
]
loading_code = '\n'.join(loading_code)
loading = ModelFactory(mimetype='text/x-python')
ns = loading.run_code(loading_code, self.ns)
self.ns.update(ns)
self.ns['get_model'] = self.get_runnable_model
for startup in self.startup.values():
model = to_model(startup)
ns = model.run_code(startup.read(), self.ns)
self.ns.update(ns)
interpreter = kwargs.get('shell')
if interpreter:
#interpreter.shell.user_ns.clear()
interpreter.shell.init_user_ns()
interpreter.shell.user_ns.update(self.ns)
def test_visualea_io():
factory = composite_node()
model = ModelFactory(mimetype='text/x-visualea', name='test_workflow_io')
model.set_code(factory)
controller = paradigm_controller(model)
new_control('a', 'IInt', 1)
new_control('b', 'IInt', 2)
interp.user_ns['c'] = 3
assert controller.run() == [1, 2, 3, 0]
assert controller.run(10) == [10, 2, 3, 0]
assert controller.run(d=5) == [1, 2, 3, 5]
def test_visualea_io():
factory = composite_node()
model = ModelFactory(mimetype='text/x-visualea', name='test_workflow_io')
model.set_code(factory)
controller = paradigm_controller(model)
new_control('a', 'IInt', 1)
new_control('b', 'IInt', 2)
interp.user_ns['c'] = 3
assert controller.run() == [1, 2, 3, 0]
assert controller.run(10) == [10, 2, 3, 0]
assert controller.run(d=5) == [1, 2, 3, 5]
def mouseDoubleClickEvent(self, event):
item = self.currentIndex()
obj = item.internalPointer()
if isinstance(obj, CompositeNodeFactory):
applet = get_applet(identifier="EditorManager")
if applet:
model = ModelFactory(dtype="Workflow", mimetype="text/x-visualea", code=obj)
cat, data = applet.add(
applet.project(), obj.name + ".wpy", code=model.repr_code(), category="model", dtype="Workflow"
)
applet.open_data(data)
elif not isinstance(obj, Package):
self.open_node()
def test_constructor():
model = ModelFactory(mimetype='text/x-python')
model.inputs_info = [InputObj('a'), InputObj('b')]
model.outputs_info = [OutputObj('c')]
model.set_step_code('c = a + b')
# Use a non existing directory to be sure data is not written on disk
data = DataFactory('/tmp/donotexists/test.py',
default_content="print('I am a python file')")
c1 = "print('hello, I am a new model')"
c2 = "print('hello, I am a new data')"
kwds = [
dict(name='Model1', content=c1),
dict(filepath='/tmp/donotexists/test.py', content=c2),
dict(model=model),
dict(data=data),
]
controller = PythonModelController(**kwds[0])
assert controller.value() == c1
assert hasattr(controller.model, 'run')
controller = PythonModelController(**kwds[1])
assert controller.value() == c2
assert hasattr(controller.model, 'run')
assert hasattr(controller._obj, 'run') is False
controller = PythonModelController(**kwds[2])
assert controller._obj is model
assert hasattr(controller.model, 'run')
controller = PythonModelController(**kwds[3])
assert controller._obj is data
assert hasattr(controller.model, 'run')
class ParadigmController(object):
default_name = unicode
default_file_name = unicode
pattern = unicode
extension = unicode
icon = unicode
mimetype_model = unicode
mimetype_data = unicode
def __init__(self, **kwds):
self.parent = kwds.pop('parent', None)
self._widget = None
mode_name, name_value = check_mutually_exclusive(kwds, 'name', 'filepath')
mode_model, model_value = check_mutually_exclusive(kwds, 'model', 'data')
_, code = check_mutually_exclusive(kwds, 'code', 'content')
if name_value and model_value:
raise ValueError('model/data and filename/name/content/code are mutually exclusive')
if mode_name or mode_model:
self._type = Model
else:
self._type = Data
if name_value and self._type == Model:
self._obj = ModelFactory(name=name_value, mimetype=self.mimetype_model, code=code)
elif name_value and self._type == Data:
self._obj = DataFactory(path=name_value, mimetype=self.mimetype_data, default_content=code)
elif model_value:
self._obj = model_value
else:
self._obj = ModelFactory(name='NewModel', mimetype=self.mimetype_model)
self._type = Model
if self._type == Model:
self._model = self._obj
else:
self._model = to_model(self._obj)
def read(self):
if self._widget is None:
return
content = self.value()
self.set_widget_value(content)
def apply(self):
if self._widget is None:
return
content = self.widget_value()
self.set_value(content)
def widget_value(self):
raise NotImplementedError
def value(self):
if self._type == Model:
content = self._obj.repr_code()
else:
content = self._obj.read()
return content
def set_widget_value(self, value):
raise NotImplementedError
def set_value(self, value):
if self._type == Model:
self._obj.set_code(value)
else:
self._obj.content = value
if self._model:
self._model.set_code(value)
def runnable(self):
return self._model is not None
def _get_model(self):
return self._model
model = property(fget=_get_model)
def execute(self):
raise NotImplementedError
def namespace(self, **kwargs):
from openalea.core.service.run import namespace
ns = namespace()
ns.update(kwargs)
return ns
def run(self, *args, **kwargs):
if self.runnable():
self.apply()
return self.model.run(*args, **self.namespace(**kwargs))
def step(self, nstep=1):
if self.runnable():
self.apply()
print self.model
return self.model.step(nstep=nstep)
def stop(self):
if self.runnable():
return self.model.stop()
def animate(self, *args, **kwargs):
if self.runnable():
self.apply()
return self.model.animate(*args, **self.namespace(**kwargs))
def init(self, *args, **kwargs):
if self.runnable():
self.apply()
return self.model.init(*args, **self.namespace(**kwargs))
def widget(self):
"""
:return: the edition widget
"""
return self._widget
name = property(fget=lambda self: self._obj.name)
def test_model_factory(self):
m = ModelFactory(name='MyModel', mimetype='text/vnd-lpy')
self.assertIsInstance(m, LPyModel)
self.assertEqual(m.name, "MyModel")
def test_model_factory(self):
m = ModelFactory(name='MyModel', mimetype='text/x-python')
self.assertIsInstance(m, PythonModel)
self.assertEqual(m.name, "MyModel")
