Exemple #1
0
 def execute(self):
     filename = QtGui.QFileDialog.getOpenFileName(
         self.toolbox, self.tr('Open model', 'AddModelFromFileAction'),
         None,
         self.tr('Processing model files (*.model *.MODEL)',
                 'AddModelFromFileAction'))
     if filename:
         try:
             ModelerAlgorithm.fromFile(filename)
         except WrongModelException:
             QtGui.QMessageBox.warning(
                 self.toolbox,
                 self.tr('Error reading model', 'AddModelFromFileAction'),
                 self.tr('The selected file does not contain a valid model',
                         'AddModelFromFileAction'))
             return
         except:
             QtGui.QMessageBox.warning(
                 self.toolbox,
                 self.tr('Error reading model', 'AddModelFromFileAction'),
                 self.tr('Cannot read file', 'AddModelFromFileAction'))
         destFilename = os.path.join(ModelerUtils.modelsFolder(),
                                     os.path.basename(filename))
         shutil.copyfile(filename, destFilename)
         self.toolbox.updateProvider('model')
 def execute(self):
     filename = QFileDialog.getOpenFileName(
         self.toolbox,
         self.tr("Open model", "AddModelFromFileAction"),
         None,
         self.tr("Processing model files (*.model *.MODEL)", "AddModelFromFileAction"),
     )
     if filename:
         try:
             ModelerAlgorithm.fromFile(filename)
         except WrongModelException:
             QMessageBox.warning(
                 self.toolbox,
                 self.tr("Error reading model", "AddModelFromFileAction"),
                 self.tr("The selected file does not contain a valid model", "AddModelFromFileAction"),
             )
             return
         except:
             QMessageBox.warning(
                 self.toolbox,
                 self.tr("Error reading model", "AddModelFromFileAction"),
                 self.tr("Cannot read file", "AddModelFromFileAction"),
             )
         destFilename = os.path.join(ModelerUtils.modelsFolder(), os.path.basename(filename))
         shutil.copyfile(filename, destFilename)
         self.toolbox.updateProvider("model")
Exemple #3
0
    def execute(self):
        settings = QgsSettings()
        lastDir = settings.value('Processing/lastModelsDir', '')
        filename, selected_filter = QFileDialog.getOpenFileName(self.toolbox,
                                                                self.tr('Open model', 'AddModelFromFileAction'), lastDir,
                                                                self.tr('Processing model files (*.model *.MODEL)', 'AddModelFromFileAction'))
        if filename:
            try:
                settings.setValue('Processing/lastModelsDir',
                                  QFileInfo(filename).absoluteDir().absolutePath())

                ModelerAlgorithm.fromFile(filename)
            except WrongModelException:
                QMessageBox.warning(
                    self.toolbox,
                    self.tr('Error reading model', 'AddModelFromFileAction'),
                    self.tr('The selected file does not contain a valid model', 'AddModelFromFileAction'))
                return
            except:
                QMessageBox.warning(self.toolbox,
                                    self.tr('Error reading model', 'AddModelFromFileAction'),
                                    self.tr('Cannot read file', 'AddModelFromFileAction'))
                return
            destFilename = os.path.join(ModelerUtils.modelsFolders()[0], os.path.basename(filename))
            shutil.copyfile(filename, destFilename)
            algList.reloadProvider('model')
    def execute(self):
        settings = QSettings()
        lastDir = settings.value('Processing/lastModelsDir', '')
        filename = QFileDialog.getOpenFileName(self.toolbox,
                                               self.tr('Open model', 'AddModelFromFileAction'), lastDir,
                                               self.tr('Processing model files (*.model *.MODEL)', 'AddModelFromFileAction'))
        if filename:
            try:
                settings.setValue('Processing/lastModelsDir',
                                  QFileInfo(filename).absoluteDir().absolutePath())

                ModelerAlgorithm.fromFile(filename)
            except WrongModelException:
                QMessageBox.warning(
                    self.toolbox,
                    self.tr('Error reading model', 'AddModelFromFileAction'),
                    self.tr('The selected file does not contain a valid model', 'AddModelFromFileAction'))
                return
            except:
                QMessageBox.warning(self.toolbox,
                                    self.tr('Error reading model', 'AddModelFromFileAction'),
                                    self.tr('Cannot read file', 'AddModelFromFileAction'))
                return
            destFilename = os.path.join(ModelerUtils.modelsFolder(), os.path.basename(filename))
            shutil.copyfile(filename, destFilename)
            self.toolbox.updateProvider('model')
 def execute(self):
     filename = QtGui.QFileDialog.getOpenFileName(self.toolbox, 'model files', None,
             '*.model')
     if filename:
         try:
             ModelerAlgorithm.fromFile(filename)
         except WrongModelException:
             QtGui.QMessageBox.warning(self.toolbox, "Error reading model", "The selected file does not contain a valid model")
             return
         except:
             QtGui.QMessageBox.warning(self.toolbox, "Error reading model", "Cannot read file")
         destFilename = os.path.join(ModelerUtils.modelsFolder(), os.path.basename(filename))
         shutil.copyfile(filename,destFilename)
         self.toolbox.updateProvider('script')
