def add_path_to_search_project(self):
fname = self.showOpenProjectDialog()
if fname:
pm = ProjectManager()
pm.repositories.append(fname)
pm.write_settings()
self.refresh_project_list()
def instantiate(self, call_stack=[]):
"""
Returns a node instance.
:param call_stack: the list of NodeFactory id already in call stack
(in order to avoir infinite recursion)
"""
from openalea.core.service.run import get_model
model = get_model(self.name)
if model is None:
print "error loading model ", self.name
# print "Available models are ", pm.cproject.model.keys()
# TODO
def signature(args_info, out=False):
args = []
if args_info:
for arg in args_info:
d = {}
d['name'] = arg.name
if arg.interface:
d['interface'] = arg.interface
if not out and arg.default is not None:
d['value'] = arg.default
if d:
args.append(d)
return args
# If class is not a Node, embed object in a Node class
if model:
# model.read()
self.inputs = signature(model.inputs_info)
self.outputs = signature(model.outputs_info, out=True)
if not self.outputs:
self.outputs = (dict(name="out", interface=None), )
node = ModelNode(model, self.inputs, self.outputs)
# Properties
try:
node.factory = self
node.lazy = self.lazy
if (not node.caption):
node.set_caption(self.name)
node.delay = self.delay
except:
pass
return node
else:
from openalea.core.project.manager import ProjectManager
pm = ProjectManager()
print "We can't instantiate node from project %s because we don't have model %s" % (
pm.cproject.name, self.name)
print "We only have models : "
print ", ".join(pm.cproject.model.keys())
def test_load_project():
from openalea.core.project.manager import ProjectManager
project_manager = ProjectManager()
project = project_manager.load('test_project', '.')
if not project.started:
project.start()
interp.user_ns['project_manager'] = project_manager
interp.user_ns['project'] = project
return True
def __init__(self):
QtGui.QTreeView.__init__(self)
self._model = ProjectManagerModel()
self.pm = ProjectManager()
self.setModel(self._model)
self._model.dataChanged.connect(self._on_model_changed)
self.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
self.connect(self, QtCore.SIGNAL('doubleClicked(const QModelIndex&)'),
self.open)
self.setHeaderHidden(True)
self.setDragEnabled(True)
self.setDropIndicatorShown(True)
self.setAcceptDrops(True)
self._actions = []
self._new_file_actions = {}
self.paradigms_actions = []
self.paradigms = {}
self.actionEditMeta = QtGui.QAction(qicon("book.png"),
"Edit Project Information", self)
self.actionEditMeta.triggered.connect(self.edit_metadata)
self.actionImportFile = QtGui.QAction(qicon("open.png"), "Import file",
self)
self.actionImportFile.triggered.connect(self.import_file)
self.actionSaveProjAs = QtGui.QAction(qicon("save.png"), "Save As",
self)
self.actionSaveProjAs.triggered.connect(self.save_as)
self.actionSaveProj = QtGui.QAction(qicon("save.png"), "Save project",
self)
self.actionSaveProj.triggered.connect(self.save)
self.actionSaveProj.setShortcut(
QtGui.QApplication.translate("MainWindow", "Ctrl+Shift+S", None,
QtGui.QApplication.UnicodeUTF8))
self.actionCloseProj = QtGui.QAction(qicon("closeButton.png"),
"Close project", self)
self.actionCloseProj.triggered.connect(self.close)
self.actionCloseProj.setShortcut(self.tr("Ctrl+Shift+W"))
self.actionNewProj = QtGui.QAction(qicon("new.png"), "New Project",
self)
self.actionNewProj.triggered.connect(self.new_project)
self.actionNewProj.setShortcut(self.tr("Ctrl+Shift+N"))
self.actionOpenProj = QtGui.QAction(qicon("open.png"), "Open Project",
self)
self.actionOpenProj.triggered.connect(self.open_project)
self.actionOpenProj.setShortcut(self.tr('Ctrl+Shift+O'))
def main():
app = QtGui.QApplication(sys.argv)
project_manager = ProjectManager()
project_manager.discover()
scroll = ProjectSelectorScroll(project_manager.projects)
# Display
scroll.show()
app.exec_()
def __init__(self):
import traceback
traceback.print_stack(file=sys.__stdout__)
self._project = None
self._is_proj = False
self._debug = False
self.gui = True
self.tmpdir = path(get_openalea_tmp_dir())
self._config = MainConfig()
self.extension = None
self.applet = {}
self.manager = {}
self.package_manager = package_manager
self.control_manager = ControlManager()
self.project_manager = ProjectManager()
self.plugin_manager = PluginManager()
self.plugin_instance_manager = PluginInstanceManager()
self.manager['control'] = self.control_manager
self.manager['package'] = self.package_manager
self.manager['project'] = self.project_manager
self.manager['plugin'] = self.plugin_manager
self.manager['plugin_instance'] = self.plugin_instance_manager
self.world = World()
self.interpreter = interpreter()
# Hack if interpreter is an object from class TerminalInteractiveShell
if not hasattr(self.interpreter, "shell"):
self.interpreter.shell = self.interpreter
if hasattr(self.interpreter.shell, "events"):
self.interpreter.shell.events.register("post_execute",
self.add_to_history)
else:
print("You need ipython >= 2.0 to use history.")
# self.project_manager.set_shell(self.interpreter.shell)
self.interpreter.locals['session'] = self
self.old_syspath = sys.path
self.load_default()
self.__class__.instantiated = True
def decode(mimetype, mimedata):
"""
decode("openalealab/model", "model1") -> Model("model1")
returns an object Model of model1
"""
if mimetype == 'openalealab/control':
from openalea.core.control.manager import ControlManager
identifier, name = mimedata.split(';')
control = ControlManager().control(name)
if isinstance(control, list):
return ControlManager().control(uid=identifier)
return control
elif mimetype == 'openalealab/data':
from openalea.core.project.manager import ProjectManager
from openalea.core.path import path
pm = ProjectManager()
return pm.get('data', path(mimedata).name)
else:
return str(mimedata)
def main():
from openalea.core.project.manager import ProjectManager
import sys
app = QtGui.QApplication(sys.argv)
tabwidget = QtGui.QTabWidget()
project_manager = ProjectManager()
project_manager.discover()
projects = project_manager.projects
for project in projects:
# Create widget
preview_widget = Preview(project)
tabwidget.addTab(preview_widget, project.name)
# Display
tabwidget.show()
app.exec_()
def __init__(self):
QtGui.QWidget.__init__(self)
AbstractListener.__init__(self)
layout = QtGui.QVBoxLayout(self)
self.view = ProjectManagerView()
self.model = self.view.model()
layout.addWidget(self.view)
layout.setContentsMargins(0, 0, 0, 0)
self.pm = ProjectManager()
self.menu_available_projects = QtGui.QMenu(u'Available Projects')
self.actionNewProj = self.view.actionNewProj
self.actionOpenProj = self.view.actionOpenProj
group = "Project"
self._actions = [
[group, "Manage Project", self.view.actionNewProj, 0],
[group, "Manage Project", self.view.actionOpenProj, 0],
[group, "Manage Project", self.view.actionSaveProj, 0],
# [group, "Manage Project", self.view.actionSaveProjAs, 1],
[group, "Manage Project", self.view.actionCloseProj, 0],
# [group, "Manage Project", self.view.actionEditMeta, 1],
# ["Project", "Manage Project", self.actionRenameProject, 1],
]
self._actions += self.view._actions
# Menu used to display all available projects.
# This menu is filled dynamically each time this menu is opened
self.menu_available_projects = QtGui.QMenu(u'Available Projects')
self.menu_available_projects.aboutToShow.connect(
self._update_available_project_menu)
self.action_available_project = {
} # Dict used to know what project corresponds to triggered action
self.pm.register_listener(self)
# Copyright 2015 INRIA - CIRAD - INRA
#
# File author(s): Guillaume Baty <*****@*****.**>
#
# File contributor(s):
#
# Distributed under the Cecill-C License.
# See accompanying file LICENSE.txt or copy at
# http://www.cecill.info/licences/Licence_CeCILL-C_V1-en.html
#
# OpenAlea WebSite : http://openalea.gforge.inria.fr
#
###############################################################################
from openalea.core.project.manager import ProjectManager
PM = ProjectManager()
def set_active_project(project):
PM.cproject = project
def active_project():
return PM.cproject
def projects():
PM.discover()
return list(PM.items())
import shutil
import sys
from openalea.core.path import path as Path
from openalea.core.path import tempdir
from openalea.core.project.manager import ProjectManager
from openalea.core.project.project import Project, _normpath
from openalea.core.unittest_tools import TestCase, EventTracker
# used to test symlinks only on unix systems
win = 'win' in sys.platform
pm = ProjectManager()
pm.count = 0
ev = EventTracker()
# ev.debug = True
pm.register_listener(ev)
def get_data(filename):
return Path(__file__).parent.abspath() / 'data' / filename
class TestProjectManager(TestCase):
def setUp(self):
self.tmpdir = tempdir()
self.tmpdir2 = tempdir()
pm.clear()
# Force to ignore default repositories
from openalea.core.pkgmanager import PackageManager
from openalea.core.project.manager import ProjectManager
from openalea.core.project import Project
from openalea.core.service.control import new_control
from openalea.core.service.model import ModelFactory
from openalea.oalab.service.paradigm import paradigm_controller
from openalea.core.service.ipython import interpreter
interp = interpreter()
interp.locals['interp'] = interp
pm = PackageManager()
project_manager = ProjectManager()
project = Project('unittest')
project_manager.cproject = project
if not project.started:
project.start()
interp.locals['project_manager'] = project_manager
interp.locals['project'] = project
def composite_node():
inputs = []
outputs = []
for io in list('abcd'):
inputs.append({
'name': io,
'desc': 'Input %s' % io.upper(),
def initialize(cls, *args, **kwds):
from openalea.core.project.manager import ProjectManager
pm = ProjectManager()
def refresh_project_list(self):
project_manager = ProjectManager()
project_manager.discover()
self.projects = project_manager.projects
self.init()
def new_tmp_project(projectdir):
pm = ProjectManager()
project = pm.create('tmpproject', projectdir=projectdir)
pm.cproject = project
return project
def on_project_opened(self):
pm = ProjectManager()
pm.cproject = self.project
self.hide()
