Exemple #1
0
 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()
Exemple #2
0
    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())
Exemple #3
0
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
Exemple #4
0
    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'))
Exemple #5
0
def main():
    app = QtGui.QApplication(sys.argv)

    project_manager = ProjectManager()
    project_manager.discover()
    scroll = ProjectSelectorScroll(project_manager.projects)

    # Display
    scroll.show()
    app.exec_()
Exemple #6
0
    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
Exemple #7
0
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)
Exemple #8
0
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_()
Exemple #9
0
    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)
Exemple #10
0
#       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())

Exemple #11
0
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
Exemple #12
0
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(),
Exemple #13
0
 def initialize(cls, *args, **kwds):
     from openalea.core.project.manager import ProjectManager
     pm = ProjectManager()
Exemple #14
0
 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
Exemple #16
0
 def on_project_opened(self):
     pm = ProjectManager()
     pm.cproject = self.project
     self.hide()