Exemple #6
0
    def openModel(self):
        filename, selected_filter = QFileDialog.getOpenFileName(self,
                                                                self.tr('Open Model'),
                                                                ModelerUtils.modelsFolders()[0],
                                                                self.tr('Processing models (*.model *.MODEL)'))
        if filename:
            try:
                alg = ModelerAlgorithm.fromFile(filename)
                self.alg = alg
                self.alg.setModelerView(self)
                self.textGroup.setText(alg._group)
                self.textName.setText(alg._name)
                self.repaintModel()

                self.view.centerOn(0, 0)
                self.hasChanged = False
            except WrongModelException as e:
                QgsMessageLog.logMessage(self.tr('Could not load model {0}\n{1}').format(filename, e.msg),
                                         self.tr('Processing'),
                                         QgsMessageLog.CRITICAL)
                QMessageBox.critical(self, self.tr('Could not open model'),
                                     self.tr('The selected model could not be loaded.\n'
                                             'See the log for more information.'))
            except Exception as e:
                QgsMessageLog.logMessage(self.tr('Could not load model {0}\n{1}').format(filename, e.args[0]),
                                         self.tr('Processing'), QgsMessageLog.CRITICAL)
                QMessageBox.critical(self, self.tr('Could not open model'),
                                     self.tr('The selected model could not be loaded.\n'
                                             'See the log for more information.'))
 def loadFromFolder(self, folder):
     if not os.path.exists(folder):
         return
     for path, subdirs, files in os.walk(folder):
         for descriptionFile in files:
             if descriptionFile.endswith('model'):
                 try:
                     fullpath = os.path.join(path, descriptionFile)
                     alg = ModelerAlgorithm.fromFile(fullpath)
                     if alg.name:
                         alg.provider = self
                         alg.descriptionFile = fullpath
                         self.algs.append(alg)
                     else:
                         ProcessingLog.addToLog(
                             ProcessingLog.LOG_ERROR,
                             self.tr('Could not load model %s',
                                     'ModelerAlgorithmProvider') %
                             descriptionFile)
                 except WrongModelException as e:
                     ProcessingLog.addToLog(
                         ProcessingLog.LOG_ERROR,
                         self.tr('Could not load model %s\n%s',
                                 'ModelerAlgorithmProvider') %
                         (descriptionFile, e.msg))
    def loadFromFolder(self, folder):
        if not os.path.exists(folder):
            return
        for path, subdirs, files in os.walk(folder):
            for descriptionFile in files:
                if descriptionFile.endswith('model3'):
                    try:
                        fullpath = os.path.join(path, descriptionFile)

                        alg = ModelerAlgorithm()
                        if alg.fromFile(fullpath):
                            if alg.name():
                                alg.setSourceFilePath(fullpath)
                                self.algs.append(alg)
                        else:
                            QgsMessageLog.logMessage(
                                self.tr('Could not load model {0}',
                                        'ModelerAlgorithmProvider').format(
                                            descriptionFile),
                                self.tr('Processing'), QgsMessageLog.CRITICAL)
                    except WrongModelException as e:
                        QgsMessageLog.logMessage(
                            self.tr('Could not load model {0}\n{1}',
                                    'ModelerAlgorithmProvider').format(
                                        descriptionFile, e.msg),
                            self.tr('Processing'), QgsMessageLog.CRITICAL)
    def openModel(self):
        filename = unicode(
            QFileDialog.getOpenFileName(
                self, self.tr('Open Model'),
                ModelerUtils.modelsFolders()[0],
                self.tr('Processing models (*.model *.MODEL)')))
        if filename:
            try:
                alg = ModelerAlgorithm.fromFile(filename)
                self.alg = alg
                self.alg.setModelerView(self)
                self.textGroup.setText(alg.group)
                self.textName.setText(alg.name)
                self.repaintModel()

                self.view.centerOn(0, 0)
                self.hasChanged = False
            except WrongModelException as e:
                ProcessingLog.addToLog(
                    ProcessingLog.LOG_ERROR,
                    self.tr('Could not load model %s\n%s') % (filename, e.msg))
                QMessageBox.critical(
                    self, self.tr('Could not open model'),
                    self.tr('The selected model could not be loaded.\n'
                            'See the log for more information.'))
            except Exception as e:
                ProcessingLog.addToLog(
                    ProcessingLog.LOG_ERROR,
                    self.tr('Could not load model %s\n%s') %
                    (filename, e.args[0]))
                QMessageBox.critical(
                    self, self.tr('Could not open model'),
                    self.tr('The selected model could not be loaded.\n'
                            'See the log for more information.'))
