scipion-pyworkflow 3.7.0__py3-none-any.whl

pyworkflowtests/protocols.py

@@ -0,0 +1,154 @@
+# -*- 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'
+# *
+# **************************************************************************
+"""
+Definition of Mock protocols to be used within the tests in the Mock Domain
+"""
+
+import time
+import datetime
+import pyworkflow.utils as pwutils
+import pyworkflow.object as pwobj
+import pyworkflow.protocol as pwprot
+from pyworkflowtests.objects import MockSetOfImages, MockImage
+
+class SleepingProtocol(pwprot.Protocol):
+    def __init__(self, **args):
+        pwprot.Protocol.__init__(self, **args)
+        self.name = pwobj.String(args.get('name', None))
+        self.numberOfSleeps = pwobj.Integer(args.get('n', 1))
+        self.runMode = pwobj.Integer(pwprot.MODE_RESUME)
+
+    def sleepStep(self, t):
+        log = self._getPath("step_%02d.txt" % t)
+        f = open(log, 'w+')
+        f.write("Going to sleep at %s\n"
+                % pwutils.dateStr(datetime.datetime.now(), True))
+        time.sleep(t)
+        f.write("  Slept: %d seconds\n" % t)
+        f.write("Awakened at %s\n"
+                % pwutils.dateStr(datetime.datetime.now(), True))
+        f.close()
+        return [log]
+
+    def _insertAllSteps(self):
+        print("Inserting all steps...")
+        for i in range(self.numberOfSleeps.get()):
+            self._insertFunctionStep('sleepStep', i + 1)
+
+
+class ParallelSleepingProtocol(SleepingProtocol):
+    def _insertAllSteps(self):
+        step1 = self._insertFunctionStep('sleepStep', 1)
+        n = 2
+        deps = [step1]
+        for i in range(n):
+            self._insertFunctionStep('sleepStep')
+
+class ConcurrencyProtocol(SleepingProtocol):
+    """ Protocol to test concurrency access to sets"""
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.stepsExecutionMode = pwprot.STEPS_PARALLEL
+
+    def _defineParams(self, form):
+        form.addParallelSection(threads=2, mpi=0)
+
+    def _insertAllSteps(self):
+        n = 2
+        for i in range(n):
+            self._insertFunctionStep(self.sleepAndOutput, 1, prerequisites=[])
+
+    def sleepAndOutput(self, secs):
+        self.sleepStep(secs)
+
+        with self._lock:
+            outputSet = self.getOutputSet("myOutput", MockSetOfImages)
+            newImage = MockImage()
+            time.sleep(1)
+            outputSet.append(newImage)
+            outputSet.write()
+
+        self._store()
+
+
+    def getOutputSet(self, attrName, setClass):
+        output = getattr(self, attrName, None)
+
+        if output is None:
+            output = setClass.create(self._getExtraPath())
+            self._defineOutputs(**{attrName: output})
+
+        return output
+
+class ProtOutputTest(pwprot.Protocol):
+    """ Protocol to test scalar output and input linking"""
+    _label = 'test output'
+
+    def __init__(self, **args):
+        pwprot.Protocol.__init__(self, **args)
+        self.name = pwobj.String(args.get('name', None))
+
+    def _defineParams(self, form):
+
+        section = form.addSection("Input")
+        section.addParam('iBoxSize', pwprot.IntParam, allowsPointers=True,
+                         default=10,
+                         label='Input box size as Integer',
+                         validators=[pwprot.Positive])
+
+        section.addParam('nullableInteger', pwprot.IntParam, allowsPointers=True,
+                         label='Nullable Integer', allowsNull=True)
+
+    def _createOutputStep(self):
+        # New Output would be an Integer
+        boxSize = pwobj.Integer(10)
+
+        if self.iBoxSize.hasValue():
+            boxSize.set(2*int(self.iBoxSize.get()))
+
+        self._defineOutputs(oBoxSize=boxSize)
+
+    def _insertAllSteps(self):
+        self._insertFunctionStep('_createOutputStep')
+
+
+class ProtMultiPointerTest(pwprot.Protocol):
+    """ Class to test how multipointer params are exported to json"""
+    def _defineParams(self, form):
+
+        # This should cover Multipointer params that points to attributes...
+        # therefore extended attribute of pointers should be used
+        form.addParam('mpToAttr', pwprot.MultiPointerParam,
+                      label="Multipointer to attribute",
+                      pointerClass='String',
+                      help="Should point to String inside another protocol")
+
+        # This should cover Multipointer params that points to protocols...
+        # therefore extended attribute of pointers should NOT be used
+        form.addParam('mpToProts', pwprot.MultiPointerParam,
+                      label="Multipointer to sets",
+                      pointerClass='Protocol',
+                      help="Should point to another protocol")

