Exemplo n.º 1
0
 def _onRemoveVersion(self):
     """Remove this version from the caffe_version_manager"""
     self.versionManager._onRemoveVersion(self.caffe_version.getName(), self.host)
     if self.host == None:
         self.restartWarning()
     else:
         msgBox = QMessageBox(QMessageBox.Warning, "Warning", "Please restart Barista host for changes to apply, otherwise Barista may be unstable!")
         msgBox.addButton("Ok", QMessageBox.NoRole)
         msgBox.addButton("Restart now", QMessageBox.YesRole)
         if msgBox.exec_() == 1:
             msg = {"key": Protocol.RESTART, "pid": self.versionManager.project.getProjectId()}
             sendMsgToHost(self.host.host, self.host.port, msg)
Exemplo n.º 2
0
    def createRemoteSession(self, remote, state_dictionary=None):
        """use this only to create entirely new sessions. to load existing use the loadRemoteSession command"""

        msg = {"key": Protocol.GETCAFFEVERSIONS}
        reply = sendMsgToHost(remote[0], remote[1], msg)
        if reply:
            remoteVersions = reply["versions"]
            if len(remoteVersions) <= 0:
                msgBox = QMessageBox(
                    QMessageBox.Warning, "Error",
                    "Cannot create remote session on a host witout a caffe-version"
                )
                msgBox.addButton("Ok", QMessageBox.NoRole)
                msgBox.exec_()
                return None

        sid = self.getNextSessionId()
        msg = {
            "key": Protocol.CREATESESSION,
            "pid": self.projectId,
            "sid": sid
        }

        layers = []
        for layer in state_dictionary["network"]["layers"]:
            layers.append(state_dictionary["network"]["layers"][layer]
                          ["parameters"]["type"])

        msg["layers"] = layers

        ret = sendMsgToHost(remote[0], remote[1], msg)
        if ret:
            if ret["status"]:
                uid = ret["uid"]
            else:
                for e in ret["error"]:
                    Log.error(e, self.getCallerId())
                return None
        else:
            Log.error('Failed to create remote session! No connection to Host',
                      self.getCallerId())
            return None

        session = ClientSession(self, remote, uid, sid)
        if state_dictionary is not None:
            session.state_dictionary = state_dictionary
        self.__sessions[sid] = session
        self.newSession.emit(sid)
        return sid
 def _onRemoveVersion(self, name, host):
     """Removes the selected caffe version"""
     if host == None:
         if caffeVersions.getAvailableVersions() > 1:
             caffeVersions.removeVersion(
                 caffeVersions.getVersionByName(name))
             if (self.project.getCaffeVersion() == name):
                 self.project.changeProjectCaffeVersion(
                     caffeVersions.getDefaultVersion().getName())
         else:
             QMessageBox.warning(
                 self, self.tr("Warning"),
                 self.
                 tr("Cannot delete version. At least one caffe-version must be available at all times in barista."
                    ))
     else:
         msg = {"key": Protocol.REMOVECAFFEVERSION, "versionname": name}
         sendMsgToHost(host.host, host.port, msg)
     self.updateList()
Exemplo n.º 4
0
 def _onSetCurrent(self):
     """Sets this version as the current projects/remote hosts caffe version"""
     if self.host == None:
         self.versionManager.project.changeProjectCaffeVersion(self.caffe_version.getName())
         self.restartWarning()
         caffeVersions.restart = True
     else:
         msg = {"key": Protocol.SETCURRENTCAFFEVERSION, "versionname": self.caffe_version.getName()}
         sendMsgToHost(self.host.host, self.host.port, msg)
         
         msgBox = QMessageBox(QMessageBox.Warning, "Warning", "Please restart Barista host for changes to apply, otherwise Barista may be unstable!")
         msgBox.addButton("Ok", QMessageBox.NoRole)
         msgBox.addButton("Restart now", QMessageBox.YesRole)
         
         if msgBox.exec_() == 1:
             msg = {"key": Protocol.RESTART, "pid": self.versionManager.project.getProjectId()}
             ret = sendMsgToHost(self.host.host, self.host.port, msg)
             if ret and not ret["status"]:
                 msgBox = QMessageBox(QMessageBox.Warning, "Warning", ret["error"][0])
                 msgBox.addButton("Ok", QMessageBox.NoRole)
                 msgBox.exec_()
     self.versionManager.updateList()
