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

pyworkflow/project/project.py

@@ -26,6 +26,7 @@
 # **************************************************************************
 import logging
 
+from .usage import ScipionWorkflow
 from ..protocol.launch import _checkJobStatus
 
 ROOT_NODE_NAME = "PROJECT"
@@ -48,7 +49,7 @@ from pyworkflow.mapper import SqliteMapper
 from pyworkflow.protocol.constants import (MODE_RESTART, MODE_RESUME,
                                            STATUS_INTERACTIVE, ACTIVE_STATUS,
                                            UNKNOWN_JOBID, INITIAL_SLEEP_TIME, STATUS_FINISHED)
-from pyworkflow.protocol.protocol import Protocol
+from pyworkflow.protocol.protocol import Protocol, LegacyProtocol
 
 from . import config
 
@@ -587,7 +588,7 @@ class Project(object):
             self._continueWorkflow(errorsList,workflowProtocolList)
         return errorsList
 
-    def launchProtocol(self, protocol, wait=False, scheduled=False,
+    def launchProtocol(self, protocol:Protocol, wait=False, scheduled=False,
                        force=False):
         """ In this function the action of launching a protocol
         will be initiated. Actions done here are:
@@ -633,13 +634,15 @@ class Project(object):
                 self.mapper.deleteRelations(self)
                 # Clean and persist execution attributes; otherwise, this would retain old job IDs and PIDs.
                 protocol.cleanExecutionAttributes()
-                protocol._store(protocol._jobId)
+                protocol._store(protocol._jobId, protocol._pid)
 
             self.mapper.commit()
 
             # NOTE: now we are simply copying the entire project db, this can be
             # changed later to only create a subset of the db need for the run
             pwutils.path.copyFile(self.dbPath, protocol.getDbPath())
+            # Update the lastUpdateTimeStamp so later PID obtained in launch is not "remove" with run.db data.
+            protocol.lastUpdateTimeStamp.set(pwutils.getFileLastModificationDate(protocol.getDbPath()))
 
         # Launch the protocol; depending on the case, either the pId or the jobId will be set in this call
         pwprot.launch(protocol, wait)
@@ -683,8 +686,14 @@ class Project(object):
         self.mapper.store(protocol)
         self.mapper.commit()
 
-    def _updateProtocol(self, protocol: Protocol, tries=0, checkPid=False,
-                        skipUpdatedProtocols=True):
+    def _updateProtocol(self, protocol: Protocol, tries=0, checkPid=False):
+        """ Update the protocol passed taking the data from its run.db.
+        It also checks if the protocol is alive base on its PID of JOBIDS """
+        # NOTE: when this method fails recurrently....we are setting the protocol to failed and
+        # therefore closing its outputs. This, in streaming scenarios triggers a false closing to protocols
+        # while actual protocol is still alive but
+
+        updated = pw.NOT_UPDATED_UNNECESSARY
 
         # If this is read only exit
         if self.openedAsReadOnly():
@@ -692,67 +701,88 @@ class Project(object):
 
         try:
 
-            # Backup the values of 'jobId', 'label' and 'comment'
-            # to be restored after the .copy
-            jobId = protocol.getJobIds().clone()  # Use clone to prevent this variable from being overwritten or cleared in the latter .copy() call
-            label = protocol.getObjLabel()
-            comment = protocol.getObjComment()
+            # IMPORTANT: the protocol after some iterations of this ends up without the project!
+            # This is a problem if we want tu use protocol.useQueueForJobs that uses project info!
+            # print("PROJECT: %s" % protocol.getProject())
 
-            if skipUpdatedProtocols:
-                # If we are already updated, comparing timestamps
-                if pwprot.isProtocolUpToDate(protocol):
+            # If the protocol database has changes ....
+            if not pwprot.isProtocolUpToDate(protocol):
 
-                    # Always check for the status of the process (queue job or pid)
-                    self.checkIsAlive(protocol)
-                    return pw.NOT_UPDATED_UNNECESSARY
+                logger.debug("Protocol %s outdated. Updating it now." % protocol.getRunName())
 
+                updated = pw.PROTOCOL_UPDATED
 
-            # If the protocol database has ....
-            #  Comparing date will not work unless we have a reliable
-            # lastModificationDate of a protocol in the project.sqlite
-            prot2 = pwprot.getProtocolFromDb(self.path,
-                                             protocol.getDbPath(),
-                                             protocol.getObjId())
+                # Backup the values of 'jobId', 'label' and 'comment'
+                # to be restored after the .copy
+                jobId = protocol.getJobIds().clone()  # Use clone to prevent this variable from being overwritten or cleared in the latter .copy() call
+                label = protocol.getObjLabel()
+                comment = protocol.getObjComment()
+                project = protocol.getProject() # The later protocol.copy(prot2, copyId=False, excludeInputs=True) cleans the project!!
 
-            # Capture the db timestamp before loading.
-            lastUpdateTime = pwutils.getFileLastModificationDate(protocol.getDbPath())
+                if project is None:
+                    logger.warning("Protocol %s hasn't the project associated when updating it." % label)
 
-            # Copy is only working for db restored objects
-            protocol.setMapper(self.mapper)
+                #  Comparing date will not work unless we have a reliable
+                # lastModificationDate of a protocol in the project.sqlite
+                prot2 = pwprot.getProtocolFromDb(self.path,
+                                                 protocol.getDbPath(),
+                                                 protocol.getObjId())
 
-            localOutputs = list(protocol._outputs)
-            protocol.copy(prot2, copyId=False, excludeInputs=True)
+                # Capture the db timestamp before loading.
+                lastUpdateTime = pwutils.getFileLastModificationDate(protocol.getDbPath())
 
-            # merge outputs: This is necessary when outputs are added from the GUI
-            # e.g.: adding coordinates from analyze result and protocol is active (interactive).
-            for attr in localOutputs:
-                if attr not in protocol._outputs:
-                    protocol._outputs.append(attr)
+                # Copy is only working for db restored objects
+                protocol.setMapper(self.mapper)
 
-            # Restore backup values
-            if protocol.useQueueForProtocol() and jobId:  # If jobId not empty then restore value as the db is empty
-                # Case for direct protocol launch from the GUI. Without passing through a scheduling process.
-                # In this case the jobid is obtained by the GUI and the job id should be preserved.
-                protocol.setJobIds(jobId)
+                localOutputs = list(protocol._outputs)
+                protocol.copy(prot2, copyId=False, excludeInputs=True) # This cleans protocol._project cause getProtocolFromDb does not bring the project
+                protocol.setProject(project)
 
-            # In case of scheduling a protocol, the jobid is obtained during the "scheduling job"
-            # and it is written in the rub.db. Therefore, it should be taken from there.
+                # merge outputs: This is necessary when outputs are added from the GUI
+                # e.g.: adding coordinates from analyze result and protocol is active (interactive).
+                for attr in localOutputs:
+                    if attr not in protocol._outputs:
+                        protocol._outputs.append(attr)
 
-            protocol.setObjLabel(label)
-            protocol.setObjComment(comment)
-            # Use the run.db timestamp instead of the system TS to prevent
-            # possible inconsistencies.
-            protocol.lastUpdateTimeStamp.set(lastUpdateTime)
+                # Restore backup values
+                if protocol.useQueueForProtocol() and jobId:  # If jobId not empty then restore value as the db is empty
+                    # Case for direct protocol launch from the GUI. Without passing through a scheduling process.
+                    # In this case the jobid is obtained by the GUI and the job id should be preserved.
+                    protocol.setJobIds(jobId)
 
-            # Check pid at the end, once updated
-            if checkPid:
-                self.checkIsAlive(protocol)
+                # In case of scheduling a protocol, the jobid is obtained during the "scheduling job"
+                # and it is written in the rub.db. Therefore, it should be taken from there.
+
+                # Restore values edited in the GUI
+                protocol.setObjLabel(label)
+                protocol.setObjComment(comment)
+                # Use the run.db timestamp instead of the system TS to prevent
+                # possible inconsistencies.
+                protocol.lastUpdateTimeStamp.set(lastUpdateTime)
+
+                # # Check pid at the end, once updated. It may have brought new pids? Job ids? or process died and pid
+                # # pid and job ids were reset and status set to failed, so it does not make sense to check pids
+                # if checkPid and protocol.isActive():
+                #     self.checkIsAlive(protocol)
+
+                # Close DB connections to rundb
+                prot2.getProject().closeMapper()
+                prot2.closeMappers()
 
-            self.mapper.store(protocol)
 
-            # Close DB connections
-            prot2.getProject().closeMapper()
-            prot2.closeMappers()
+            # If protocol is still active
+            if protocol.isActive():
+                # If it is still alive, and hasn't been updated from run db
+                # NOTE: checkIsAlive may have changed the protocol status,in case the process ware killed
+                # So we need to persist those changes.
+                if not self.checkIsAlive(protocol):
+
+                     updated = pw.PROTOCOL_UPDATED
+
+
+            if updated == pw.PROTOCOL_UPDATED:
+                # We store changes, either after updating the protocol with data from run-db or because it died
+                self.mapper.store(protocol)
 
         except Exception as ex:
             if tries == 3:  # 3 tries have been failed
@@ -766,19 +796,34 @@ class Project(object):
                     pass
                 return pw.NOT_UPDATED_ERROR
             else:
-                logger.warning("Couldn't update protocol %s(jobId=%s) from it's own database. ERROR: %s, attempt=%d"
-                             % (protocol.getObjName(), jobId, ex, tries))
+                logger.warning("Couldn't update protocol %s from it's own database. ERROR: %s, attempt=%d"
+                             % (protocol.getRunName(), ex, tries))
                 time.sleep(0.5)
-                self._updateProtocol(protocol, tries + 1)
+                return self._updateProtocol(protocol, tries + 1)
 
-        return pw.PROTOCOL_UPDATED
+        return updated
 
     def checkIsAlive(self, protocol):
-        """ Check if a protocol is alive based on its jobid or pid"""
-        if protocol.getPid() == 0:
-            self.checkJobId(protocol)
+        """ Check if a protocol is alive based on its jobid (queue engines) or pid
+        :param protocol: protocol to check its status
+        :returns True if it is alive
+        """
+        # For some reason pid ends up with a None...
+        pid = protocol.getPid()
+
+        if pid is None:
+            logger.info("Protocol's %s pid is None and is active... this should not happen. Checking its job id: %s" % (protocol.getRunName(), protocol.getJobIds()))
+            pid = 0
+
+        alive = False
+        if pid == 0:
+            alive = self.checkJobId(protocol)
         else:
-            self.checkPid(protocol)
+            alive = self.checkPid(protocol)
+
+        if alive:
+            logger.debug("Protocol %s is alive." % protocol.getRunName())
+        return alive
 
     def stopProtocol(self, protocol):
         """ Stop a running protocol """
@@ -908,7 +953,7 @@ class Project(object):
                                     break
                                 # If it is a class already: "possibleOutput" case. In this case attr is the class and not
                                 # an instance of c. In this special case
-                                elif possibleOutput and attr == c:
+                                elif possibleOutput and issubclass(attr, c):
                                     match = True
                                     cancelConditionEval = True
 
@@ -1239,6 +1284,39 @@ class Project(object):
 
         return result
 
+    def getProjectUsage(self) -> ScipionWorkflow:
+        """ returns usage class ScipionWorkflow populated with project data
+        """
+        protocols = self.getRuns()
+
+        # Handle the copy of a list of protocols
+        # for this case we need to update the references of input/outputs
+        sw = ScipionWorkflow()
+        g = self.getRunsGraph()
+
+        for prot in protocols:
+
+            if not isinstance(prot, LegacyProtocol):
+                # Add a count for the protocol
+                protName = prot.getClassName()
+                sw.addCount(protName)
+
+                # Add next protocols count
+                node = g.getNode(prot.strId())
+
+                for childNode in node.getChildren():
+                    prot = childNode.run
+                    if not isinstance(prot, LegacyProtocol):
+                        nextProtName = prot.getClassName()
+                        sw.addCountToNextProtocol(protName, nextProtName)
+
+                # Special case: First protocols, those without parent. Import protocols mainly.
+                # All protocols, even the firs ones have a parent. For the fisrt ones the parent is "PROJECT" node that is the only root one.
+                if node.getParent().isRoot():
+                    sw.addCountToNextProtocol(str(None), protName)
+
+        return sw
+
     def getProtocolsDict(self, protocols=None, namesOnly=False):
         """ Creates a dict with the information of the given protocols.
 
@@ -1567,6 +1645,7 @@ class Project(object):
             for r in self.runs:
 
                 self._setProtocolMapper(r)
+                r.setProject(self)
 
                 # Check for run warnings
                 r.checkSummaryWarnings()
@@ -1611,39 +1690,45 @@ class Project(object):
         """ Check if a running protocol is still alive or not.
         The check will only be done for protocols that have not been sent
         to a queue system.
+
+        :returns True if pid is alive or irrelevant
         """
         from pyworkflow.protocol.launch import _runsLocally
         pid = protocol.getPid()
 
         if pid == 0:
-            return
+            return True
 
         # Include running and scheduling ones
         # Exclude interactive protocols
         # NOTE: This may be happening even with successfully finished protocols
         # which PID is gone.
-        if (protocol.isActive() and not protocol.isInteractive() and _runsLocally(protocol)
+        if (protocol.isActive() and not protocol.isInteractive()
                 and not pwutils.isProcessAlive(pid)):
             protocol.setFailed("Process %s not found running on the machine. "
                                "It probably has died or been killed without "
                                "reporting the status to Scipion. Logs might "
                                "have information about what happened to this "
                                "process." % pid)
+            return False
+
+        return True
 
     def checkJobId(self, protocol):
         """ Check if a running protocol is still alive or not.
         The check will only be done for protocols that have been sent
         to a queue system.
-        """
 
+        :returns True if job is still alive or irrelevant
+        """
         if len(protocol.getJobIds()) == 0:
-            return
-
+            logger.warning("Checking if protocol alive in the queue but JOB ID is empty. Considering it dead.")
+            return False
         jobid = protocol.getJobIds()[0]
         hostConfig = protocol.getHostConfig()
 
         if jobid == UNKNOWN_JOBID:
-            return
+            return True
 
         # Include running and scheduling ones
         # Exclude interactive protocols
@@ -1654,12 +1739,15 @@ class Project(object):
             jobStatus = _checkJobStatus(hostConfig, jobid)
 
             if jobStatus == STATUS_FINISHED:
-                protocol.setFailed("Process %s not found running on the machine. "
-                                   "It probably has died or been killed without "
+                protocol.setFailed("JOB ID %s not found running on the queue engine. "
+                                   "It probably has timeout, died or been killed without "
                                    "reporting the status to Scipion. Logs might "
                                    "have information about what happened to this "
-                                   "process." % jobid)
+                                   "JOB ID." % jobid)
+
+                return False
 
+        return True
     def iterSubclasses(self, classesName, objectFilter=None):
         """ Retrieve all objects from the project that are instances
             of any of the classes in classesName list.

pyworkflow/project/usage.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# **************************************************************************
+# *
+# * Authors:   Pablo Conesa [1]
+# *
+# * [1] Biocomputing unit, CNB-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'
+# *
+# **************************************************************************
+import json
+import logging
+logger = logging.getLogger(__name__)
+
+from urllib.request import urlopen
+from pyworkflow import Config
+
+
+# Module to have Models for reporting usage data to the scipion.i2pc.es site.
+class ProtStat:
+    """ Class to store the usage part of a reported ScipionWorkflow"""
+    def __init__(self, count=0, nextProtsDict=None):
+        self._count = count
+        self._nextProts = nextProtsDict or dict()
+
+    def getCount(self):
+        return self._count
+    def addUsage(self, count=1):
+        self._count += count
+    def addCountToNextProtocol(self, nextProt, count=1):
+        self._nextProts[nextProt] = self._nextProts.get(nextProt, 0) + count
+
+    def toJSON(self):
+        jsonStr = "[%s,{%s}]"
+        nextProtS = ""
+
+        if len(self._nextProts):
+            nextProtA = []
+            for protName, count in self._nextProts.items():
+                nextProtA.append('"%s":%d' % (protName, count))
+
+            nextProtS= ",".join(nextProtA)
+
+        jsonStr = jsonStr % (self._count, nextProtS)
+
+        return jsonStr
+
+    def __repr__(self):
+        return self.toJSON()
+
+class ScipionWorkflow:
+    """ Class to serialize and deserialize what is reported from scipion.
+    Example: {"ProtA":
+                [2, {
+                        "ProtB":2,
+                        "ProtC":3,
+                        ...
+                    }
+                ], ...
+              }
+    """
+
+    def __init__(self, jsonStr=None):
+        """ Instantiate this class optionally with a JSON string serialized from this class
+        (what is sent by Scipion to this web service)."""
+
+        self._prots = dict()
+        if jsonStr is not None:
+            self.deserialize(jsonStr)
+
+    def getProtStats(self):
+        return self._prots
+
+    def deserialize(self, jsonStr):
+        """ Deserialize a JSONString serialized by this class with the toJSON method"""
+        jsonObj = json.loads(jsonStr)
+
+        if isinstance(jsonObj, dict):
+            self.deserializeV2(jsonObj)
+        else:
+            self.deserializeList(jsonObj)
+
+    def deserializeV2(self, jsonObj):
+        """ Deserializes v2 usage stats: something like {"ProtA": [2,{..}],...} """
+        for key, value in jsonObj.items():
+            # Value should be something like [2,{..}]
+            count = value[0]
+            nextProtDict = value[1]
+            nextProt = ProtStat(count, nextProtDict)
+            self._prots[key] = nextProt
+
+    def deserializeList(self, jsonObj):
+        """ Deserializes old data: a list of protocol names repeated: ["ProtA","ProtA", "ProtB", ...] """
+
+        for protName in jsonObj:
+            self.addCount(protName)
+
+    def addCount(self, protName):
+        """ Adds one to the count of a protocol"""
+
+        protStat = self.getProtStat(protName)
+
+        protStat.addUsage()
+
+    def getProtStat(self, protName):
+
+        protStat = self._prots.get(protName, ProtStat())
+        if protName not in self._prots:
+            self._prots[protName] = protStat
+
+        return protStat
+
+    def addCountToNextProtocol(self, protName, nextProtName):
+        protStat = self.getProtStat(protName)
+        protStat.addCountToNextProtocol(nextProtName)
+
+    def getCount(self):
+        """ Returns the number of protocols in the workflow"""
+        count = 0
+        for ps in self._prots.values():
+            count += ps._count
+        return count
+
+    def toJSON(self):
+        """ Returns a valid JSON string"""
+        if len(self._prots) == 0:
+            return "{}"
+        else:
+            jsonStr="{"
+            for protName, protStat in self._prots.items():
+
+                jsonStr += '"%s":%s,' % (protName, protStat.toJSON())
+
+            jsonStr = jsonStr[:-1] + "}"
+
+            return jsonStr
+
+    def __repr__(self):
+        return self.toJSON()
+
+def getNextProtocolSuggestions(protocol):
+    """ Returns the suggestions from the Scipion website for the next protocols to the protocol passed"""
+
+    try:
+        url = Config.SCIPION_STATS_SUGGESTION % protocol  # protocol.getClassName()
+        results = json.loads(urlopen(url).read().decode('utf-8'))
+        return results
+    except Exception as e:
+        logger.error("Suggestions system not available", exc_info=e)
+        return []

pyworkflow/protocol/executor.py

@@ -60,10 +60,7 @@ class StepExecutor:
         """ Set protocol to append active jobs to its jobIds. """
         self.protocol = protocol
 
-    def getRunContext(self):
-        return {PLUGIN_MODULE_VAR: self.protocol.getPlugin().getName()}
-
-    def runJob(self, log, programName, params,
+    def runJob(self, log, programName, params,           
                numberOfMpi=1, numberOfThreads=1,
                env=None, cwd=None, executable=None):
         """ This function is a wrapper around runJob, 
@@ -161,6 +158,9 @@ class StepThread(threading.Thread):
         self.step = step
         self.lock = lock
 
+    def needsGPU(self):
+        return self.step.needsGPU()
+
     def run(self):
         error = None
         try:
@@ -255,24 +255,35 @@ class ThreadStepExecutor(StepExecutor):
                 newGPUList.append(gpuid)
         return newGPUList
 
+    def getCurrentStepThread(self) -> StepThread:
+
+        return threading.current_thread()
+
     def getGpuList(self):
         """ Return the GPU list assigned to current thread
         or empty list if not using GPUs. """
 
         # If the node id has assigned gpus?
-        nodeId = threading.current_thread().thId
-        if nodeId in self.gpuDict:
-            gpus = self.gpuDict.get(nodeId)
-            logger.info("Reusing GPUs (%s) slot for %s" % (gpus, nodeId))
-            return gpus
-        else:
+        stepThread = self.getCurrentStepThread()
 
-            gpus = self.getFreeGpuSlot(nodeId)
-            if gpus is None:
-                logger.warning("Step on node %s is requesting GPUs but there isn't any available. Review configuration of threads/GPUs. Returning an empty list." % nodeId)
-                return []
-            else:
+        # If the step does not need the gpu
+        if not stepThread.needsGPU():
+            # return an empty list
+            return []
+        else:
+            nodeId = stepThread.thId
+            if nodeId in self.gpuDict:
+                gpus = self.gpuDict.get(nodeId)
+                logger.info("Reusing GPUs (%s) slot for %s" % (gpus, nodeId))
                 return gpus
+            else:
+
+                gpus = self.getFreeGpuSlot(nodeId)
+                if gpus is None:
+                    logger.warning("Step on node %s is requesting GPUs but there isn't any available. Review configuration of threads/GPUs. Returning an empty list." % nodeId)
+                    return []
+                else:
+                    return gpus
     def getFreeGpuSlot(self, stepId=None):
         """ Returns a free gpu slot available or None. If node is passed it also reserves it for that node
 
@@ -336,7 +347,7 @@ class ThreadStepExecutor(StepExecutor):
         runningSteps = {}  # currently running step in each node ({node: step})
         freeNodes = list(range(1, self.numberOfProcs+1))  # available nodes to send jobs
         logger.info("Execution threads: %s" % freeNodes)
-        logger.info("Running steps using %s threads. 1 thread is used for this main proccess." % self.numberOfProcs)
+        logger.info("Running steps using %s threads. 1 thread is used for this main process." % self.numberOfProcs)
 
         while True:
             # See which of the runningSteps are not really running anymore.
@@ -452,8 +463,9 @@ class QueueStepExecutor(ThreadStepExecutor):
         self.protocol._store(self.protocol._jobId)
 
         if (jobid is None) or (jobid == UNKNOWN_JOBID):
-            logger.info("jobId is none therefore we set it to fail")
-            raise Exception("Failed to submit to queue.")
+            errorMsg = "Failed to submit to queue. JOBID is not valid. There's probably an error interacting with the queue: %s" % error
+            logger.info(errorMsg)
+            raise Exception(errorMsg)
 
         status = cts.STATUS_RUNNING
         wait = 3

pyworkflow/protocol/hosts.py

@@ -187,13 +187,16 @@ class HostConfig(Object):
                         return default
 
                 def getDict(var):
-                    od = OrderedDict()
+                    try:
+                        od = OrderedDict()
 
-                    if cp.has_option(hostName, var):
-                        for key, value in json.loads(get(var)).items():
-                            od[key] = value
+                        if cp.has_option(hostName, var):
+                            for key, value in json.loads(get(var)).items():
+                                od[key] = value
 
-                    return od
+                        return od
+                    except Exception as e:
+                        raise AttributeError("There is a parsing error in the '%s' variable: %s" % (var, str(e)))
 
                 host.setScipionHome(get(pw.SCIPION_HOME_VAR, pw.Config.SCIPION_HOME))
                 host.setScipionConfig(pw.Config.SCIPION_CONFIG)
@@ -207,9 +210,9 @@ class HostConfig(Object):
 
                 # If the NAME is not provided or empty
                 # do no try to parse the rest of Queue parameters
+                hostQueue.submitPrefix.set(get('SUBMIT_PREFIX', ''))
                 if hostQueue.hasName():
                     hostQueue.setMandatory(get('MANDATORY', 0))
-                    hostQueue.submitPrefix.set(get('SUBMIT_PREFIX', ''))
                     hostQueue.submitCommand.set(get('SUBMIT_COMMAND'))
                     hostQueue.submitTemplate.set(get('SUBMIT_TEMPLATE'))
                     hostQueue.cancelCommand.set(get('CANCEL_COMMAND'))