scipion-pyworkflow 3.11.0__py3-none-any.whl → 3.11.1__py3-none-any.whl

pyworkflow/gui/project/searchprotocol.py

@@ -0,0 +1,238 @@
+# -*- coding: utf-8 -*-
+# **************************************************************************
+# *
+# * Authors:     Pablo Conesa [1]
+# *
+# * [1] 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, see <https://www.gnu.org/licenses/>.
+# *
+# *  All comments concerning this program package may be sent to the
+# *  e-mail address 'scipion@cnb.csic.es'
+# *
+# **************************************************************************
+""" This module contains the provider and dialog to search for a protocol"""
+import tkinter as tk
+from pyworkflow import Config
+import pyworkflow.gui as pwgui
+import pyworkflow.object as pwobj
+from pyworkflow.gui.dialog import SearchBaseWindow
+
+from pyworkflow.gui.project.utils import isAFinalProtocol
+from pyworkflow.gui.project.viewprotocols_extra import ProtocolTreeConfig
+from pyworkflow.project.usage import getNextProtocolSuggestions
+from pyworkflow.utils import Icon
+
+UPDATED = "updated"
+
+NEW = "new"
+
+BETA = "beta"
+
+
+class ProtocolTreeProvider(pwgui.tree.ObjectTreeProvider):
+    """Create the tree elements for a Protocol run"""
+
+    def __init__(self, protocol):
+        self.protocol = protocol
+        # This list is create to group the protocol parameters
+        # in the tree display
+        self.status = pwobj.List(objName='_status')
+        self.params = pwobj.List(objName='_params')
+        self.statusList = ['status', 'initTime', 'endTime', 'error',
+                           'interactive', 'mode']
+
+        objList = [] if protocol is None else [protocol]
+        pwgui.tree.ObjectTreeProvider.__init__(self, objList)
+
+
+
+class SearchProtocolWindow(SearchBaseWindow):
+
+    columnConfig = {
+        '#0': ('Status', {'width': 50, 'minwidth': 50, 'stretch': tk.NO}, 5),
+        # Heading, tree column kwargs, casting for sorting
+        'protocol': ('Protocol', {'width': 300, 'stretch': tk.FALSE}, 10),
+        'score': ('Score/Freq.', {'width': 50, 'stretch': tk.FALSE}, 5, int),
+        'streaming': ('Streamified', {'width': 100, 'stretch': tk.FALSE}, 5),
+        'installed': ('Installation', {'width': 110, 'stretch': tk.FALSE}, 5),
+        'help': ('Help', {'minwidth': 300, 'stretch': tk.YES}, 5),
+    }
+
+    def __init__(self, parentWindow, position=None, selectionGetter=None):
+
+        posStr = "" if position is None else " at (%s,%s)" % position
+        self.position = position
+        self.selectionGetter = selectionGetter
+        self.selectedProtocol = None
+        self._infoLbl = None  # Label to show information
+        super().__init__(parentWindow,
+                         title="Add a protocol" + posStr)
+
+        self.root.bind("<FocusIn>", self._onWindowFocusIn)
+
+    def _onWindowFocusIn(self, event):
+        """
+        To refresh the selected protocol in the graph upon window activation.
+        :param event: event information
+        :return: Nothing
+        """
+        if event.widget == self.root and self.selectionGetter:
+            self.selectedProtocol = self.selectionGetter()
+            if self._isSuggestionActive():
+                self._onSearchClick()
+    def _isSuggestionActive(self):
+        """
+        :return: Returns true if current mode is suggestion mode.
+        """
+        return self._searchVar.get().lower().strip() ==""
+
+    def _createSearchBox(self, content):
+        frame = super()._createSearchBox(content)
+
+        btn = pwgui.widgets.IconButton(frame, "Suggest",
+                                 tooltip="Suggestions for active protocol based on usage.",
+                                 imagePath=Icon.LIGHTBULB,
+                                 command=self.showSuggestions)
+        btn.grid(row=0, column=3, sticky='nw')
+
+        self.lbl = tk.StringVar()
+        lbl = tk.Label(frame, text="", bg=Config.SCIPION_BG_COLOR, textvariable=self.lbl, font=self.font)
+        lbl.grid(row=0, column=4, sticky='news')
+
+    def _createResultsTree(self, frame, show, columns):
+        # This code is where the callback (on double click) is defined.
+        return self.master.getViewWidget()._createProtocolsTree(frame, show=show, columns=columns, position=self.position)
+
+    def showSuggestions(self, e=None):
+        self._searchVar.set("")
+        self._onSearchClick()
+    def _onSearchClick(self, e=None):
+
+        self._resultsTree.clear()
+
+        protList = self.scoreProtocols()
+
+        # Sort by weight
+        protList.sort(reverse=True, key=lambda x: x[8])
+
+        self._addProtocolToTree(protList)
+
+    def scoreProtocols(self):
+
+        if self._isSuggestionActive():
+            return self.addSuggestions()
+
+        keyword = self._searchVar.get().lower().strip()
+        self.lbl.set('Showing text search matches for "%s"' % keyword)
+
+        emProtocolsDict = Config.getDomain().getProtocols()
+        protList = []
+
+        for key, prot in emProtocolsDict.items():
+            if isAFinalProtocol(prot, key):
+                label = prot.getClassLabel().lower()
+                line = (key, label,
+                        "installed" if prot.isInstalled() else "missing installation",
+                        prot.getHelpText().strip().replace('\r', '').replace('\n', '').lower(),
+                        "streamified" if prot.worksInStreaming() else "static",
+                        BETA if prot.isBeta() else "",
+                        NEW if prot.isNewDev() else "",
+                        UPDATED if prot.isUpdated() else "")
+
+                line = self._addSearchWeight(line, keyword)
+                # something was found: weight > 0
+                if line[8] != 0:
+                    protList.append(line)
+
+        return protList
+
+    def addSuggestions(self):
+
+        if self.selectedProtocol is None:
+            self.lbl.set("Showing suggestions for a first protocol")
+            protName =str(None)
+        else:
+            protName = self.selectedProtocol.getClassName()
+            self.lbl.set("Usage suggestions for selected protocol: %s" % self.selectedProtocol.getClassLabel())
+
+        protList = []
+        suggestions = getNextProtocolSuggestions(protName)
+        for suggestion in suggestions:
+            #Fields comming from the site:
+            # https://scipion.i2pc.es/report_protocols/api/v2/nextprotocol/suggestion/None/
+            # 'next_protocol__name', 'count', 'next_protocol__friendlyName', 'next_protocol__package', 'next_protocol__description'
+            nextProtName, count, name, package, descr = suggestion
+            streamstate = "unknown"
+            installed = "Missing. Available in %s plugin." % package
+            protClass = Config.getDomain().getProtocols().get(nextProtName, None)
+
+            # Get accurate values from existing installations
+            if protClass is not None:
+                name = protClass.getClassLabel().lower()
+                descr = protClass.getHelpText().strip().replace('\r', '').replace('\n', '').lower()
+                streamstate = "streamified" if protClass.worksInStreaming() else "static"
+                installed = "installed" if protClass.isInstalled() else "missing installation"
+
+            line = (nextProtName, name,
+                    installed,
+                    descr,
+                    streamstate,
+                    "",
+                    "",
+                    "",
+                    count)
+
+            protList.append(line)
+
+        return protList
+
+    @staticmethod
+    def _addSearchWeight(line2Search, searchtext):
+        # Adds a weight value for the search
+        weight = 0
+
+        # prioritize findings in label
+        if searchtext in line2Search[1]:
+            weight += 10
+
+        for value in line2Search[2:]:
+            weight += 5 if searchtext in value else 0
+
+        if " " in searchtext:
+            for word in searchtext.split():
+                if word in line2Search[1]:
+                    weight += 3
+
+                for value in line2Search[2:]:
+                    weight += 1 if word in value else 0
+
+        return line2Search + (weight,)
+
+    def _addProtocolToTree(self, protList):
+        """ Adds the items in protList to the tree
+
+        :param protList: List of tuples with all the values/columns used in search and shown in the tree"""
+
+        for key, label, installed, help, streamified, beta, new, updated, weight in protList:
+            tag = ProtocolTreeConfig.getProtocolTag(installed == 'installed',
+                                                    beta == BETA,
+                                                    new == NEW,
+                                                    updated == UPDATED)
+
+            self._resultsTree.insert(
+                '', 'end', key, text="", tags=tag,
+                values=(label, weight, streamified, installed, help))
+
+