Exemplo n.º 5
0
    def cloneRemoteSession(self, oldSolverstate, oldSession):
        """
         Starts the cloning process for a remote session and creates the corr. local session upon success

         oldSolverstate: solverstate produced by the snapshot from which the clone should be created
         oldSession: session from which a clone should be created (type ClientSession)
        """
        # validate the given session and solverstate
        if oldSolverstate is None:
            Log.error('Could not find solver', self.getCallerId())
            return None
        if oldSession is None:
            Log.error('Failed to create session!', self.getCallerId())
            return None

        sid = self.getNextSessionId()
        # call the remote host to invoke cloning; @see cloneSession in server_session_manager.py
        msg = {
            "key": Protocol.CLONESESSION,
            "pid": self.projectId,
            "sid": sid,
            "old_uid": oldSession.uid,
            "old_solverstate": oldSolverstate
        }
        ret = sendMsgToHost(oldSession.remote[0], oldSession.remote[1], msg)
        # receive and validate answer
        if ret:
            if ret["status"]:
                uid = ret["uid"]
            else:
                for e in ret["error"]:
                    Log.error(e, self.getCallerId())
                return None
        else:
            Log.error('Failed to clone remote session! No connection to Host',
                      self.getCallerId())
            return None
        # Create a corr. local session and copy (if available) the state-dictionary to maintain
        # solver/net etc.
        session = ClientSession(self, oldSession.remote, uid, sid)
        if hasattr(oldSession, 'state_dictionary'):
            session.state_dictionary = oldSession.state_dictionary
        self.__sessions[sid] = session
        self.newSession.emit(sid)
        return sid
Exemplo n.º 6
0
        def updateModel(self, path="/home/", fileFilter=["*"]):
            """update the model by connecting to the host and asking for a new dir dictionary"""

            msg = {
                "key": Protocol.GETDIR,
                "path": path,
                "filter": fileFilter,
                "dirSelect": False
            }
            if self.dirselect:
                msg["dirSelect"] = True
            res = sendMsgToHost(self.host, self.port, msg)
            if res:
                self.currentPath = res["path"]
                oldlen = len(self.fileList)
                newlen = len(res["data"])
                diff = oldlen - newlen

                if diff > 0:
                    self.beginRemoveRows(QModelIndex(), newlen, oldlen - 1)
                    self.fileList = res[
                        "data"]  # has to be done here to prevent invalid index exception
                    self.endRemoveRows()

                if diff < 0:
                    self.beginInsertRows(QModelIndex(), oldlen, newlen - 1)
                    self.fileList = res[
                        "data"]  # has to be done here to prevent invalid index exception
                    self.endInsertRows()

                if diff == 0:
                    self.fileList = res["data"]
                    self.dataChanged.emit(self.createIndex(0, 0),
                                          self.createIndex(newlen, 2))

                self.updateStatus.emit(True)
                return

            self.updateStatus.emit(False)
    def updateList(self):
        """updates the list containing all available caffe versions"""
        self.lstVersions.clear()

        lblLocalVersion = QLabel("Local versions:")
        lblLocalVersion.setFont(self.boldFont)
        self.addListWidget(lblLocalVersion, False, False)

        localCurrent = ""
        if self.project != None:
            localCurrent = self.project.getCaffeVersion()

        for version in caffeVersions.getAvailableVersions():
            name = version.getName()
            selected = self.versionsEqual(self.selectedVersion, {
                "host": None,
                "versionname": version.getName()
            })
            widget = CaffeVersionWidget(caffeVersions.getVersionByName(name),
                                        self.lstVersions,
                                        self,
                                        isSelected=selected,
                                        current=name == localCurrent,
                                        restart=caffeVersions.restart,
                                        host=None)
            self.addListWidget(widget, True, selected)

        for host in self.hostManager.getActiveHostList():
            host = self.hostManager.getHostById(host[0])
            lblRemoteVersion = QLabel("Versions on " + host.host + ":" +
                                      str(host.port) + ":")
            lblRemoteVersion.setFont(self.boldFont)
            lblRemoteVersion.setStyleSheet(
                lblRemoteVersion.styleSheet() +
                "QLabel{ border-top: 1px solid black; }")
            self.addListWidget(lblRemoteVersion, False, False)

            remoteCurrent = ""
            msg = {"key": Protocol.GETDEFAULTCAFFEVERSION}
            reply = sendMsgToHost(host.host, host.port, msg)
            if reply:
                if reply["status"]:
                    remoteCurrent = reply["defaultVersionName"]

            remoteRestart = False
            msg = {"key": Protocol.GETCAFFERESTART}
            reply = sendMsgToHost(host.host, host.port, msg)
            if reply:
                if reply["status"]:
                    remoteRestart = reply["cafferestart"]

            msg = {"key": Protocol.GETCAFFEVERSIONS}
            reply = sendMsgToHost(host.host, host.port, msg)
            if reply:
                remoteVersions = reply["versions"]
                for version in remoteVersions:
                    version = caffeVersions.caffeVersion(
                        version, remoteVersions[version]["root"],
                        remoteVersions[version]["binary"],
                        remoteVersions[version]["python"],
                        remoteVersions[version]["proto"])
                    selected = self.versionsEqual(
                        self.selectedVersion, {
                            "host": host,
                            "versionname": version.getName()
                        })
                    widget = CaffeVersionWidget(
                        version,
                        self.lstVersions,
                        self,
                        isSelected=selected,
                        current=remoteCurrent == version.getName(),
                        restart=remoteRestart,
                        host=host)
                    self.addListWidget(widget, True, selected)
