def getParamValues(self): if self.mUpdateExistingGroupBox.isChecked(): fieldName = self.mExistingFieldComboBox.currentText() else: fieldName = self.mOutputFieldNameLineEdit.text() layer = self.cmbInputLayer.currentLayer() context = dataobjects.createContext() parameters = {} parameters['INPUT'] = layer parameters['FIELD_NAME'] = fieldName parameters['FIELD_TYPE'] = self.mOutputFieldTypeComboBox.currentIndex() parameters['FIELD_LENGTH'] = self.mOutputFieldWidthSpinBox.value() parameters[ 'FIELD_PRECISION'] = self.mOutputFieldPrecisionSpinBox.value() parameters['NEW_FIELD'] = self.mNewFieldGroupBox.isChecked() parameters['FORMULA'] = self.builder.expressionText() output = QgsProcessingOutputLayerDefinition() if self.leOutputFile.text().strip(): output.sink = QgsProperty.fromValue( self.leOutputFile.text().strip()) else: output.sink = QgsProperty.fromValue('memory:') output.destinationProject = context.project() parameters['OUTPUT'] = output ok, msg = self.alg.checkParameterValues(parameters, context) if not ok: QMessageBox.warning(self, self.tr('Unable to execute algorithm'), msg) return {} return parameters
def getConsoleCommands(self, parameters, context, feedback, executing=True): context = dataobjects.createContext() inLayer = QgsProcessingUtils.mapLayerFromString( self.getParameterValue(self.INPUT), context) inRasterLayer = QgsProcessingUtils.mapLayerFromString( self.getParameterValue(self.INPUT_RASTER), context) ogrLayer = GdalUtils.ogrConnectionString(inLayer, context)[1:-1] ogrRasterLayer = GdalUtils.ogrConnectionString(inRasterLayer, context)[1:-1] arguments = [] arguments.append('-a') arguments.append(str(self.getParameterValue(self.FIELD))) arguments.append('-l') arguments.append(GdalUtils.ogrLayerName(inLayer)) arguments.append(ogrLayer) arguments.append(ogrRasterLayer) return ['gdal_rasterize', GdalUtils.escapeAndJoin(arguments)]
def save(self): toSave = [] context = dataobjects.createContext() for row in range(self.tblParameters.rowCount()): algParams = {} algOutputs = {} col = 0 alg = self.alg for param in alg.parameterDefinitions(): if param.flags() & QgsProcessingParameterDefinition.FlagHidden: continue if param.isDestination(): continue wrapper = self.wrappers[row][col] if not param.checkValueIsAcceptable(wrapper.value(), context): self.parent.messageBar().pushMessage( "", self.tr( 'Wrong or missing parameter value: {0} (row {1})'). format(param.description(), row + 1), level=Qgis.Warning, duration=5) return algParams[param.name()] = param.valueAsPythonString( wrapper.value(), context) col += 1 for out in alg.destinationParameterDefinitions(): if out.flags() & QgsProcessingParameterDefinition.FlagHidden: continue widget = self.tblParameters.cellWidget(row, col) text = widget.getValue() if text.strip() != '': algOutputs[out.name()] = text.strip() col += 1 else: self.parent.messageBar().pushMessage( "", self.tr('Wrong or missing output value: {0} (row {1})' ).format(out.description(), row + 1), level=Qgis.Warning, duration=5) return toSave.append({ self.PARAMETERS: algParams, self.OUTPUTS: algOutputs }) settings = QgsSettings() last_path = settings.value("/Processing/LastBatchPath", QDir.homePath()) filename, __ = QFileDialog.getSaveFileName( self, self.tr('Save Batch'), last_path, self.tr('JSON files (*.json)')) if filename: if not filename.endswith('.json'): filename += '.json' last_path = QFileInfo(filename).path() settings.setValue('/Processing/LastBatchPath', last_path) with open(filename, 'w') as f: json.dump(toSave, f)
def _executeAlgorithm(alg): ok, message = alg.canExecute() if not ok: dlg = MessageDialog() dlg.setTitle(Processing.tr('Missing dependency')) dlg.setMessage( Processing.tr('<h3>Missing dependency. This algorithm cannot ' 'be run :-( </h3>\n{0}').format(message)) dlg.exec_() return if (alg.countVisibleParameters()) > 0: dlg = alg.createCustomParametersWidget(None) if not dlg: dlg = AlgorithmDialog(alg) canvas = iface.mapCanvas() prevMapTool = canvas.mapTool() dlg.show() dlg.exec_() if canvas.mapTool() != prevMapTool: try: canvas.mapTool().reset() except: pass canvas.setMapTool(prevMapTool) else: feedback = MessageBarProgress() context = dataobjects.createContext(feedback) parameters = {} ret, results = execute(alg, parameters, context, feedback) handleAlgorithmResults(alg, context, feedback) feedback.close()
def setDynamicLayer(self, layer): context = createContext() try: if isinstance(layer, QgsProcessingFeatureSourceDefinition): layer, ok = layer.source.valueAsString(context.expressionContext()) if isinstance(layer, str): layer = QgsProcessingUtils.mapLayerFromString(layer, context) self.btnDataDefined.setVectorLayer(layer) except: pass
def testProcessingException(self): """ Test that Python exception is caught when running an alg """ alg = TestAlg() context = createContext() feedback = QgsProcessingFeedback() results, ok = alg.run({}, context, feedback) self.assertFalse(ok)
def setLayer(self, layer): context = dataobjects.createContext() if layer == self._layer: return if isinstance(layer, QgsProcessingFeatureSourceDefinition): layer, ok = layer.source.valueAsString(context.expressionContext()) if isinstance(layer, str): layer = QgsProcessingUtils.mapLayerFromString(layer, context) if not isinstance(layer, QgsVectorLayer): layer = None self._layer = layer self.widget.setLayer(self._layer)
def showExpressionsBuilder(self): context = createExpressionContext() processing_context = createContext() scope = self.modelParametersDialog.model.createExpressionContextScopeForChildAlgorithm(self.modelParametersDialog.childId, processing_context) context.appendScope(scope) highlighted = scope.variableNames() context.setHighlightedVariables(highlighted) dlg = QgsExpressionBuilderDialog(None, str(self.leText.text()), self, 'generic', context) dlg.setWindowTitle(self.tr('Expression Based Input')) if dlg.exec_() == QDialog.Accepted: exp = QgsExpression(dlg.expressionText()) if not exp.hasParserError(): self.setValue(dlg.expressionText())
def executeAlgorithm(self): item = self.algorithmTree.currentItem() if isinstance(item, TreeAlgorithmItem): alg = QgsApplication.processingRegistry().createAlgorithmById( item.alg.id()) if not alg: return ok, message = alg.canExecute() if not ok: dlg = MessageDialog() dlg.setTitle(self.tr('Error executing algorithm')) dlg.setMessage( self.tr('<h3>This algorithm cannot ' 'be run :-( </h3>\n{0}').format(message)) dlg.exec_() return if alg.countVisibleParameters() > 0: dlg = alg.createCustomParametersWidget(self) if not dlg: dlg = AlgorithmDialog(alg) canvas = iface.mapCanvas() prevMapTool = canvas.mapTool() dlg.show() dlg.exec_() if canvas.mapTool() != prevMapTool: try: canvas.mapTool().reset() except: pass canvas.setMapTool(prevMapTool) if dlg.wasExecuted(): showRecent = ProcessingConfig.getSetting( ProcessingConfig.SHOW_RECENT_ALGORITHMS) if showRecent: self.addRecentAlgorithms(True) else: feedback = MessageBarProgress() context = dataobjects.createContext(feedback) parameters = {} ret, results = execute(alg, parameters, context, feedback) handleAlgorithmResults(alg, context, feedback) feedback.close()
def accept(self): context = dataobjects.createContext() try: parameters = self.getParameterValues() self.setOutputValues() ok, msg = self.algorithm().checkParameterValues( parameters, context) if not ok: QMessageBox.warning(self, self.tr('Unable to execute algorithm'), msg) return description = algAsDict(self.algorithm()) description["name"] = self.settingsPanel.txtName.text().strip() description["group"] = self.settingsPanel.txtGroup.text().strip() if not (description["name"] and description["group"]): self.tabWidget().setCurrentIndex(self.tabWidget().count() - 1) return validChars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:' filename = ''.join(c for c in description["name"] if c in validChars).lower() + ".json" filepath = os.path.join(preconfiguredAlgorithmsFolder(), filename) with open(filepath, "w") as f: json.dump(description, f) QgsApplication.processingRegistry().providerById( 'preconfigured').refreshAlgorithms() except AlgorithmDialogBase.InvalidParameterValue as e: try: self.buttonBox().accepted.connect( lambda: e.widget.setPalette(QPalette())) palette = e.widget.palette() palette.setColor(QPalette.Base, QColor(255, 255, 0)) e.widget.setPalette(palette) self.messageBar().pushMessage( "", self.tr('Missing parameter value: {0}').format( e.parameter.description()), level=Qgis.Warning, duration=5) return except: QMessageBox.critical( self, self.tr('Unable to execute algorithm'), self.tr('Wrong or missing parameter values')) self.close()
def parametersHaveChanged(self): context = createContext() feedback = QgsProcessingFeedback() try: parameters = self.parent.getParameterValues() for output in self.alg.destinationParameterDefinitions(): if not output.name() in parameters or parameters[output.name()] is None: parameters[output.name()] = self.tr("[temporary file]") for p in self.alg.parameterDefinitions(): if (not p.name() in parameters and not p.flags() & QgsProcessingParameterDefinition.FlagOptional) \ or (not p.checkValueIsAcceptable(parameters[p.name()])): # not ready yet self.text.setPlainText('') return commands = self.alg.getConsoleCommands(parameters, context, feedback, executing=False) commands = [c for c in commands if c not in ['cmd.exe', '/C ']] self.text.setPlainText(" ".join(commands)) except AlgorithmDialogBase.InvalidParameterValue as e: self.text.setPlainText(self.tr("Invalid value for parameter '{0}'").format(e.parameter.description()))
def execute(alg, parameters, context=None, feedback=None): """Executes a given algorithm, showing its progress in the progress object passed along. Return true if everything went OK, false if the algorithm could not be completed. """ if feedback is None: feedback = QgsProcessingFeedback() if context is None: context = dataobjects.createContext(feedback) try: results, ok = alg.run(parameters, context, feedback) return ok, results except QgsProcessingException as e: QgsMessageLog.logMessage(str(sys.exc_info()[0]), 'Processing', Qgis.Critical) if feedback is not None: feedback.reportError(e.msg) return False, {}
def __init__(self, dialog, param): super(ExtentSelectionPanel, self).__init__(None) self.setupUi(self) self.dialog = dialog self.param = param self.crs = QgsProject.instance().crs() if self.param.flags() & QgsProcessingParameterDefinition.FlagOptional: if hasattr(self.leText, 'setPlaceholderText'): self.leText.setPlaceholderText( self.tr('[Leave blank to use min covering extent]')) self.btnSelect.clicked.connect(self.selectExtent) if iface is not None: canvas = iface.mapCanvas() self.prevMapTool = canvas.mapTool() self.tool = RectangleMapTool(canvas) self.tool.rectangleCreated.connect(self.updateExtent) else: self.prevMapTool = None self.tool = None if param.defaultValue() is not None: context = createContext() rect = QgsProcessingParameters.parameterAsExtent(param, {param.name(): param.defaultValue()}, context) crs = QgsProcessingParameters.parameterAsExtentCrs(param, {param.name(): param.defaultValue()}, context) if not rect.isNull(): try: s = '{},{},{},{}'.format( rect.xMinimum(), rect.xMaximum(), rect.yMinimum(), rect.yMaximum()) if crs.isValid(): s += ' [' + crs.authid() + ']' self.crs = crs self.leText.setText(s) except: pass
def accept(self): keepOpen = ProcessingConfig.getSetting( ProcessingConfig.KEEP_DIALOG_OPEN) parameters = self.getParamValues() if parameters: with OverrideCursor(Qt.WaitCursor): self.feedback = FieldCalculatorFeedback(self) self.feedback.progressChanged.connect(self.setPercentage) context = dataobjects.createContext() ProcessingLog.addToLog( self.alg.asPythonCommand(parameters, context)) self.executed, results = execute(self.alg, parameters, context, self.feedback) self.setPercentage(0) if self.executed: handleAlgorithmResults(self.alg, context, self.feedback, not keepOpen) self._wasExecuted = self.executed or self._wasExecuted if not keepOpen: QDialog.reject(self)
def value(self): layers = '' context = dataobjects.createContext() for i in range(self.layersTree.topLevelItemCount()): item = self.layersTree.topLevelItem(i) if item: layerName = item.text(0) layer = QgsProcessingUtils.mapLayerFromString(layerName, context) if not layer: continue provider = layer.dataProvider() if not provider: continue interpolationAttribute = item.text(1) interpolationSource = QgsInterpolator.ValueAttribute if interpolationAttribute == 'Z_COORD': interpolationSource = QgsInterpolator.ValueZ fieldIndex = -1 else: fieldIndex = layer.fields().indexFromName(interpolationAttribute) comboBox = self.layersTree.itemWidget(self.layersTree.topLevelItem(i), 2) inputTypeName = comboBox.currentText() if inputTypeName == self.tr('Points'): inputType = QgsInterpolator.SourcePoints elif inputTypeName == self.tr('Structure lines'): inputType = QgsInterpolator.SourceStructureLines else: inputType = QgsInterpolator.SourceBreakLines layers += '{}::~::{:d}::~::{:d}::~::{:d};'.format(layer.source(), interpolationSource, fieldIndex, inputType) return layers[:-1]
def accept(self): feedback = self.createFeedback() context = dataobjects.createContext(feedback) checkCRS = ProcessingConfig.getSetting( ProcessingConfig.WARN_UNMATCHING_CRS) try: parameters = self.getParameterValues() if checkCRS and not self.algorithm().validateInputCrs( parameters, context): reply = QMessageBox.question( self, self.tr("Unmatching CRS's"), self.tr('Parameters do not all use the same CRS. This can ' 'cause unexpected results.\nDo you want to ' 'continue?'), QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if reply == QMessageBox.No: return ok, msg = self.algorithm().checkParameterValues( parameters, context) if msg: QMessageBox.warning(self, self.tr('Unable to execute algorithm'), msg) return self.runButton().setEnabled(False) self.cancelButton().setEnabled(False) buttons = self.mainWidget().iterateButtons self.iterateParam = None for i in range(len(list(buttons.values()))): button = list(buttons.values())[i] if button.isChecked(): self.iterateParam = list(buttons.keys())[i] break self.clearProgress() self.setProgressText( QCoreApplication.translate('AlgorithmDialog', 'Processing algorithm…')) self.setInfo( self.tr('AlgorithmDialog', '<b>Algorithm \'{0}\' starting…</b>').format( self.algorithm().displayName()), escapeHtml=False) feedback.pushInfo(self.tr('Input parameters:')) display_params = [] for k, v in parameters.items(): display_params.append("'" + k + "' : " + self.algorithm().parameterDefinition( k).valueAsPythonString(v, context)) feedback.pushCommandInfo('{ ' + ', '.join(display_params) + ' }') feedback.pushInfo('') start_time = time.time() if self.iterateParam: # Make sure the Log tab is visible before executing the algorithm try: self.showLog() self.repaint() except: pass self.cancelButton().setEnabled( self.algorithm().flags() & QgsProcessingAlgorithm.FlagCanCancel) if executeIterating(self.algorithm(), parameters, self.iterateParam, context, feedback): feedback.pushInfo( self.tr( 'Execution completed in {0:0.2f} seconds'.format( time.time() - start_time))) self.cancelButton().setEnabled(False) self.finish(True, parameters, context, feedback) else: self.cancelButton().setEnabled(False) self.resetGui() else: command = self.algorithm().asPythonCommand(parameters, context) if command: ProcessingLog.addToLog(command) self.cancelButton().setEnabled( self.algorithm().flags() & QgsProcessingAlgorithm.FlagCanCancel) def on_complete(ok, results): if ok: feedback.pushInfo( self.tr('Execution completed in {0:0.2f} seconds'. format(time.time() - start_time))) feedback.pushInfo(self.tr('Results:')) feedback.pushCommandInfo(pformat(results)) else: feedback.reportError( self.tr('Execution failed after {0:0.2f} seconds'. format(time.time() - start_time))) feedback.pushInfo('') if self.feedback_dialog is not None: self.feedback_dialog.close() self.feedback_dialog.deleteLater() self.feedback_dialog = None self.cancelButton().setEnabled(False) self.finish(ok, results, context, feedback) if not (self.algorithm().flags() & QgsProcessingAlgorithm.FlagNoThreading): # Make sure the Log tab is visible before executing the algorithm self.showLog() task = QgsProcessingAlgRunnerTask(self.algorithm(), parameters, context, feedback) task.executed.connect(on_complete) self.setCurrentTask(task) else: self.feedback_dialog = self.createProgressDialog() self.feedback_dialog.show() ok, results = execute(self.algorithm(), parameters, context, feedback) on_complete(ok, results) except AlgorithmDialogBase.InvalidParameterValue as e: try: self.buttonBox().accepted.connect( lambda e=e: e.widget.setPalette(QPalette())) palette = e.widget.palette() palette.setColor(QPalette.Base, QColor(255, 255, 0)) e.widget.setPalette(palette) except: pass self.messageBar().clearWidgets() self.messageBar().pushMessage( "", self.tr("Wrong or missing parameter value: {0}").format( e.parameter.description()), level=Qgis.Warning, duration=5)
def runAlgorithm(algOrName, parameters, onFinish=None, feedback=None, context=None): if isinstance(algOrName, QgsProcessingAlgorithm): alg = algOrName else: alg = QgsApplication.processingRegistry().createAlgorithmById( algOrName) if feedback is None: feedback = QgsProcessingFeedback() if alg is None: # fix_print_with_import print('Error: Algorithm not found\n') msg = Processing.tr('Error: Algorithm {0} not found\n').format( algOrName) feedback.reportError(msg) raise QgsProcessingException(msg) # check for any mandatory parameters which were not specified for param in alg.parameterDefinitions(): if param.name() not in parameters: if not param.flags( ) & QgsProcessingParameterDefinition.FlagOptional: # fix_print_with_import msg = Processing.tr( 'Error: Missing parameter value for parameter {0}.' ).format(param.name()) print('Error: Missing parameter value for parameter %s.' % param.name()) feedback.reportError(msg) raise QgsProcessingException(msg) if context is None: context = dataobjects.createContext(feedback) ok, msg = alg.checkParameterValues(parameters, context) if not ok: # fix_print_with_import print('Unable to execute algorithm\n' + str(msg)) msg = Processing.tr('Unable to execute algorithm\n{0}').format(msg) feedback.reportError(msg) raise QgsProcessingException(msg) if not alg.validateInputCrs(parameters, context): print('Warning: Not all input layers use the same CRS.\n' + 'This can cause unexpected results.') feedback.pushInfo( Processing. tr('Warning: Not all input layers use the same CRS.\nThis can cause unexpected results.' )) ret, results = execute(alg, parameters, context, feedback) if ret: feedback.pushInfo(Processing.tr('Results: {}').format(results)) if onFinish is not None: onFinish(alg, context, feedback) else: # auto convert layer references in results to map layers for out in alg.outputDefinitions(): if out.name() not in results: continue if isinstance(out, (QgsProcessingOutputVectorLayer, QgsProcessingOutputRasterLayer, QgsProcessingOutputMapLayer)): result = results[out.name()] if not isinstance(result, QgsMapLayer): layer = context.takeResultLayer( result ) # transfer layer ownership out of context if layer: results[out.name( )] = layer # replace layer string ref with actual layer (+ownership) elif isinstance(out, QgsProcessingOutputMultipleLayers): result = results[out.name()] if result: layers_result = [] for l in result: if not isinstance(result, QgsMapLayer): layer = context.takeResultLayer( l ) # transfer layer ownership out of context if layer: layers_result.append(layer) else: layers_result.append(l) else: layers_result.append(l) results[out.name( )] = layers_result # replace layers strings ref with actual layers (+ownership) else: msg = Processing.tr("There were errors executing the algorithm.") feedback.reportError(msg) raise QgsProcessingException(msg) if isinstance(feedback, MessageBarProgress): feedback.close() return results
def paintModel(self, model, controls=True): self.model = model context = createContext() # Inputs for inp in list(model.parameterComponents().values()): item = ModelerGraphicItem(inp, model, controls, scene=self) item.setFlag(QGraphicsItem.ItemIsMovable, True) item.setFlag(QGraphicsItem.ItemIsSelectable, True) self.addItem(item) item.setPos(inp.position().x(), inp.position().y()) self.paramItems[inp.parameterName()] = item # Input dependency arrows for input_name in list(model.parameterComponents().keys()): idx = 0 parameter_def = model.parameterDefinition(input_name) if hasattr(parameter_def, 'parentLayerParameterName') and parameter_def.parentLayerParameterName(): parent_name = parameter_def.parentLayerParameterName() if input_name in self.paramItems and parent_name in self.paramItems: input_item = self.paramItems[input_name] parent_item = self.paramItems[parent_name] arrow = ModelerArrowItem(parent_item, -1, input_item, -1) input_item.addArrow(arrow) parent_item.addArrow(arrow) arrow.setPenStyle(Qt.DotLine) arrow.updatePath() self.addItem(arrow) # We add the algs for alg in list(model.childAlgorithms().values()): item = ModelerGraphicItem(alg, model, controls, scene=self) item.setFlag(QGraphicsItem.ItemIsMovable, True) item.setFlag(QGraphicsItem.ItemIsSelectable, True) self.addItem(item) item.setPos(alg.position().x(), alg.position().y()) self.algItems[alg.childId()] = item # And then the arrows for alg in list(model.childAlgorithms().values()): idx = 0 for parameter in alg.algorithm().parameterDefinitions(): if not parameter.isDestination() and not parameter.flags() & QgsProcessingParameterDefinition.FlagHidden: if parameter.name() in alg.parameterSources(): sources = alg.parameterSources()[parameter.name()] else: sources = [] for source in sources: sourceItems = self.getItemsFromParamValue(source, alg.childId(), context) for sourceItem, sourceIdx in sourceItems: arrow = ModelerArrowItem(sourceItem, sourceIdx, self.algItems[alg.childId()], idx) sourceItem.addArrow(arrow) self.algItems[alg.childId()].addArrow(arrow) arrow.updatePath() self.addItem(arrow) idx += 1 for depend in alg.dependencies(): arrow = ModelerArrowItem(self.algItems[depend], -1, self.algItems[alg.childId()], -1) self.algItems[depend].addArrow(arrow) self.algItems[alg.childId()].addArrow(arrow) arrow.updatePath() self.addItem(arrow) # And finally the outputs for alg in list(model.childAlgorithms().values()): outputs = alg.modelOutputs() outputItems = {} idx = 0 for key, out in outputs.items(): if out is not None: item = ModelerGraphicItem(out, model, controls, scene=self) item.setFlag(QGraphicsItem.ItemIsMovable, True) item.setFlag(QGraphicsItem.ItemIsSelectable, True) self.addItem(item) pos = out.position() if pos is None: pos = (alg.position() + QPointF(ModelerGraphicItem.BOX_WIDTH, 0) + self.algItems[alg.childId()].getLinkPointForOutput(idx)) item.setPos(pos) outputItems[key] = item arrow = ModelerArrowItem(self.algItems[alg.childId()], idx, item, -1) self.algItems[alg.childId()].addArrow(arrow) item.addArrow(arrow) arrow.updatePath() self.addItem(arrow) idx += 1 else: outputItems[key] = None self.outputItems[alg.childId()] = outputItems
def __init__(self, param, dialog, row=0, col=0, **kwargs): super().__init__(param, dialog, row, col, **kwargs) self.context = dataobjects.createContext()