scipion-pyworkflow 3.7.0__py3-none-any.whl

pyworkflow/utils/which.py

@@ -0,0 +1,229 @@
+
+# Copyright (c) 2002-2005 ActiveState Corp.
+# See LICENSE.txt for license details.
+# Author:
+#   Trent Mick (TrentM@ActiveState.com)
+# Home:
+#   http://trentm.com/projects/which/
+
+"""Find the full path to commands.
+
+which(command, path=None, verbose=0, exts=None)
+    Return the full path to the first match of the given command on the
+    path.
+
+whichall(command, path=None, verbose=0, exts=None)
+    Return a list of full paths to all matches of the given command on
+    the path.
+
+whichgen(command, path=None, verbose=0, exts=None)
+    Return a generator which will yield full paths to all matches of the
+    given command on the path.
+    
+"""
+
+import os
+import sys
+import stat
+# ---- exceptions
+
+
+class WhichError(Exception):
+    pass
+
+# ---- internal support stuff
+
+
+def _getRegisteredExecutable(exeName):
+    """Windows allow application paths to be registered in the registry."""
+    registered = None
+    if sys.platform.startswith('win'):
+        if os.path.splitext(exeName)[1].lower() != '.exe':
+            exeName += '.exe'
+        import winreg
+        try:
+            key = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\" +\
+                  exeName
+            value = winreg.QueryValue(winreg.HKEY_LOCAL_MACHINE, key)
+            registered = (value, "from HKLM\\"+key)
+        except winreg.error:
+            pass
+        if registered and not os.path.exists(registered[0]):
+            registered = None
+    return registered
+
+
+def _samefile(fname1, fname2):
+    if sys.platform.startswith('win'):
+        return (os.path.normpath(os.path.normcase(fname1)) ==
+                os.path.normpath(os.path.normcase(fname2)))
+    else:
+        return os.path.samefile(fname1, fname2)
+
+
+def _cull(potential, matches, verbose=0):
+    """Cull inappropriate matches. Possible reasons:
+        - a duplicate of a previous match
+        - not a disk file
+        - not executable (non-Windows)
+    If 'potential' is approved it is returned and added to 'matches'.
+    Otherwise, None is returned.
+    """
+    for match in matches:  # don't yield duplicates
+        if _samefile(potential[0], match[0]):
+            if verbose:
+                sys.stderr.write("duplicate: %s (%s)\n" % potential)
+            return None
+    else:
+        if not stat.S_ISREG(os.stat(potential[0]).st_mode):
+            if verbose:
+                sys.stderr.write("not a regular file: %s (%s)\n" % potential)
+        elif not os.access(potential[0], os.X_OK):
+            if verbose:
+                sys.stderr.write("no executable access: %s (%s)\n"
+                                 % potential)
+        else:
+            matches.append(potential)
+            return potential
+
+        
+# ---- module API
+
+def whichgen(command, path=None, verbose=0, exts=None):
+    """Return a generator of full paths to the given command.
+    
+    :param command: is a the name of the executable to search for.
+    :param path: is an optional alternate path list to search. The default it
+        to use the PATH environment variable.
+    :param verbose: if true, will cause a 2-tuple to be returned for each
+        match. The second element is a textual description of where the
+        match was found.
+    :param exts: optionally allows one to specify a list of extensions to use
+        instead of the standard list for this system. This can
+        effectively be used as an optimization to, for example, avoid
+        stat's of "foo.vbs" when searching for "foo" and you know it is
+        not a VisualBasic script but ".vbs" is on PATHEXT. This option
+        is only supported on Windows.
+
+    :return: This method returns a generator which yields either full paths to
+        the given command or, if verbose, tuples of the form (<path to
+        command>, <where path found>).
+
+    """
+    matches = []
+    if path is None:
+        usingGivenPath = 0
+        path = os.environ.get("PATH", "").split(os.pathsep)
+        if sys.platform.startswith("win"):
+            path.insert(0, os.curdir)  # implied by Windows shell
+    else:
+        usingGivenPath = 1
+
+    # Windows has the concept of a list of extensions (PATHEXT env var).
+    if sys.platform.startswith("win"):
+        if exts is None:
+            exts = os.environ.get("PATHEXT", "").split(os.pathsep)
+            # If '.exe' is not in exts then obviously this is Win9x and
+            # or a bogus PATHEXT, then use a reasonable default.
+            for ext in exts:
+                if ext.lower() == ".exe":
+                    break
+            else:
+                exts = ['.COM', '.EXE', '.BAT']
+        elif not isinstance(exts, list):
+            raise TypeError("'exts' argument must be a list or None")
+    else:
+        if exts is not None:
+            raise WhichError("'exts' argument is not supported on "
+                             "platform '%s'" % sys.platform)
+        exts = []
+
+    # File name cannot have path separators because PATH lookup does not
+    # work that way.
+    if os.sep in command or os.altsep and os.altsep in command:
+        pass
+    else:
+        for i in range(len(path)):
+            dirName = path[i]
+            # On windows the dirName *could* be quoted, drop the quotes
+            if sys.platform.startswith("win") and len(dirName) >= 2\
+               and dirName[0] == '"' and dirName[-1] == '"':
+                dirName = dirName[1:-1]
+            for ext in ['']+exts:
+                absName = os.path.abspath(
+                    os.path.normpath(os.path.join(dirName, command+ext)))
+                if os.path.isfile(absName):
+                    if usingGivenPath:
+                        fromWhere = "from given path element %d" % i
+                    elif not sys.platform.startswith("win"):
+                        fromWhere = "from PATH element %d" % i
+                    elif i == 0:
+                        fromWhere = "from current directory"
+                    else:
+                        fromWhere = "from PATH element %d" % (i-1)
+                    match = _cull((absName, fromWhere), matches, verbose)
+                    if match:
+                        if verbose:
+                            yield match
+                        else:
+                            yield match[0]
+        match = _getRegisteredExecutable(command)
+        if match is not None:
+            match = _cull(match, matches, verbose)
+            if match:
+                if verbose:
+                    yield match
+                else:
+                    yield match[0]
+
+
+def which(command, path=None, verbose=0, exts=None):
+    """Return the full path to the first match of the given command on
+    the path.
+
+    :param command: is a the name of the executable to search for.
+    :param path: is an optional alternate path list to search.
+        The default is to use the PATH environment variable.
+    :param verbose: if true, will cause a 2-tuple to be returned.
+        The second element is a textual description of where the match was found.
+    :param exts: optionally allows one to specify a list of extensions to use
+        instead of the standard list for this system. This can
+        effectively be used as an optimization to, for example, avoid
+        stat's of "foo.vbs" when searching for "foo" and you know it is
+        not a VisualBasic script but ".vbs" is on PATHEXT. This option
+        is only supported on Windows.
+
+    :return If no match is found for the command, an empty string is returned.
+
+    """
+    try:
+        match = next(whichgen(command, path, verbose, exts))
+    except StopIteration:
+        return ''
+    return match
+
+
+def commandExists(command):
+    path = which(command)
+    return path != ''
+
+
+def whichall(command, path=None, verbose=0, exts=None):
+    """Return a list of full paths to all matches of the given command
+    on the path.  
+
+    :param command: is a the name of the executable to search for.
+    :param path: is an optional alternate path list to search. The default it
+        to use the PATH environment variable.
+    :param verbose: if true, will cause a 2-tuple to be returned for each
+        match. The second element is a textual description of where the
+        match was found.
+    :param exts: optionally allows one to specify a list of extensions to use
+        instead of the standard list for this system. This can
+        effectively be used as an optimization to, for example, avoid
+        stat's of "foo.vbs" when searching for "foo" and you know it is
+        not a VisualBasic script but ".vbs" is on PATHEXT. This option
+        is only supported on Windows.
+
+    """
+    return list(whichgen(command, path, verbose, exts))