Exemple #10
0
    def openModel(self):
        filename = unicode(QFileDialog.getOpenFileName(self,
                                                       self.tr('Open Model'), ModelerUtils.modelsFolder(),
                                                       self.tr('Processing models (*.model *.MODEL)')))
        if filename:
            try:
                alg = ModelerAlgorithm.fromFile(filename)
                self.alg = alg
                self.alg.setModelerView(self)
                self.textGroup.setText(alg.group)
                self.textName.setText(alg.name)
                self.repaintModel()

                self.view.centerOn(0, 0)
                self.hasChanged = False
            except WrongModelException as e:
                ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
                                       self.tr('Could not load model %s\n%s') % (filename, e.msg))
                QMessageBox.critical(self, self.tr('Could not open model'),
                                     self.tr('The selected model could not be loaded.\n'
                                             'See the log for more information.'))
            except Exception as e:
                ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
                                       self.tr('Could not load model %s\n%s') % (filename, e.args[0]))
                QMessageBox.critical(self, self.tr('Could not open model'),
                                     self.tr('The selected model could not be loaded.\n'
                                             'See the log for more information.'))
Exemple #11
0
    def openModel(self):
        filename, selected_filter = QFileDialog.getOpenFileName(self,
                                                                self.tr('Open Model'),
                                                                ModelerUtils.modelsFolders()[0],
                                                                self.tr('Processing models (*.model *.MODEL)'))
        if filename:
            try:
                alg = ModelerAlgorithm.fromFile(filename)
                self.alg = alg
                self.alg.setModelerView(self)
                self.textGroup.setText(alg._group)
                self.textName.setText(alg._name)
                self.repaintModel()

                self.view.centerOn(0, 0)
                self.hasChanged = False
            except WrongModelException as e:
                QgsMessageLog.logMessage(self.tr('Could not load model {0}\n{1}').format(filename, e.msg),
                                         self.tr('Processing'),
                                         QgsMessageLog.CRITICAL)
                QMessageBox.critical(self, self.tr('Could not open model'),
                                     self.tr('The selected model could not be loaded.\n'
                                             'See the log for more information.'))
            except Exception as e:
                QgsMessageLog.logMessage(self.tr('Could not load model {0}\n{1}').format(filename, e.args[0]),
                                         self.tr('Processing'), QgsMessageLog.CRITICAL)
                QMessageBox.critical(self, self.tr('Could not open model'),
                                     self.tr('The selected model could not be loaded.\n'
                                             'See the log for more information.'))