Exemplo n.º 8
0
 def _getHardware(self):
     msg = {"key": Protocol.GETHARDWARE}
     ret = sendMsgToHost(self.host, self.port, msg)
     if ret and "hardware" in ret:
         return [ret["hardware"], ret["current"]]
Exemplo n.º 9
0
 def getSessionsOfProject(self, pid):
     msg = {"key": Protocol.GETSESSIONS, "pid": pid}
     return sendMsgToHost(self.host, self.port, msg)
Exemplo n.º 10
0
 def setHardware(self, hid):
     msg = {"key": Protocol.SETHARDWARE, "hid": hid}
     return sendMsgToHost(self.host, self.port, msg)
Exemplo n.º 11
0
 def makePathRealtiveDirect(self, host, port, path):
     msg = {"key": Protocol.MAKEPATHRELATIVE, "path": path}
     ret = sendMsgToHost(host, port, msg)
     if ret:
         return ret["path"]
Exemplo n.º 12
0
    def __init__(self, reason, buttontext, quitonclose = False, parent = None, remote = False, host = None):
        super(CaffepathDialog, self).__init__(parent)
        self.setWindowFlags(self.windowFlags() & ~QtCore.Qt.WindowContextHelpButtonHint)
        self.setWindowTitle("Caffepath")
        self.changes = False
        self.quitonclose = quitonclose
        self.startPath = "/home"
        self.remote = remote
        self.host = host
        caffepathttext = reason

        if remote:
            msg = {"key": Protocol.GETPLATFORM}
            reply = sendMsgToHost(self.host.host, self.host.port, msg)
            platform = reply["platform"]
        else:
            platform = sys.platform

        if platform == "win32": self.platform = Platform.WINDOWS
        elif platform == "cygwin": self.platform = Platform.CYGWIN
        elif platform == "darwin": self.platform = Platform.MACOSX
        elif platform == "os2": self.platform = Platform.OS2
        elif platform == "os2emx": self.platform = Platform.OS2EMX
        elif platform == "riscos": self.platform = Platform.RISCOS
        elif platform == "atheos": self.platform = Platform.ATHEOS
        else: self.platform = Platform.LINUX

        if remote==True and self.host==None:
            print("Error: CaffepathDialog needs a host if remote is True")
            exit(-1)

        lay = QtWidgets.QGridLayout(self)
        lay.addWidget(QtWidgets.QLabel(caffepathttext, self),0,0,1,1)

        self.pbSaveStart = QtWidgets.QPushButton(buttontext)
        lay.addWidget(self.pbSaveStart, 1, 0, 1, 2)
        
        self.labelName = QtWidgets.QLabel("Unique name:")
        lay.addWidget(self.labelName, 3, 0, 1, 4)

        self.LineEditName = QtWidgets.QLineEdit()
        lay.addWidget(self.LineEditName, 4, 0, 1, 2)

        self.labelPathtoCaffe = QtWidgets.QLabel("Path to caffe root:")
        lay.addWidget(self.labelPathtoCaffe, 5, 0, 1, 4)

        self.LineEditPathtoCaffe = QtWidgets.QLineEdit()
        lay.addWidget(self.LineEditPathtoCaffe, 6, 0, 1, 2)

        self.labelPathtoPython = QtWidgets.QLabel("Path to python packages of caffe:")
        lay.addWidget(self.labelPathtoPython, 7, 0, 1, 4)

        self.LineEditPathtoPython = QtWidgets.QLineEdit()
        lay.addWidget(self.LineEditPathtoPython, 8, 0, 1, 2)

        if self.platform == Platform.WINDOWS:
            self.labelPathtoBinaries = QtWidgets.QLabel("Caffe executable:")
        else:
            self.labelPathtoBinaries = QtWidgets.QLabel("Caffe binary file:")
        lay.addWidget(self.labelPathtoBinaries, 9, 0, 1, 4)

        self.LineEditPathtoBinaries = QtWidgets.QLineEdit()
        lay.addWidget(self.LineEditPathtoBinaries, 10, 0, 1, 2)

        self.labelPathtoProto = QtWidgets.QLabel("Caffe proto file:")
        lay.addWidget(self.labelPathtoProto, 11, 0, 1, 4)

        self.LineEditPathtoProto = QtWidgets.QLineEdit()
        lay.addWidget(self.LineEditPathtoProto, 12, 0, 1, 2)

        pix = QtWidgets.qApp.style().standardPixmap(QtWidgets.QStyle.SP_DialogOpenButton)
        ico = QIcon(pix)
        self.pbCaffePath = QtWidgets.QPushButton(ico, "")
        lay.addWidget(self.pbCaffePath, 6, 3, 1, 1)

        pix = QtWidgets.qApp.style().standardPixmap(QtWidgets.QStyle.SP_DialogOpenButton)
        ico = QIcon(pix)
        self.pbPythonFile = QtWidgets.QPushButton(ico, "")
        lay.addWidget(self.pbPythonFile, 8, 3, 1, 1)

        pix = QtWidgets.qApp.style().standardPixmap(QtWidgets.QStyle.SP_DialogOpenButton)
        ico = QIcon(pix)
        self.pbBinaryFiles = QtWidgets.QPushButton(ico, "")
        lay.addWidget(self.pbBinaryFiles, 10, 3, 1, 1)

        pix = QtWidgets.qApp.style().standardPixmap(QtWidgets.QStyle.SP_DialogOpenButton)
        ico = QIcon(pix)
        self.pbProtoFile = QtWidgets.QPushButton(ico, "")
        lay.addWidget(self.pbProtoFile, 12, 3, 1, 1)

        self.pbCaffePath.clicked.connect(self._onCaffePath)
        self.pbPythonFile.clicked.connect(self._onPythonFile)
        self.pbBinaryFiles.clicked.connect(self._onBinaryFile)
        self.pbProtoFile.clicked.connect(self._onProtoFile)
        self.pbSaveStart.clicked.connect(self._onSave)