pyworkflow/gui/project/searchrun.py

@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+# **************************************************************************
+# *
+# * Authors:     Pablo Conesa [1]
+# *
+# * [1] 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, see <https://www.gnu.org/licenses/>.
+# *
+# *  All comments concerning this program package may be sent to the
+# *  e-mail address 'scipion@cnb.csic.es'
+# *
+# **************************************************************************
+""" This modules hosts code provider and window to search for a run"""
+
+import tkinter as tk
+from pyworkflow import Config
+import pyworkflow.protocol as pwprot
+
+from pyworkflow.gui import SearchBaseWindow
+from pyworkflow.gui.project.constants import *
+from pyworkflow.gui.tree import ProjectRunsTreeProvider
+
+class RunsTreeProvider(ProjectRunsTreeProvider):
+    """Provide runs info to populate tree inside viewprotocols. Is more advanced
+    than ProjectRunsTreeProvider extended, extended with right click actions."""
+
+    def __init__(self, project, actionFunc):
+        super().__init__(project)
+        self.actionFunc = actionFunc  # ProtocolsView._runActionClicked
+        self._selection = project.getSettings().runSelection
+
+    def getActionsFromSelection(self):
+        """ Return the list of options available for selection. """
+        n = len(self._selection)
+        single = n == 1
+        anyselected = n > 0
+        if n:
+            prot = self.project.getProtocol(self._selection[0], fromRuns=True)
+            status = prot.getStatus()
+            nodeInfo = self.project.getSettings().getNodeById(prot.getObjId())
+            expanded = nodeInfo.isExpanded() if nodeInfo else True
+        else:
+            status = None
+
+        stoppable = status in [pwprot.STATUS_RUNNING, pwprot.STATUS_SCHEDULED,
+                               pwprot.STATUS_LAUNCHED]
+
+        # This list defines the order the icons are shown
+        return [(ACTION_NEW, True),
+                (ACTION_EDIT, single and status and expanded),
+                (ACTION_BROWSE, single and status and expanded),
+                (ACTION_RENAME, single and status and expanded),
+                (ACTION_LABELS, True),
+
+                (ACTION_DUPLICATE, status and expanded),
+                (ACTION_COPY, status and expanded),
+                (ACTION_PASTE, status and expanded),
+                (ACTION_DELETE, status != pwprot.STATUS_RUNNING and status and expanded),
+
+                (ACTION_SELECT_FROM, anyselected),
+                (ACTION_SELECT_TO, anyselected),
+                (ACTION_COLLAPSE, single and status and expanded),
+                (ACTION_EXPAND, single and status and not expanded),
+
+                (ACTION_STOP, stoppable and single),
+                (ACTION_STOP_WORKFLOW, single),
+                (ACTION_RESTART_WORKFLOW, single),
+                (ACTION_CONTINUE_WORKFLOW, single),
+                (ACTION_RESET_WORKFLOW, single),
+
+                (ACTION_EXPORT, anyselected),
+                (ACTION_EXPORT_UPLOAD, anyselected),
+
+                (ACTION_STEPS, single and Config.debugOn() and status and expanded),
+                (ACTION_DB, single and Config.debugOn() and status and expanded),
+                ]
+
+    def getObjectActions(self, obj, withEvent=False):
+        """ Get actions available to perform.
+
+        This method is called in 2 cases:
+        1.- Right-click on the tree (list of runs)
+        2.- Right-click on the canvas. When called from the canvas we need the event to get the click's position.
+
+        :param obj: optional, if passed, actions on the object. otherwise generic actions
+        :param withEvent: pass True if callback has to have the event as a parameter (call from canvas but not from tree)
+
+        """
+
+        def addAction(actionLabel):
+            if actionLabel:
+                text = actionLabel
+                action = actionLabel
+                if withEvent:
+                    callback=lambda e: self.actionFunc(action, e)
+                else:
+                    callback=lambda: self.actionFunc(action)
+
+                actionLabel = (text, callback,
+                               ActionIcons.get(action, None),
+                               ActionShortCuts.get(action,None))
+            return actionLabel
+
+        actions = [addAction(a)
+                   for a, cond in self.getActionsFromSelection() if cond]
+
+        if obj is not None and hasattr(obj, 'getActions'):
+            for text, action in obj.getActions():
+                actions.append((text, action, None))
+
+        return actions
+
+
+class SearchRunWindow(SearchBaseWindow):
+
+    columnConfig = {
+        '#0': (ProjectRunsTreeProvider.ID_COLUMN, {'width': 100, 'stretch': tk.NO}, 10),
+        ProjectRunsTreeProvider.RUN_COLUMN: (ProjectRunsTreeProvider.RUN_COLUMN, {'width': 300, 'stretch': tk.TRUE}, 10),
+        ProjectRunsTreeProvider.STATE_COLUMN: (ProjectRunsTreeProvider.STATE_COLUMN, {'width': 150, 'stretch': tk.FALSE}, 5),
+        ProjectRunsTreeProvider.TIME_COLUMN: (ProjectRunsTreeProvider.TIME_COLUMN, {'width': 200, 'stretch': tk.FALSE}, 5),
+        'Comment': ('Comment', {'width': 300, 'stretch': tk.FALSE}, 5),
+        'Expanded': ('Expanded', {'width': 150, 'stretch': tk.FALSE}, 5),
+    }
+
+    def __init__(self, parentWindow, runsGraph, **kwargs):
+
+
+        super().__init__(parentWindow,
+                         title="Locate a protocol in the graph",
+                         **kwargs)
+        self.runsGraph = runsGraph
+
+    def _onSearchClick(self, e=None):
+
+        self._resultsTree.clear()
+        keyword = self._searchVar.get().lower().strip()
+
+        weightIndex = len(self.columnConfig)
+        nodes = self.runsGraph.getNodes()
+        protList = []
+
+        for node in nodes:
+            if node.run is not None:
+                run = node.run
+                key = run.getObjId()
+                label = run.getRunName()
+                status = run.getStatusMessage(),
+                time = run.getObjCreation()
+                comment = run.getObjComment()
+                expanded = "expanded" if getattr(node, 'expanded', False) else "collapsed"
+                line = (key, label, status, time, comment, expanded)
+
+                line = self.addSearchWeight(line, keyword)
+                # something was found: weight > 0
+                if line[weightIndex] != 0:
+                    # Add the run
+                    protList.append(line)
+
+        # Sort by weight
+        protList.sort(reverse=True, key=lambda x: x[weightIndex])
+
+        for line in protList:
+
+            self._resultsTree.insert(
+                '', 'end', line[0], text=line[0],
+                values=line[1:])
+
+
+

