scipion-pyworkflow 3.7.0__py3-none-any.whl

pyworkflow/project/__init__.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+# **************************************************************************
+# *
+# * Authors:     J.M. De la Rosa Trevin (delarosatrevin@scilifelab.se) [1]
+# *
+# * [1] SciLifeLab, Stockholm University
+# *
+# * This program is free software; you can redistribute it and/or modify
+# * it under the terms of the GNU General Public License as published by
+# * the Free Software Foundation; either version 3 of the License, or
+# * (at your option) any later version.
+# *
+# * This program is distributed in the hope that it will be useful,
+# * but WITHOUT ANY WARRANTY; without even the implied warranty of
+# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# * GNU General Public License for more details.
+# *
+# * You should have received a copy of the GNU General Public License
+# * along with this program; if not, write to the Free Software
+# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+# * 02111-1307  USA
+# *
+# *  All comments concerning this program package may be sent to the
+# *  e-mail address 'scipion@cnb.csic.es'
+# *
+# **************************************************************************
+
+from .project import Project, MissingProjectDbException
+from .manager import Manager, ProjectInfo
+from .config import (ProjectSettings, MenuConfig,
+                     NodeConfig, NodeConfigList, Label, LabelsList)

pyworkflow/project/config.py

@@ -0,0 +1,451 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# **************************************************************************
+# *
+# * Authors:     J.M. De la Rosa Trevin (delarosatrevin@scilifelab.se) [1]
+# *
+# * [1] SciLifeLab, Stockholm University
+# *
+# * This program is free software: you can redistribute it and/or modify
+# * it under the terms of the GNU General Public License as published by
+# * the Free Software Foundation, either version 3 of the License, or
+# * (at your option) any later version.
+# *
+# * This program is distributed in the hope that it will be useful,
+# * but WITHOUT ANY WARRANTY; without even the implied warranty of
+# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# * GNU General Public License for more details.
+# *
+# * You should have received a copy of the GNU General Public License
+# * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# *
+# *  All comments concerning this program package may be sent to the
+# *  e-mail address 'scipion@cnb.csic.es'
+# *
+# **************************************************************************
+
+import logging
+logger = logging.getLogger(__name__)
+import json
+import datetime as dt
+
+import pyworkflow.object as pwobj
+from pyworkflow.mapper import SqliteMapper
+
+
+class ProjectSettings(pwobj.Object):
+    """ Store settings related to a project. """
+
+    COLOR_MODE_STATUS = 0
+    COLOR_MODE_LABELS = 1
+    COLOR_MODE_AGE = 2
+    COLOR_MODE_SIZE = 3
+    COLOR_MODES = (COLOR_MODE_STATUS, COLOR_MODE_LABELS, COLOR_MODE_AGE, COLOR_MODE_SIZE)
+
+    def __init__(self, confs={}, **kwargs):
+        super().__init__(**kwargs)
+        # Store the current view selected by the user
+        self.currentProtocolsView = pwobj.String()
+        # Store the color mode: 0= Status, 1=Labels, ...
+        self.colorMode = pwobj.Integer(ProjectSettings.COLOR_MODE_STATUS)
+        # Store graph nodes positions and other info
+        self.nodeList = NodeConfigList()
+        self.labelsList = LabelsList()  # Label list
+        self.mapper = None  # This should be set when load, or write
+        self.runsView = pwobj.Integer(1)  # by default the graph view
+        self.readOnly = pwobj.Boolean(False)
+        self.runSelection = pwobj.CsvList(int)  # Store selected runs
+        self.dataSelection = pwobj.CsvList(int)  # Store selected runs
+        # Some extra settings stored, now mainly used
+        # from the webtools
+        # Time when the project was created
+        self.creationTime = pwobj.String(dt.datetime.now())
+        # Number of days that this project is active
+        # if None, the project will not expire
+        # This is used in webtools where a limited time
+        # is allowed for each project
+        self.lifeTime = pwobj.Integer()
+        # Set a disk quota for the project (in Gb)
+        # if None, quota is unlimited
+        self.diskQuota = pwobj.Integer()
+
+    def commit(self):
+        """ Commit changes made. """
+        self.mapper.commit()
+
+    def getRunsView(self):
+        return self.runsView.get()
+
+    def setRunsView(self, value):
+        self.runsView.set(value)
+
+    def getReadOnly(self):
+        return self.readOnly.get()
+
+    def setReadOnly(self, value):
+        self.readOnly.set(value)
+
+    def getCreationTime(self):
+        return self.creationTime.datetime()
+
+    def setCreationTime(self, value):
+        self.creationTime.set(value)
+
+    def getLifeTime(self):
+        return self.lifeTime.get()
+
+    def setLifeTime(self, value):
+        self.lifeTime.set(value)
+
+    def getProtocolView(self):
+        return self.currentProtocolsView.get()
+
+    def setProtocolView(self, protocolView):
+        """ Set the new protocol Menu given its index.
+        The new ProtocolMenu will be returned.
+        """
+        self.currentProtocolsView.set(protocolView)
+
+    def getColorMode(self):
+        return self.colorMode.get()
+
+    def setColorMode(self, colorMode):
+        """ Set the color mode to use when drawing the graph.
+        """
+        self.colorMode.set(colorMode)
+
+    def statusColorMode(self):
+        return self.getColorMode() == self.COLOR_MODE_STATUS
+
+    def labelsColorMode(self):
+        return self.getColorMode() == self.COLOR_MODE_LABELS
+
+    def ageColorMode(self):
+        return self.getColorMode() == self.COLOR_MODE_AGE
+
+    def sizeColorMode(self):
+        return self.getColorMode() == self.COLOR_MODE_SIZE
+
+    def write(self, dbPath=None):
+        self.setName('ProjectSettings')
+        if dbPath is not None:
+            self.mapper = SqliteMapper(dbPath, globals())
+        else:
+            if self.mapper is None:
+                raise Exception("Can't write ProjectSettings without "
+                                "mapper or dbPath")
+
+        self.mapper.deleteAll()
+        self.mapper.insert(self)
+        self.mapper.commit()
+
+    def getNodes(self):
+        return self.nodeList
+
+    def cleanUpNodes(self, runsIds, toRemove=True):
+        """ This will clean up all the nodes that do not have a matching run.
+        This is because until now, the nodes here weren't removes when protocols were removed.
+
+        :param runsIds: iterable with protocol's objId to be removed.
+        :param toRemove: Passed is are to be removed. Otherwise, are the ones to keep
+        """
+
+        try:
+            logger.info("Cleaning up unused graphical nodes.")
+
+            nodesToDelete = []
+            for node  in self.getNodes():
+                nodeId = str(node.getId())
+                # if it is not the root node
+                if nodeId != '0':
+
+                    if (nodeId in runsIds) == toRemove:
+                        nodesToDelete.append(node.getId())
+
+            logger.info("Following graphical nodes %s unmatched. Deleting them" % nodesToDelete)
+            for key in nodesToDelete:
+                self.getNodes().removeNode(key)
+                
+        except Exception as e:
+            logger.error("Couldn't clean up graphical nodes.", exc_info=e)
+
+    def getNodeById(self, nodeId):
+        return self.nodeList.getNode(nodeId)
+
+    def addNode(self, nodeId, **kwargs):
+        return self.nodeList.addNode(nodeId, **kwargs)
+
+    def removeNode(self, nodeId):
+        """ Removes a graphical node based on its id"""
+        self.nodeList.removeNode(nodeId)
+
+    def getLabels(self):
+        return self.labelsList
+
+    @classmethod
+    def load(cls, dbPath):
+        """ Load a ProjectSettings from dbPath. """
+        classDict = dict(globals())
+        classDict.update(pwobj.__dict__)
+        mapper = SqliteMapper(dbPath, classDict)
+        settingList = mapper.selectByClass('ProjectSettings')
+        n = len(settingList)
+
+        if n == 0:
+            raise Exception("Can't load ProjectSettings from %s" % dbPath)
+        elif n > 1:
+            raise Exception("Only one ProjectSettings is expected in db, "
+                            "found %d in %s" % (n, dbPath))
+
+        settings = settingList[0]
+        settings.mapper = mapper
+
+        return settings
+
+
+class MenuConfig(object):
+    """Menu configuration in a tree fashion.
+    Each menu can contain submenus.
+    Leaf elements can contain actions"""
+
+    def __init__(self, text=None, value=None,
+                 icon=None, tag=None, shortCut=None, openItem=False, visible=True):
+        """Constructor for the Menu config item.
+        Arguments:
+          text: text to be displayed
+          value: internal value associated with the item.
+          icon: display an icon with the item
+          tag: put some tags to items
+        **args: pass other options to base class.
+        """
+        self.text = text
+        self.value = value
+        self.icon = icon
+        self.tag = tag
+        self.shortCut = shortCut
+        self.openItem = openItem
+        self.visible = visible
+        self.childs = pwobj.List()
+
+    def addSubMenu(self, text, value=None, **args):
+        subMenu = type(self)(text, value, **args)
+        self.childs.append(subMenu)
+        return subMenu
+
+    def __iter__(self):
+        for v in self.childs:
+            yield v
+
+    def __len__(self):
+        return len(self.childs)
+
+    def isEmpty(self):
+        return len(self.childs) == 0
+
+
+class NodeConfig(pwobj.Scalar):
+    """ Store Graph node information such as x, y. """
+
+    def __init__(self, nodeId=0, x=None, y=None, selected=False, expanded=True,
+                 visible=True):
+        pwobj.Scalar.__init__(self)
+        # Special node id 0 for project node
+        self._values = {'id': nodeId,
+                        'x': pwobj.Integer(x).get(0),
+                        'y': pwobj.Integer(y).get(0),
+                        'selected': selected,
+                        'expanded': expanded,
+                        'visible': pwobj.Boolean(visible).get(0),
+                        'labels': []}
+
+    def _convertValue(self, value):
+        """Value should be a str with comma separated values
+        or a list.
+        """
+        self._values = json.loads(value)
+
+    def getObjValue(self):
+        self._objValue = json.dumps(self._values)
+        return self._objValue
+
+    def get(self):
+        return self.getObjValue()
+
+    def getId(self):
+        return self._values['id']
+
+    def setX(self, x):
+        self._values['x'] = x
+
+    def getX(self):
+        return self._values['x']
+
+    def setY(self, y):
+        self._values['y'] = y
+
+    def getY(self):
+        return self._values['y']
+
+    def setPosition(self, x, y):
+        self.setX(x)
+        self.setY(y)
+
+    def getPosition(self):
+        return self.getX(), self.getY()
+
+    def setSelected(self, selected):
+        self._values['selected'] = selected
+
+    def isSelected(self):
+        return self._values['selected']
+
+    def setExpanded(self, expanded):
+        self._values['expanded'] = expanded
+
+    def isExpanded(self):
+        return self._values['expanded']
+
+    def setVisible(self, visible):
+        self._values['visible'] = visible
+
+    def isVisible(self):
+        if self._values.get('visible') is None:
+            self._values['visible'] = True
+        return self._values['visible']
+
+    def setLabels(self, labels):
+        self._values['labels'] = labels
+
+    def getLabels(self):
+        return self._values.get('labels', None)
+
+    def __str__(self):
+        return 'NodeConfig: %s' % self._values
+
+
+class NodeConfigList(pwobj.List):
+    """ Store all nodes information items and 
+    also store a dictionary for quick access
+    to nodes query.
+    """
+
+    def __init__(self):
+        self._nodesDict = {}
+        pwobj.List.__init__(self)
+
+    def getNode(self, nodeId):
+        return self._nodesDict.get(nodeId, None)
+
+    def addNode(self, nodeId, **kwargs):
+        node = NodeConfig(nodeId, **kwargs)
+        self._nodesDict[node.getId()] = node
+        self.append(node)
+        return node
+
+    def removeNode(self, nodeId):
+        """ Removes a node with the id = nodeId"""
+        nodeToRemove = self._nodesDict[nodeId]
+        self._nodesDict.pop(nodeId)
+        self.remove(nodeToRemove)
+
+    def updateDict(self):
+        self._nodesDict.clear()
+        for node in self:
+            self._nodesDict[node.getId()] = node
+
+    def clear(self):
+        pwobj.List.clear(self)
+        self._nodesDict.clear()
+
+
+class Label(pwobj.Scalar):
+    """ Store Label information """
+
+    EMPTY_OLD_NAME = None
+
+    def __init__(self, name='', color=None):
+        pwobj.Scalar.__init__(self)
+        # Special node id 0 for project node
+        self._values = {'name': name,
+                        'color': color}
+        self._oldName = self.EMPTY_OLD_NAME
+
+    def _convertValue(self, value):
+        """Value should be a str with comma separated values
+        or a list.
+        """
+        self._values = json.loads(value)
+
+        # Clean unused "id" field
+        if "id" in self._values:
+            self._values.pop("id")
+
+    def getObjValue(self):
+        self._objValue = json.dumps(self._values)
+        
+        return self._objValue
+
+    def get(self):
+        return self.getObjValue()
+
+
+    def getName(self)->str:
+        return self._values['name']
+
+    def setName(self, newName):
+        # For recurrent edit,
+        # we keep the old name only the first time
+        if not self.hasOldName():
+            self._oldName = self._values['name']
+
+        self._values['name'] = newName
+
+    def hasOldName(self)->bool:
+        return self._oldName != self.EMPTY_OLD_NAME
+
+    def clearOldName(self):
+        self._oldName = self.EMPTY_OLD_NAME
+
+    def getOldName(self)->str:
+        return self._oldName
+
+    def setColor(self, color):
+        self._values['color'] = color
+
+    def getColor(self)->str:
+        return self._values.get('color', None)
+
+    def __str__(self):
+        return 'Label: %s' % self._values
+
+    def __eq__(self, other):
+        return self.getName() == other.getName()
+
+
+class LabelsList(pwobj.List):
+    """ Store all labels information"""
+
+    def __init__(self):
+        self._labelsDict = {}
+        pwobj.List.__init__(self)
+
+    def getLabel(self, name):
+        return self._labelsDict.get(name, None)
+
+    def addLabel(self, label):
+        self._labelsDict[label.getName()] = label
+        self.append(label)
+        return label
+
+    def updateDict(self):
+        self._labelsDict.clear()
+        for label in self:
+            self._labelsDict[label.getName()] = label
+
+    def deleteLabel(self, label):
+        self._labelsDict.pop(label.getName())
+        self.remove(label)
+
+    def clear(self):
+        pwobj.List.clear(self)
+        self._labelDict.clear()