Exemplo n.º 13
0
    def _onSave(self):
        """if path in LineEditPathtoPython is correct caffepath, change caffepath and close window,
        otherwise show warning """
        caffename = str(self.LineEditName.text())
        caffepath = str(self.LineEditPathtoCaffe.text())
        pythonpath = str(self.LineEditPathtoPython.text())
        binarypath = str(self.LineEditPathtoBinaries.text())
        protopath = str(self.LineEditPathtoProto.text())

        versions = []

        if self.remote:
            msg = {"key": Protocol.GETCAFFEVERSIONS}
            reply = sendMsgToHost(self.host.host, self.host.port, msg)
            if reply:
                remoteVersions = reply["versions"]
                for version in remoteVersions:
                    versions.append(caffe_versions.caffeVersion(version, remoteVersions[version]["root"], remoteVersions[version]["binary"], remoteVersions[version]["python"], remoteVersions[version]["proto"]))
        else:
            versions = caffe_versions.getAvailableVersions()

        existing = False
        for version in versions:
            if version.getName() == caffename:
                existing = True

        if existing:
                QtWidgets.QMessageBox.warning(self, "Error", "An version with the given name already exists. Please choose a unique name.")
        else:
            try:
                if len(caffepath) == 0: raise Exception("Please select the caffe root path")

                try:
                    import importlib
                    import sys

                    sys.path.insert(0, pythonpath)
                    caffe = importlib.import_module("caffe")
                    sys.path.pop(0)
                except ImportError as e:
                    raise Exception("Please select the path to the python package of caffe")
                
                if len(binarypath) == 0:
                    if self.platform == Platform.WINDOWS:
                        raise Exception("Plese select the caffe executable")
                    else:
                        raise Exception("Please select the caffe binary file")
                if len(protopath) == 0: raise Exception("Please select the proto file")
                #if os.path.isfile(binarypath)
                version = caffe_versions.caffeVersion(caffename, caffepath, binarypath, pythonpath, protopath)

                if self.remote:
                    msg = {"key": Protocol.ADDCAFFEVERSION, "version": {"name": version.getName(),
                                                                "root": version.getRootpath(),
                                                                "binary": version.getBinarypath(),
                                                                "python": version.getPythonpath(),
                                                                "proto": version.getProtopath()}}
                    sendMsgToHost(self.host.host, self.host.port, msg)
                else:
                    caffe_versions.addVersion(version)

                self.changes = True
                self.close()
            except Exception as e:
                QtWidgets.QMessageBox.warning(self, "Error", self.tr(repr(e)))