Exemple #12
0
    def openModel(self):
        filename, selected_filter = QFileDialog.getOpenFileName(
            self, self.tr('Open Model'),
            ModelerUtils.modelsFolders()[0],
            self.tr('Processing models (*.model3 *.MODEL3)'))
        if filename:
            alg = ModelerAlgorithm()
            if alg.fromFile(filename):
                self.model = alg
                self.model.setProvider(
                    QgsApplication.processingRegistry().providerById('model'))
                self.textGroup.setText(alg.group())
                self.textName.setText(alg.name())
                self.repaintModel()

                self.view.centerOn(0, 0)
                self.hasChanged = False
            else:
                QgsMessageLog.logMessage(
                    self.tr('Could not load model {0}').format(filename),
                    self.tr('Processing'), QgsMessageLog.CRITICAL)
                QMessageBox.critical(
                    self, self.tr('Could not open model'),
                    self.tr('The selected model could not be loaded.\n'
                            'See the log for more information.'))
    def execute(self):
        settings = QgsSettings()
        lastDir = settings.value('Processing/lastModelsDir', '')
        filename, selected_filter = QFileDialog.getOpenFileName(
            self.toolbox, self.tr('Open model', 'AddModelFromFileAction'),
            lastDir,
            self.tr('Processing model files (*.model3 *.MODEL3)',
                    'AddModelFromFileAction'))
        if filename:
            settings.setValue('Processing/lastModelsDir',
                              QFileInfo(filename).absoluteDir().absolutePath())

            alg = ModelerAlgorithm()
            if not alg.fromFile(filename):
                QMessageBox.warning(
                    self.toolbox,
                    self.tr('Error reading model', 'AddModelFromFileAction'),
                    self.tr('The selected file does not contain a valid model',
                            'AddModelFromFileAction'))
                return
            destFilename = os.path.join(ModelerUtils.modelsFolders()[0],
                                        os.path.basename(filename))
            shutil.copyfile(filename, destFilename)
            QgsApplication.processingRegistry().providerById(
                'model').refreshAlgorithms()
 def execute(self):
     filename = QtGui.QFileDialog.getOpenFileName(self.toolbox,
                                                  'model files', None,
                                                  '*.model')
     if filename:
         try:
             ModelerAlgorithm.fromFile(filename)
         except WrongModelException:
             QtGui.QMessageBox.warning(
                 self.toolbox, "Error reading model",
                 "The selected file does not contain a valid model")
             return
         except:
             QtGui.QMessageBox.warning(self.toolbox, "Error reading model",
                                       "Cannot read file")
         destFilename = os.path.join(ModelerUtils.modelsFolder(),
                                     os.path.basename(filename))
         shutil.copyfile(filename, destFilename)
         self.toolbox.updateProvider('script')
    def _loadModels(self):
        """Load models from the 'models' sub directory

        :return: List of ModelerAlgorithm
        """

        self.models = []

        for f in glob.glob(os.path.join(self.modeldir, '*.model')):
            m = ModelerAlgorithm.fromFile(f)
            m.provider = self
            self.models.append(m)
 def loadFromFolder(self, folder):
     if not os.path.exists(folder):
         return
     for path, subdirs, files in os.walk(folder):
         for descriptionFile in files:
             if descriptionFile.endswith('model'):
                 try:
                     fullpath = os.path.join(path, descriptionFile)
                     alg = ModelerAlgorithm.fromFile(fullpath)
                     alg.provider = self
                     self.algs.append(alg)
                 except WrongModelException, e:
                     ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
                         self.tr('Could not load model %s\n%s', 'ModelerAlgorithmProvider') % (descriptionFile, e.msg))
 def loadFromFolder(self, folder):
     if not os.path.exists(folder):
         return
     for path, subdirs, files in os.walk(folder):
         for descriptionFile in files:
             if descriptionFile.endswith('model'):
                 try:
                     fullpath = os.path.join(path, descriptionFile)
                     alg = ModelerAlgorithm.fromFile(fullpath)
                     alg.provider = self
                     self.algs.append(alg)
                 except WrongModelException, e:
                     ProcessingLog.addToLog(
                         ProcessingLog.LOG_ERROR, 'Could not load model ' +
                         descriptionFile + '\n' + e.msg)
 def loadFromFolder(self, folder):
     if not os.path.exists(folder):
         return
     for path, subdirs, files in os.walk(folder):
         for descriptionFile in files:
             if descriptionFile.endswith('model'):
                 try:
                     fullpath = os.path.join(path, descriptionFile)
                     alg = ModelerAlgorithm.fromFile(fullpath)
                     if alg.name():
                         alg.descriptionFile = fullpath
                         self.algs.append(alg)
                     else:
                         QgsMessageLog.logMessage(self.tr('Could not load model {0}', 'ModelerAlgorithmProvider').format(descriptionFile),
                                                  self.tr('Processing'), QgsMessageLog.CRITICAL)
                 except WrongModelException as e:
                     QgsMessageLog.logMessage(self.tr('Could not load model {0}\n{1}', 'ModelerAlgorithmProvider').format(descriptionFile, e.msg),
                                              self.tr('Processing'), QgsMessageLog.CRITICAL)