pyworkflowtests/tests/test_canvas.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+# To run only the tests in this file, use:
+# python -m unittest test_canvas -v
+
+import pyworkflow.gui.canvas
+import tkinter
+import math
+from pyworkflow.tests import *
+
+
+class TestCanvas(BaseTest):
+    # IMPORTANT: Tk requires at least that DISPLAY is defined
+    # hence in some environments (like buildbot) the test may fail,
+    # check for the TclError exception
+
+    _labels = [PULL_REQUEST]
+
+    @classmethod
+    def setUpClass(cls):
+        setupTestOutput(cls)
+
+    def distance(self, c1, c2):
+        return round(math.hypot(c2[0] - c1[0], c2[1] - c1[1]), 2)
+
+    def allEqual(self, values):
+        return not values or values.count(values[0]) == len(values)
+
+    def allDifferent(self, values):
+        return not values or len(values) == len(set(values))
+
+    def test_connectorsCoords(self):
+        try:
+            root = tkinter.Tk()
+            canvas = pyworkflow.gui.canvas.Canvas(root, width=800, height=600)
+            tb1 = canvas.createTextbox("First", 100, 100, "blue")
+
+            connectorsCoords = tb1.getConnectorsCoordinates()
+            self.assertTrue(self.allDifferent(connectorsCoords))
+
+            print(connectorsCoords)
+
+            distances = {}
+            for i in range(len(connectorsCoords) - 1):
+                distances[i] = self.distance(connectorsCoords[i],
+                                             connectorsCoords[i + 1])
+
+                print(distances)
+                self.assertTrue(self.allEqual(list(distances.values())))
+                self.assertNotEqual(distances[0], 0)
+        except tkinter.TclError as ex:
+            print(ex)
+
+    def test_closestConnectors(self):
+        try:
+            root = tkinter.Tk()
+            canvas = pyworkflow.gui.canvas.Canvas(root, width=800, height=600)
+            tb1 = canvas.createTextbox("Textbox1", 100, 100, "blue")
+            tb2 = canvas.createTextbox("Textbox2", 300, 100, "blue")
+            tb3 = canvas.createTextbox("Textbox3", 100, 300, "blue")
+
+            tb1ConnectorsCoords = tb1.getConnectorsCoordinates()
+            tb2ConnectorsCoords = tb2.getConnectorsCoordinates()
+            tb3ConnectorsCoords = tb3.getConnectorsCoordinates()
+            c1, c2 = pyworkflow.gui.canvas.findStrictClosestConnectors(tb1, tb2)
+            c3, c4 = pyworkflow.gui.canvas.findStrictClosestConnectors(tb1, tb3)
+            # tb1 and tb2 are aligned vertically. tb1 and tb3, horizontally.
+            # So, their closest connectors must share one coordinate (y in case of c1&c2, x i n case of c3&c4)
+            self.assertEqual(c1[1], c2[1])
+            self.assertEqual(c3[0], c4[0])
+
+        except tkinter.TclError as ex:
+            print(ex)

pyworkflowtests/tests/test_domain.py

@@ -0,0 +1,45 @@
+#!/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, 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 pyworkflow.tests as pwtests
+import pyworkflowtests.objects as objectsMod
+from pyworkflowtests import Domain
+
+
+class TestDomain(pwtests.BaseTest):
+
+    def test_objects(self):
+        """ Test that all objects are properly discovered. """
+        objects = Domain.getObjects()
+        for k in dir(objectsMod):
+            v = getattr(objectsMod, k)
+            if isinstance(v, objectsMod.MockObject):
+                self.assertEqual(objects[k], v)
+
+    def test_viewers(self):
+        pass
+
+    def test_wizards(self):
+        pass

pyworkflowtests/tests/test_logs.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+
+import logging
+import unittest
+
+from pyworkflow import Config
+from pyworkflow.utils import (getLineInFile,
+                              LoggingConfigurator, restoreStdoutAndErr)
+from pyworkflow.tests import BaseTest, setupTestOutput
+from pyworkflow.utils.process import runJob
+
+
+class TestLogs(BaseTest):
+    
+    @classmethod
+    def setUpClass(cls):
+        setupTestOutput(cls)        
+
+    def testSimpleFileLog(self):
+
+        # Default generic configuration
+        Config.SCIPION_LOG = self.getOutputPath("general.log")
+        genLogFn = Config.SCIPION_LOG
+        print("General log file at %s" % genLogFn)
+        LoggingConfigurator.setupLogging()
+        log1 = logging.getLogger('pyworkflow.test.log.test_scipion_log')
+
+        def testMessage(message, msg_callback, file, shouldExist):
+
+            if msg_callback:
+                msg_callback(message)
+
+            self.assertEqual(shouldExist, bool(getLineInFile(message, file)))
+
+        testMessage("INFO to GEN", log1.info, genLogFn, True)
+        testMessage("DEBUG missing in GEN", log1.debug, genLogFn, False)
+        testMessage("WARNING in GEN", log1.warning, genLogFn, True)
+        testMessage("ERROR in GEN", log1.error, genLogFn, True)
+
+        # Protocol run logging configuration (this is propagating the messages,
+        # so messages end un in general log too). This is to allow custom configurations to receive running protocol messages)
+        logFn = self.getOutputPath('stdout.log')
+        logErrFn = self.getOutputPath('stdErr.log')
+        log2 = LoggingConfigurator.setUpProtocolRunLogging(logFn, logErrFn)
+
+        fileInfoTest = 'INFO to FILE'
+        testMessage(fileInfoTest, log2.info, logFn, True)
+        testMessage(fileInfoTest, None, genLogFn, False)
+
+        fileDebugMsg = "DEBUG does not reach FILE nor GEN"
+        testMessage(fileDebugMsg, log2.debug, logFn, False)
+        testMessage(fileDebugMsg, None, genLogFn, False)
+
+        fileWarningTest = 'WARNING to FILE and not GEN'
+        testMessage(fileWarningTest, log2.warning, logFn, True)
+        testMessage(fileWarningTest, None, genLogFn, False)
+
+        fileErrorTest = 'ERROR to FILE and not GEN'
+        testMessage(fileErrorTest, log2.error, logErrFn, True)
+        testMessage(fileErrorTest, None, genLogFn, False)
+
+        # Test print goes to the log file (stdout is captured)
+        printStdOut = "Print ends up in stdout FILE"
+        print(printStdOut, flush=True)
+        testMessage(printStdOut,None, logFn, True)
+
+        subprocessOut = "subprocess output in stdout FILE"
+        runJob(None,"echo", subprocessOut)
+        testMessage(subprocessOut,None, logFn, True)
+
+        restoreStdoutAndErr()
+
+if __name__ == '__main__':
+    unittest.main()