pyworkflow/viewer.py

@@ -0,0 +1,328 @@
+# **************************************************************************
+# *
+# * 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 os
+
+import pyworkflow.protocol as pwprot
+from pyworkflow.utils import KEYSYM
+from subprocess import call
+
+DESKTOP_TKINTER = 'tkinter'
+WEB_DJANGO = 'django'
+
+
+class View(object):
+    """ Represents a visualization result for some object or file.
+    Views can be plots, table views, chimera scripts, commands or messages.
+    """
+    def show(self):
+        """ This method should be overwritten to implement how
+        this particular view will be displayed in desktop.
+        """
+        pass
+    
+    def toUrl(self):
+        """ If the view have web implementation, this method
+        should be implemented to build the url with parameters
+        that will be used to respond.
+        """
+        pass
+    
+    
+class CommandView(View):
+    """ View for calling an external command. """
+    def __init__(self, cmd, **kwargs):
+        View.__init__(self)
+        self._cmd = cmd
+        self._env = kwargs.get('env', None)
+        self._cwd = kwargs.get('cwd', None)
+        
+    def show(self):
+        call(self._cmd, shell=True, env=self._env, cwd=self._cwd)
+        
+
+MSG_INFO = 0
+MSG_WARN = 1
+MSG_ERROR = 2
+
+MSG_DICT = {MSG_INFO: 'showInfo',
+            MSG_WARN: 'showWarning',
+            MSG_ERROR: 'showError'}
+
+
+class MessageView(View):
+    """ View for some message. """
+    def __init__(self, msg, title='', msgType=MSG_INFO, tkParent=None,
+                 **kwargs):
+        View.__init__(self)
+        self._msg = msg
+        self._title = title
+        self._msgType = msgType
+        self._tkParent = tkParent
+        
+    def show(self):
+        import pyworkflow.gui.dialog as dialog
+        func = getattr(dialog, MSG_DICT[self._msgType])
+        func(self._title, self._msg, self._tkParent)
+        
+    def getMessage(self):
+        return self._msg
+
+
+class TextView(View):
+    """ View for display some text file. """
+    def __init__(self, filelist, title='', tkParent=None, **kwargs):
+        View.__init__(self)
+        self._filelist = filelist
+        if title:
+            self._title = title
+        else:
+            self._title = filelist[0]
+        self._tkParent = tkParent
+        
+    def getFileList(self):
+        return self._filelist
+        
+    def show(self):
+        from pyworkflow.gui.text import showTextFileViewer
+        showTextFileViewer(self._title, self._filelist, self._tkParent)
+
+
+# ---------------- Viewers ----------------------------------------
+class Viewer(object):
+    """ A Viewer will provide several Views to visualize
+    the data associated to data objects or protocol.
+    
+    The _targets class property should contain a list of string
+    with the class names that this viewer is able to visualize.
+    For example: _targets = ['Image', 'SetOfImages']
+    """
+    _targets = []
+    _environments = [DESKTOP_TKINTER]
+    _name = None
+    
+    def __init__(self, tmpPath='./Tmp', **args):
+        self._tmpPath = tmpPath
+        self._project = args.get('project')
+        if self._project is None:
+            raise Exception('Can not initialize a Viewer with None project.')
+        self.protocol = args.get('protocol', None)
+        self.formWindow = args.get('parent', None)
+        self._keyPressed = args.get('keyPressed', None)
+        self._tkRoot = self.formWindow.root if self.formWindow else None
+
+    def getKeyPressed(self):
+        return self._keyPressed
+
+    def shiftPressed(self):
+        return self._keyPressed==KEYSYM.SHIFT
+
+    def controlPressed(self):
+        return self._keyPressed == KEYSYM.CONTROL
+
+    def getTkRoot(self):
+        return self._tkRoot
+
+    def _getTmpPath(self, *paths):
+        return os.path.join(self._tmpPath, *paths)
+    
+    def visualize(self, obj, **kwargs):
+        """ Display each of the views, by default
+        the implementation is for desktop.
+        """
+        for view in self._visualize(obj, **kwargs):
+            view.show()
+            
+    def _visualize(self, obj, **kwargs):
+        """ This method should make the necessary conversions
+        and return the list of Views that will be used to 
+        visualize the object
+        """
+        return []
+    
+    # FIXME: REMOVE THIS METHOD AFTER RE-FACTORING
+    def getView(self):
+        """ This method should return the string value of the view in web
+        that will respond to this viewer. This method only should be implemented
+        in those viewers that have WEB_DJANGO environment defined. 
+        """
+        return None
+    
+    def getProject(self):
+        return self._project
+    
+    def setProject(self, project):
+        self._project = project
+        
+    def getParent(self):
+        """ Get the Tk parent widget. """
+        return self.formWindow
+        
+    def infoMessage(self, msg, title='',):
+        """ Build a message View of type INFO. """
+        return MessageView(msg, title, msgType=MSG_INFO, tkParent=self._tkRoot)
+    
+    def errorMessage(self, msg, title=''):
+        """ Build a message View of type INFO. """
+        return MessageView(msg, title, msgType=MSG_ERROR, tkParent=self._tkRoot)  
+    
+    def errorList(self, errors, views, title='Visualization errors'):
+        """ Convert an error list in a single Error message. """
+        if errors:
+            views.append(self.errorMessage('\n'.join(errors), title))
+    
+    def warnMessage(self, msg, title=''):
+        """ Build a message View of type INFO. """
+        return MessageView(msg, title, msgType=MSG_WARN, tkParent=self._tkRoot)
+
+    def textView(self, filelist, title=''):
+        return TextView(filelist, title, tkParent=self.formWindow)  
+    
+    def tkWindow(self, windowClass, **kwargs):
+        kwargs['masterWindow'] = self.formWindow
+        return windowClass(**kwargs)  
+
+    def getProtocolId(self):
+        if not hasattr(self, 'protocol'):
+            raise Exception("self.protocol is not defined for this Viewer.")
+        return self.protocol.strId()
+
+    @classmethod
+    def getName(cls):
+        if cls._name is None:
+            return cls.__name__
+        return cls._name
+
+
+class ProtocolViewer(Viewer, pwprot.Protocol):
+    """ Special kind of viewer that have a Form to organize better
+    complex visualization associated with protocol results.
+    If should provide a mapping between form params and the corresponding
+    functions that will return the corresponding Views.
+    """
+    def __init__(self, **kwargs):
+        # Here we are going to intercept the original _defineParams function
+        # and replace by an empty one, this is to postpone the definition of 
+        # params until the protocol is set and then self.protocol can be used
+        # for a more dynamic definition
+        object.__setattr__(self, '_defineParamsBackup', self._defineParams)
+        object.__setattr__(self, '_defineParams', self._defineParamsEmpty)
+    
+        pwprot.Protocol.__init__(self, **kwargs)
+        Viewer.__init__(self, **kwargs)
+        self.allowHeader.set(False)
+        # This flag will be used to display a plot or return the plotter
+        self.showPlot = True
+        self._tkRoot = None
+        self.formWindow = None
+        self.setWorkingDir(self.getProject().getTmpPath())
+        
+    def getWindow(self):
+        return self.formWindow
+    
+    def getTkRoot(self):
+        return self._tkRoot
+    
+    def _defineParamsEmpty(self, form):
+        """ Just do nothing and postpone the real definition. """
+        pass
+    
+    def setProtocol(self, protocol):
+        """ Set the protocol instance to the viewer and
+        call the definition of the parameters.
+        """
+        self.protocol = protocol
+        self._defineParamsBackup(self._definition)
+        self._createVarsFromDefinition()
+    
+    def visualize(self, obj, **args):
+        """Open the Protocol GUI Form given a Protocol instance"""
+        from pyworkflow.gui.form import FormWindow
+        self.setProtocol(obj)
+        self.windows = args.get('windows', None)
+        self.formWindow = FormWindow("Protocol Viewer: " + self.getClassName(),
+                                     self, self._viewAll, self.windows,
+                                     visualizeDict=self.__getVisualizeWrapperDict(),
+                                     visualizeMode=True)
+        self.formWindow.visualizeMode = True
+        self.showInfo = self.formWindow.showInfo
+        self.showError = self.formWindow.showError
+        self._tkRoot = self.formWindow.root
+        self.formWindow.show(center=True)     
+    
+    def _visualizeParam(self, paramName=None):
+        """ Call handler to get viewers and visualize each one. """
+        errors = self.validate()
+        if errors:
+            errorMsg = '\n'.join(errors)
+            self.showError(errorMsg, "Validation errors")
+        else:
+            views = self._getVisualizeDict()[paramName](paramName)
+            if views:
+                for v in views:
+                    v.show()
+            
+    def __getVisualizeWrapperDict(self):
+        """ Replace the True attributes handler by the generic one. """
+        d = {}
+        for k in self._getVisualizeDict():
+            d[k] = self._visualizeParam
+            
+        return d        
+        
+    def _getVisualizeDict(self):
+        """ Create the visualization dict for view individual params. """
+        return {}
+    
+    def _viewAll(self, *args):
+        """ Visualize all data give the parameters. """
+        for k, v in self._getVisualizeDict().items():
+            if self.getAttributeValue(k, False):
+                v(k)
+                
+    def _citations(self):
+        return self.protocol._citations()
+
+    def validateInstallation(self):
+        return
+
+    # TODO deprecate this method, it's duplicate of one from pwutils.utils
+    def _getListFromRangeString(self, rangeStr):
+        """ Create a list of integer from a string with range definitions
+        Examples:
+        "1,5-8,10" -> [1,5,6,7,8,10]
+        "2,6,9-11" -> [2,6,9,10,11]
+        "2 5, 6-8" -> [2,5,6,7,8]
+        """
+        elements = rangeStr.split(',')
+        values = []
+        for e in elements:
+            if '-' in e:
+                limits = e.split('-')
+                values += range(int(limits[0]), int(limits[1])+1)
+            else:
+                # If values are separated by comma also split
+                values += map(int, e.split())
+        return values

pyworkflow/webservices/__init__.py

@@ -0,0 +1,8 @@
+
+# Export all configuration variables in case they will be needed outside this module
+# Nonetheless, the recommend way is to import the classes or functions provided
+# by the module
+from .config import *
+
+from .notifier import ProjectWorkflowNotifier
+from .repository import WorkflowRepository

pyworkflow/webservices/config.py

@@ -0,0 +1,11 @@
+# Variable related to the online services (workflow stats and repository) that Scipion reports to or communicate.
+# These variables may change between Scipion versions but do not depend on the user or system
+
+# Web that gathers protocol usage
+SCIPION_STATS_SERVER = 'https://scipion.i2pc.es'
+SCIPION_STATS_WORKFLOW_APP = SCIPION_STATS_SERVER + '/report_protocols/api/workflow/workflow/'
+
+# Web that handles workflows
+WORKFLOW_REPOSITORY_SERVER = 'https://workflows.scipion.i2pc.es/'
+WORKFLOW_PROG_STEP1 = 'workflowProgStep1_add/'
+WORKFLOW_PROG_STEP2 = 'workflowProgStep2_add/'