pyworkflow/gui/project/steps.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+# **************************************************************************
+# *
+# * Authors:     Pablo Conesa [1]
+# *
+# * [1] 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, see <https://www.gnu.org/licenses/>.
+# *
+# *  All comments concerning this program package may be sent to the
+# *  e-mail address 'scipion@cnb.csic.es'
+# *
+# **************************************************************************
+""" This modules hosts gui code to visualize steps"""
+import json
+import tkinter as tk
+
+import pyworkflow.protocol as pwprot
+import  pyworkflow.gui as pwgui
+import pyworkflow.utils as pwutils
+
+from pyworkflow import TK
+from pyworkflow.utils import Icon
+
+
+class StepsTreeProvider(pwgui.tree.TreeProvider):
+    """Create the tree elements for a Protocol run"""
+
+    def __init__(self, stepsList):
+        for i, s in enumerate(stepsList):
+            if not s._index:
+                s._index = i + 1
+
+        self._stepsList = stepsList
+        self.getColumns = lambda: [('Index', 50), ('Step', 200), ('Status', 150),
+                                   ('Time', 150), ('Class', 100)]
+        self._parentDict = {}
+
+    def getObjects(self):
+        return self._stepsList
+
+    @staticmethod
+    def getObjectInfo(obj):
+        info = {'key': obj._index,
+                'values': (str(obj), obj.getStatus(), pwutils.prettyDelta(obj.getElapsedTime()),
+                           obj.getClassName())}
+        return info
+
+    @staticmethod
+    def getObjectPreview(obj: pwprot.Step):
+
+        args = json.loads(obj.argsStr.get())
+        msg = "*Prerequisites*: %s \n" % str(obj._prerequisites)
+
+        msg += ("*Arguments*:\n")
+        for arg in args:
+            msg += " %s\n" % arg
+
+        msg += "*Needs GPU*: %s" % obj.needsGPU()
+
+        if hasattr(obj, 'resultFiles'):
+            results = json.loads(obj.resultFiles.get())
+            if len(results):
+                msg += "\n*Result files:* " + '\n  '.join(results)
+
+        return None, msg
+
+class StepsWindow(pwgui.browser.BrowserWindow):
+    def __init__(self, title, parentWindow, protocol, **args):
+        self._protocol = protocol
+        provider = StepsTreeProvider(protocol.loadSteps())
+        pwgui.browser.BrowserWindow.__init__(self, title, parentWindow,
+                                             weight=False, **args)
+        # Create buttons toolbar
+        self.root.columnconfigure(0, weight=1)
+        self.root.rowconfigure(1, weight=1)
+
+        self.fillToolBar()
+
+        # Create and set browser
+        browser = pwgui.browser.ObjectBrowser(self.root, provider,
+                                              showPreviewTop=False)
+        self.setBrowser(browser, row=1, column=0)
+
+    def fillToolBar(self):
+        # Tool bar
+        toolbar = tk.Frame(self.root)
+        toolbar.grid(row=0, column=0, sticky='nw', padx=5, pady=5)
+
+        # Tree button
+        btn = tk.Label(toolbar, text="Tree",
+                       image=self.getImage(Icon.CODE_BRANCH),
+                       compound=tk.LEFT, cursor='hand2')
+        btn.bind(TK.LEFT_CLICK, self._showTree)
+        btn.grid(row=0, column=0, sticky='nw')
+
+        # Reset status
+        btn = tk.Label(toolbar, text="Reset",
+                       image=self.getImage(Icon.BROOM),
+                       compound=tk.LEFT, cursor='hand2')
+        btn.bind('<Button-1>', self._resetStep)
+        btn.grid(row=0, column=1, sticky='nw')
+
+        # Finish status
+        btn = tk.Label(toolbar, text="Finish",
+                       image=self.getImage(Icon.CHECKED),
+                       compound=tk.LEFT, cursor='hand2')
+        btn.bind('<Button-1>', self._finishStep)
+        btn.grid(row=0, column=2, sticky='nw')
+
+    def _setStepStatus(self, status):
+
+        item = self.browser._lastSelected
+        if item is not None:
+            objId = item.getObjId()
+            self._protocol._updateSteps(lambda step: step.setStatus(status), where="id='%s'" % objId)
+            item.setStatus(status)
+            self.browser.tree.update()
+    def _resetStep(self, e=None):
+        self._setStepStatus(pwprot.STATUS_NEW)
+
+    def _finishStep(self, e=None):
+        self._setStepStatus(pwprot.STATUS_FINISHED)
+
+    # noinspection PyUnusedLocal
+    def _showTree(self, e=None):
+        g = self._protocol.getStepsGraph()
+        w = pwgui.Window("Protocol steps", self, minsize=(800, 600))
+        root = w.root
+        canvas = pwgui.Canvas(root, width=600, height=500,
+                              tooltipCallback=self._stepTooltip,)
+        canvas.grid(row=0, column=0, sticky='nsew')
+        canvas.drawGraph(g, pwgui.LevelTreeLayout())
+        w.show()
+
+    def _stepTooltip(self, tw, item):
+        """ Create the contents of the tooltip to be displayed
+        for the given step.
+        Params:
+            tw: a tk.TopLevel instance (ToolTipWindow)
+            item: the selected step.
+        """
+
+        if not hasattr(item.node, 'step'):
+            return
+
+        step = item.node.step
+
+        tm = str(step.funcName)
+
+        if not hasattr(tw, 'tooltipText'):
+            frame = tk.Frame(tw)
+            frame.grid(row=0, column=0)
+            tw.tooltipText = pwgui.dialog.createMessageBody(
+                frame, tm, None, textPad=0, textBg=pwutils.Color.ALT_COLOR_2)
+            tw.tooltipText.config(bd=1, relief=tk.RAISED)
+        else:
+            pwgui.dialog.fillMessageText(tw.tooltipText, tm)
+
+