pyworkflow/project/manager.py

@@ -0,0 +1,179 @@
+# **************************************************************************
+# *
+# * Authors:     J.M. De la Rosa Trevin (jmdelarosa@cnb.csic.es)
+# *
+# * Unidad de  Bioinformatica of Centro Nacional de Biotecnologia , CSIC
+# *
+# * This program is free software; you can redistribute it and/or modify
+# * it under the terms of the GNU General Public License as published by
+# * the Free Software Foundation; either version 3 of the License, or
+# * (at your option) any later version.
+# *
+# * This program is distributed in the hope that it will be useful,
+# * but WITHOUT ANY WARRANTY; without even the implied warranty of
+# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# * GNU General Public License for more details.
+# *
+# * You should have received a copy of the GNU General Public License
+# * along with this program; if not, write to the Free Software
+# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+# * 02111-1307  USA
+# *
+# *  All comments concerning this program package may be sent to the
+# *  e-mail address 'scipion@cnb.csic.es'
+# *
+# **************************************************************************
+"""
+This modules handles the System management
+"""
+
+import os
+
+import pyworkflow as pw
+import pyworkflow.utils as pwutils
+from .project import Project
+
+
+class ProjectInfo(object):
+    """Class to store some information about the project"""
+    def __init__(self, projName, mTime, cTime, path):
+        """At least it receives the Project Name and its modification time"""
+        self.projName = projName
+        self.mTime = mTime
+        self.cTime = cTime
+        self.path = path
+
+    def __str__(self):
+        return "%s - %s" % (self.projName, self.path)
+
+    def getName(self):
+        return self.projName
+    
+    def getModificationTime(self):
+        return self.mTime
+
+    def getCreationTime(self):
+        return self.cTime
+
+    def isLink(self):
+        return os.path.islink(self.path)
+
+    def realPath(self):
+        return os.path.realpath(self.path)
+
+
+class Manager(object):
+    """ Manage all projects of a given workspace, for a given Domain.
+     (i.e, listing projects, creating, deleting or querying info)
+    """
+    def __init__(self, workspace=None):
+        """
+        Params:
+            workspace: path to where the user's workspace is. A subfolder
+            named 'projects' is expected. If workspace is None, the workspace
+            will be taken from the global configuration.
+        """
+        ws = workspace or pw.Config.SCIPION_USER_DATA
+        self.PROJECTS = os.path.join(ws, 'projects')
+
+    def getProjectPath(self, projectName):
+        """Return the project path given the name"""
+        return os.path.join(self.PROJECTS, projectName)
+        
+    def listProjects(self, sortByDate=True):
+        """Return a list with all existing projects
+        And some other project info
+        If sortByData is True, recently modified projects will be first"""
+        projList = []
+        pw.utils.makePath(self.PROJECTS)
+        for f in os.listdir(self.PROJECTS):
+            p = self.getProjectPath(f)
+            if os.path.isdir(p):
+                stat = os.stat(p)
+                projList.append(ProjectInfo(f, stat.st_mtime, stat.st_ctime, p))
+                
+        if sortByDate:
+            projList.sort(key=lambda k: k.mTime, reverse=True)
+        return projList
+    
+    def createProject(self, projectName, runsView=1, 
+                      hostsConf=None, protocolsConf=None, location=None):
+        """Create a new project.
+        confs dict can contains customs .conf files 
+        for: menus, protocols, or hosts
+        """
+        # Clean project name from undesired characters
+        projectName = Project.cleanProjectName(projectName)
+
+        # If location is not None create project on it (if exists)
+        if location is None:
+            projectPath = self.getProjectPath(projectName)
+        else:
+            projectPath = os.path.join(location, projectName)
+
+        # JMRT: Right now the project.create function change the current
+        # working dir (cwd) to the project location, let's store the cwd
+        # and restored after the creation
+        cwd = os.getcwd()
+        project = Project(pw.Config.getDomain(), projectPath)
+        project.create(runsView=runsView, 
+                       hostsConf=hostsConf, 
+                       protocolsConf=protocolsConf)
+        # If location is not the default one create a symlink on self.PROJECTS directory
+        if projectPath != self.getProjectPath(projectName):
+            # JMRT: Let's create the link to the absolute path, since relative
+            # can be broken in systems with different mount points
+            pw.utils.createAbsLink(os.path.abspath(projectPath),
+                                   self.getProjectPath(projectName))
+
+        os.chdir(cwd)  # Restore cwd before project creation
+
+        return project
+
+    def importProject(self, fromLocation, copyFiles=True, projectName=None, searchLocation=None):
+        """ Import a project that is somewhere else in the FS
+        Folder can be copied (default) or linked
+        Optionally a name can be specified, otherwise name will match location folder name
+        Project will always be created in the default project folder.
+        """
+        # If projectName is None...
+        if projectName is None:
+            # use same name as the import location
+            projectName = os.path.basename(fromLocation)
+
+        projectPath = self.getProjectPath(projectName)
+
+        # If need to copyFiles
+        if copyFiles:
+            # Copy the whole folder
+            pw.utils.copyTree(os.path.abspath(fromLocation), os.path.abspath(projectPath))
+
+        else:
+            # Link the folder
+            pw.utils.createAbsLink(os.path.abspath(fromLocation), projectPath)
+
+        project = self.loadProject(projectName)
+
+        if searchLocation:
+            project.fixLinks(searchLocation)
+
+        return project
+
+    def loadProject(self, projId, **kwargs):
+        """ Retrieve a project object, given its id. """
+        project = Project(pw.Config.getDomain(), self.getProjectPath(projId))
+        project.load(**kwargs)
+        return project
+
+    def deleteProject(self, projectName):
+        pw.utils.cleanPath(self.getProjectPath(projectName))
+
+    def renameProject(self, oldName, newName):
+        os.rename(self.getProjectPath(oldName), self.getProjectPath(newName))
+
+    def hasProject(self, projectName):
+        """Return True if exists a project with projectName"""
+        for projInfo in self.listProjects():
+            if projectName == projInfo.projName:
+                return True
+        return False