Exemple #19
0
    def execute(self):
        settings = QgsSettings()
        lastDir = settings.value('Processing/lastModelsDir', '')
        filename, selected_filter = QFileDialog.getOpenFileName(self.toolbox,
                                                                self.tr('Open model', 'AddModelFromFileAction'), lastDir,
                                                                self.tr('Processing model files (*.model3 *.MODEL3)', 'AddModelFromFileAction'))
        if filename:
            settings.setValue('Processing/lastModelsDir',
                              QFileInfo(filename).absoluteDir().absolutePath())

            alg = ModelerAlgorithm()
            if not alg.fromFile(filename):
                QMessageBox.warning(
                    self.toolbox,
                    self.tr('Error reading model', 'AddModelFromFileAction'),
                    self.tr('The selected file does not contain a valid model', 'AddModelFromFileAction'))
                return
            destFilename = os.path.join(ModelerUtils.modelsFolders()[0], os.path.basename(filename))
            shutil.copyfile(filename, destFilename)
            QgsApplication.processingRegistry().providerById('model').refreshAlgorithms()
Exemple #20
0
    def openModel(self):
        filename, selected_filter = QFileDialog.getOpenFileName(self,
                                                                self.tr('Open Model'),
                                                                ModelerUtils.modelsFolders()[0],
                                                                self.tr('Processing models (*.model3 *.MODEL3)'))
        if filename:
            alg = ModelerAlgorithm()
            if alg.fromFile(filename):
                self.model = alg
                self.model.setProvider(QgsApplication.processingRegistry().providerById('model'))
                self.textGroup.setText(alg.group())
                self.textName.setText(alg.name())
                self.repaintModel()

                self.view.centerOn(0, 0)
                self.hasChanged = False
            else:
                QgsMessageLog.logMessage(self.tr('Could not load model {0}').format(filename),
                                         self.tr('Processing'),
                                         QgsMessageLog.CRITICAL)
                QMessageBox.critical(self, self.tr('Could not open model'),
                                     self.tr('The selected model could not be loaded.\n'
                                             'See the log for more information.'))
 def loadFromFolder(self, folder):
     if not os.path.exists(folder):
         return
     for path, subdirs, files in os.walk(folder):
         for descriptionFile in files:
             if descriptionFile.endswith("model"):
                 try:
                     fullpath = os.path.join(path, descriptionFile)
                     alg = ModelerAlgorithm.fromFile(fullpath)
                     if alg.name:
                         alg.provider = self
                         alg.descriptionFile = fullpath
                         self.algs.append(alg)
                     else:
                         ProcessingLog.addToLog(
                             ProcessingLog.LOG_ERROR,
                             self.tr("Could not load model %s", "ModelerAlgorithmProvider") % descriptionFile,
                         )
                 except WrongModelException as e:
                     ProcessingLog.addToLog(
                         ProcessingLog.LOG_ERROR,
                         self.tr("Could not load model %s\n%s", "ModelerAlgorithmProvider")
                         % (descriptionFile, e.msg),
                     )