def __init__(self, alg, toolbox):
AlgorithmDialog.__init__(self, alg)
self.toolbox = toolbox
self.runButton().setText(self.tr("OK"))
self.tabWidget().removeTab(1)
self.settingsPanel = SettingsPanel()
self.tabWidget().addTab(self.settingsPanel, "Description")
def runModel(self):
if len(self.model.childAlgorithms()) == 0:
self.bar.pushMessage("", self.tr("Model doesn't contain any algorithm and/or parameter and can't be executed"), level=Qgis.Warning, duration=5)
return
dlg = AlgorithmDialog(self.model.create(), parent=iface.mainWindow())
dlg.exec_()
def run_script_from_file(filepath):
"""
Runs a Python script from a given file. Supports loading processing scripts.
:param filepath: The .py file to load.
"""
import sys
import inspect
from qgis.processing import alg
try:
from qgis.core import QgsApplication, QgsProcessingAlgorithm, QgsProcessingFeatureBasedAlgorithm
from processing.gui.AlgorithmDialog import AlgorithmDialog
_locals = {}
exec(open(filepath.replace("\\\\", "/").encode(sys.getfilesystemencoding())).read(), _locals)
alginstance = None
try:
alginstance = alg.instances.pop().createInstance()
except IndexError:
for name, attr in _locals.items():
if inspect.isclass(attr) and issubclass(attr, (QgsProcessingAlgorithm, QgsProcessingFeatureBasedAlgorithm)) and attr.__name__ not in ("QgsProcessingAlgorithm", "QgsProcessingFeatureBasedAlgorithm"):
alginstance = attr()
break
if alginstance:
alginstance.setProvider(QgsApplication.processingRegistry().providerById("script"))
alginstance.initAlgorithm()
dlg = AlgorithmDialog(alginstance)
dlg.show()
except ImportError:
pass
def runModel(self):
if len(self.model.childAlgorithms()) == 0:
self.bar.pushMessage("", "Model doesn't contain any algorithm and/or parameter and can't be executed", level=Qgis.Warning, duration=5)
return
dlg = AlgorithmDialog(self.model)
dlg.exec_()
def runModel(self):
if len(self.alg.algs) == 0:
self.bar.pushMessage("", "Model doesn't contain any algorithm and/or parameter and can't be executed", level=QgsMessageBar.WARNING, duration=5)
return
dlg = AlgorithmDialog(self.alg)
dlg.exec_()
def createAlgorithmDialog(algOrName, parameters={}):
"""
Creates and returns an algorithm dialog for the specified algorithm, prepopulated
with a given set of parameters. It is the caller's responsibility to execute
and delete this dialog.
:param algOrName: Either an instance of an algorithm, or an algorithm's ID
:param parameters: Initial algorithm parameters dictionary
:returns algorithm results as a dictionary, or None if execution failed
:rtype: Union[dict, None]
"""
if isinstance(algOrName, QgsProcessingAlgorithm):
alg = algOrName.create()
else:
alg = QgsApplication.processingRegistry().createAlgorithmById(algOrName)
if alg is None:
return False
dlg = alg.createCustomParametersWidget(iface.mainWindow())
if not dlg:
dlg = AlgorithmDialog(alg, parent=iface.mainWindow())
dlg.setParameters(parameters)
return dlg
def runAsSingle(self):
self.close()
from processing.gui.AlgorithmDialog import AlgorithmDialog
dlg = AlgorithmDialog(self.algorithm().create(), parent=iface.mainWindow())
dlg.show()
dlg.exec_()
def __init__(self, alg, toolbox):
AlgorithmDialog.__init__(self, alg)
self.toolbox = toolbox
self.cornerWidget.setVisible(False)
self.btnRun.setText(self.tr("OK"))
self.tabWidget.removeTab(1)
self.settingsPanel = SettingsPanel()
self.tabWidget.addTab(self.settingsPanel, "Description")
def runAlg(file):
alg = QgsProcessingModelAlgorithm()
if not alg.fromFile(file):
return False
alg.setProvider(QgsApplication.processingRegistry().providerById('model'))
dlg = AlgorithmDialog(alg)
dlg.show()
return True
def runModel(self):
if len(self.model.childAlgorithms()) == 0:
self.bar.pushMessage("", "Model doesn't contain any algorithm and/or parameter and can't be executed", level=QgsMessageBar.WARNING, duration=5)
return
dlg = AlgorithmDialog(self.model)
dlg.exec_()
# have to manually delete the dialog - otherwise it's owned by the
# iface mainWindow and never deleted
dlg.deleteLater()
def __init__(self, alg):
AlgorithmDialog.__init__(self, alg)
QgsMapLayerRegistry.instance().layerWasAdded.disconnect(self.mainWidget.layerAdded)
QgsMapLayerRegistry.instance().layersWillBeRemoved.disconnect(self.mainWidget.layersWillBeRemoved)
self.tabWidget.widget(0).layout().removeWidget(self.mainWidget)
self.mainWidget = FieldsMapperParametersPanel(self, alg)
self.setMainWidget()
QgsMapLayerRegistry.instance().layerWasAdded.connect(self.mainWidget.layerAdded)
QgsMapLayerRegistry.instance().layersWillBeRemoved.connect(self.mainWidget.layersWillBeRemoved)
def runModel(self):
if len(self.alg.algs) == 0:
self.bar.pushMessage("", "Model doesn't contain any algorithm and/or parameter and can't be executed", level=QgsMessageBar.WARNING, duration=5)
return
if self.alg.provider is None:
# Might happen if model is opened from modeler dialog
self.alg.provider = QgsApplication.processingRegistry().providerById('model')
alg = self.alg.getCopy()
dlg = AlgorithmDialog(alg)
dlg.exec_()
def runModel(self):
if len(self.alg.algs) == 0:
QMessageBox.warning(self, self.tr('Empty model'),
self.tr("Model doesn't contains any algorithms and/or "
"parameters and can't be executed"))
return
if self.alg.provider is None:
# Might happen if model is opened from modeler dialog
self.alg.provider = ModelerUtils.providers['model']
alg = self.alg.getCopy()
dlg = AlgorithmDialog(alg)
dlg.exec_()
def runAlgorithm(self):
_locals = {}
try:
exec(self.editor.text(), _locals)
except Exception as e:
error = QgsError(traceback.format_exc(), "Processing")
QgsErrorDialog.show(error,
self.tr("Execution error")
)
return
alg = None
try:
alg = algfactory.instances.pop().createInstance()
except IndexError:
for name, attr in _locals.items():
if inspect.isclass(attr) and issubclass(attr, (QgsProcessingAlgorithm, QgsProcessingFeatureBasedAlgorithm)) and attr.__name__ not in ("QgsProcessingAlgorithm", "QgsProcessingFeatureBasedAlgorithm"):
alg = attr()
break
if alg is None:
QMessageBox.warning(self,
self.tr("No script found"),
self.tr("Seems there is no valid script in the file.")
)
return
alg.setProvider(QgsApplication.processingRegistry().providerById("script"))
alg.initAlgorithm()
dlg = alg.createCustomParametersWidget(iface.mainWindow())
if not dlg:
dlg = AlgorithmDialog(alg, parent=iface.mainWindow())
canvas = iface.mapCanvas()
prevMapTool = canvas.mapTool()
dlg.show()
if canvas.mapTool() != prevMapTool:
try:
canvas.mapTool().reset()
except:
pass
canvas.setMapTool(prevMapTool)
def runAlgorithm(self):
d = {}
try:
exec(self.editor.text(), d)
except Exception as e:
error = QgsError(traceback.format_exc(), "Processing")
QgsErrorDialog.show(error,
self.tr("Execution error")
)
return
alg = None
for k, v in d.items():
if inspect.isclass(v) and issubclass(v, (QgsProcessingAlgorithm, QgsProcessingFeatureBasedAlgorithm)) and v.__name__ not in ("QgsProcessingAlgorithm", "QgsProcessingFeatureBasedAlgorithm"):
alg = v()
break
if alg is None:
QMessageBox.warning(self,
self.tr("No script found"),
self.tr("Seems there is no valid script in the file.")
)
return
alg.setProvider(QgsApplication.processingRegistry().providerById("script"))
alg.initAlgorithm()
dlg = alg.createCustomParametersWidget(self)
if not dlg:
dlg = AlgorithmDialog(alg)
canvas = iface.mapCanvas()
prevMapTool = canvas.mapTool()
dlg.show()
if canvas.mapTool() != prevMapTool:
try:
canvas.mapTool().reset()
except:
pass
canvas.setMapTool(prevMapTool)
def runAlgorithm(self):
if self.algType == self.SCRIPT_PYTHON:
alg = ScriptAlgorithm(None, self.editor.text())
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)
def createAlgorithmDialog(algOrName, parameters={}):
"""Creates and returns an algorithm dialog for the specified algorithm, prepopulated
with a given set of parameters. It is the caller's responsibility to execute
and delete this dialog.
"""
if isinstance(algOrName, QgsProcessingAlgorithm):
alg = algOrName
else:
alg = QgsApplication.processingRegistry().createAlgorithmById(algOrName)
if alg is None:
return False
dlg = alg.createCustomParametersWidget(iface.mainWindow())
if not dlg:
dlg = AlgorithmDialog(alg)
dlg.setParameters(parameters)
return dlg
def runWorkflow(self):
item = self.algorithmTree.currentItem()
if isinstance(item, TreeAlgorithmItem):
alg = Processing.getAlgorithm(item.alg.commandLineName())
message = alg.checkBeforeOpeningParametersDialog()
if message:
QtGui.QMessageBox.warning(self, self.tr("Warning"), message)
return
alg = alg.getCopy()
dlg = alg.getCustomParametersDialog()
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)
def runAlgorithm(self):
if self.algType == self.SCRIPT_PYTHON:
alg = ScriptAlgorithm(None, unicode(self.editor.text()))
alg.provider = ModelerUtils.providers['script']
if self.algType == self.SCRIPT_R:
alg = RAlgorithm(None, unicode(self.editor.text()))
alg.provider = ModelerUtils.providers['r']
dlg = alg.getCustomParametersDialog()
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)
def runAlgorithm(self):
if self.algType == self.SCRIPT_PYTHON:
alg = ScriptAlgorithm(None, self.editor.text())
alg.provider = QgsApplication.processingRegistry().providerById('script')
if self.algType == self.SCRIPT_R:
alg = RAlgorithm(None, self.editor.text())
alg.provider = QgsApplication.processingRegistry().providerById('r')
dlg = alg.getCustomParametersDialog()
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)
def runalg_parameters(self):
dlg = self.alg.getCustomParametersDialog()
if not dlg:
dlg = AlgorithmDialog(self.alg)
# Hack to handle that hacky code...
dlg.setParamValues = lambda: True
dlg.show()
dlg.accept()
while not dlg.executed:
time.sleep(.5)
def runAlgorithm(self):
if self.algType == self.SCRIPT_PYTHON:
alg = ScriptAlgorithm(None, self.editor.text())
dlg = alg.createCustomParametersWidget(self)
if not dlg:
dlg = AlgorithmDialog(alg)
canvas = iface.mapCanvas()
prevMapTool = canvas.mapTool()
dlg.show()
dlg.exec_()
# have to manually delete the dialog - otherwise it's owned by the
# iface mainWindow and never deleted
dlg.deleteLater()
if canvas.mapTool() != prevMapTool:
try:
canvas.mapTool().reset()
except:
pass
canvas.setMapTool(prevMapTool)
def __init__(self, alg):
AlgorithmDialog.__init__(self, alg)
QgsMapLayerRegistry.instance().layerWasAdded.connect(self.mainWidget.layerAdded)
QgsMapLayerRegistry.instance().layersWillBeRemoved.connect(self.mainWidget.layersWillBeRemoved)
class StepDialog(QtGui.QDialog):
def __init__(self, alg, mainDialog, canEdit=True):
self.alg = alg
self.mainDialog = mainDialog
self.goForward = False
self.goBackward = False
QtGui.QDialog.__init__(self)
self.setWindowFlags(self.windowFlags() | QtCore.Qt.WindowSystemMenuHint |
QtCore.Qt.WindowMinMaxButtonsHint)
# create a tab for this algorithm
self.tabLayout = QtGui.QGridLayout()
self.algInstructions = QtGui.QTextEdit()
self.algInstructions.setMinimumWidth(250)
self.algInstructions.setMaximumWidth(250)
self.algInstructions.setFontPointSize(10)
if not canEdit:
self.algInstructions.setReadOnly(True)
self.normalModeDialog = alg.getCustomParametersDialog()
if not self.normalModeDialog:
self.normalModeDialog = AlgorithmDialog(alg)
self.batchModeDialog = BatchAlgorithmDialog(alg)
self.batchModeDialog.setHidden(True)
# forwardButton does the job of cancel/close button
try:
if self.alg.name == "Field calculator":
self.normalModeDialog.mButtonBox.removeButton(self.normalModeDialog.mButtonBox.button(QtGui.QDialogButtonBox.Cancel))
else:
self.normalModeDialog.buttonBox.removeButton(self.normalModeDialog.buttonBox.button(QtGui.QDialogButtonBox.Close))
self.batchModeDialog.buttonBox.removeButton(self.batchModeDialog.buttonBox.button(QtGui.QDialogButtonBox.Close)) # forwardButton does this job
except:
# Not all dialogs might have buttonBox
pass
if canEdit:
try:
self.normalModeDialog.progressBar.hide()
self.batchModeDialog.progressBar.hide()
if self.alg.name == "Field calculator":
self.normalModeDialog.mButtonBox.hide()
else:
self.normalModeDialog.buttonBox.hide()
self.batchModeDialog.buttonBox.hide()
except:
# Not all dialogs might have buttonBox
pass
self.normalModeDialog.connect(self.normalModeDialog, QtCore.SIGNAL("finished(int)"), self.forward)
self.batchModeDialog.connect(self.batchModeDialog, QtCore.SIGNAL("finished(int)"), self.forward)
self.tabLayout.addWidget(self.algInstructions,0,0)
self.tabLayout.addWidget(self.normalModeDialog, 0, 1)
self.tabLayout.addWidget(self.batchModeDialog, 0, 1)
self.algMode = QtGui.QComboBox()
self.algMode.addItems([NORMAL_MODE, BATCH_MODE])
if canEdit:
self.algMode.connect(self.algMode, QtCore.SIGNAL("currentIndexChanged(QString)"), self.mainDialog.changeAlgMode)
self.tabLayout.addWidget(self.algMode, 1, 1)
else:
self.buttonBox = QtGui.QDialogButtonBox()
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.backwardButton = QtGui.QPushButton()
self.backwardButton.setText("< Previous step")
self.buttonBox.addButton(self.backwardButton, QtGui.QDialogButtonBox.ActionRole)
QtCore.QObject.connect(self.backwardButton, QtCore.SIGNAL("clicked()"), self.backward)
self.forwardButton = QtGui.QPushButton()
self.forwardButton.setText("Skip step >")
self.buttonBox.addButton(self.forwardButton, QtGui.QDialogButtonBox.ActionRole)
QtCore.QObject.connect(self.forwardButton, QtCore.SIGNAL("clicked()"), self.forward)
self.closeButton = QtGui.QPushButton()
self.closeButton.setText("Finish Workflow")
self.buttonBox.addButton(self.closeButton, QtGui.QDialogButtonBox.ActionRole)
QtCore.QObject.connect(self.closeButton, QtCore.SIGNAL("clicked()"), self.close)
self.tabLayout.addWidget(self.buttonBox, 1, 1)
self.setLayout(self.tabLayout)
self.executed = self.normalModeDialog.executed
def forward(self):
self.goForward = True
self.close()
def backward(self):
self.goBackward = True
self.close()
def getMode(self):
return self.algMode.currentText()
def setMode(self, mode):
if mode == NORMAL_MODE and not self.normalModeDialog.isVisible():
self.batchModeDialog.setHidden(True)
self.normalModeDialog.setVisible(True)
elif mode == BATCH_MODE and not self.batchModeDialog.isVisible():
self.normalModeDialog.setHidden(True)
self.batchModeDialog.setVisible(True)
self.resize(1050, 500)
def getInstructions(self):
return self.algInstructions.toPlainText()
def setInstructions(self, instructions):
self.algInstructions.setText(instructions)
# not used for now
def addRasterInputs(self, inputs):
if self.getMode() == NORMAL_MODE:
panelList = self.normalModeDialog.mainWidget.findChildren(InputLayerSelectorPanel)
else:
panelList = self.normalBatchDialog.mainWidget.findChildren(InputLayerSelectorPanel)
for panel in panelList:
comboBox = panel.text
for myInput in inputs:
comboBox.addItem(myInput, myInput)
def __init__(self, alg, mainDialog, canEdit=True):
self.alg = alg
self.mainDialog = mainDialog
self.goForward = False
self.goBackward = False
QtGui.QDialog.__init__(self)
self.setWindowFlags(self.windowFlags() | QtCore.Qt.WindowSystemMenuHint |
QtCore.Qt.WindowMinMaxButtonsHint)
# create a tab for this algorithm
self.tabLayout = QtGui.QGridLayout()
self.algInstructions = QtGui.QTextEdit()
self.algInstructions.setMinimumWidth(250)
self.algInstructions.setMaximumWidth(250)
self.algInstructions.setFontPointSize(10)
if not canEdit:
self.algInstructions.setReadOnly(True)
self.normalModeDialog = alg.getCustomParametersDialog()
if not self.normalModeDialog:
self.normalModeDialog = AlgorithmDialog(alg)
self.batchModeDialog = BatchAlgorithmDialog(alg)
self.batchModeDialog.setHidden(True)
# forwardButton does the job of cancel/close button
try:
if self.alg.name == "Field calculator":
self.normalModeDialog.mButtonBox.removeButton(self.normalModeDialog.mButtonBox.button(QtGui.QDialogButtonBox.Cancel))
else:
self.normalModeDialog.buttonBox.removeButton(self.normalModeDialog.buttonBox.button(QtGui.QDialogButtonBox.Close))
self.batchModeDialog.buttonBox.removeButton(self.batchModeDialog.buttonBox.button(QtGui.QDialogButtonBox.Close)) # forwardButton does this job
except:
# Not all dialogs might have buttonBox
pass
if canEdit:
try:
self.normalModeDialog.progressBar.hide()
self.batchModeDialog.progressBar.hide()
if self.alg.name == "Field calculator":
self.normalModeDialog.mButtonBox.hide()
else:
self.normalModeDialog.buttonBox.hide()
self.batchModeDialog.buttonBox.hide()
except:
# Not all dialogs might have buttonBox
pass
self.normalModeDialog.connect(self.normalModeDialog, QtCore.SIGNAL("finished(int)"), self.forward)
self.batchModeDialog.connect(self.batchModeDialog, QtCore.SIGNAL("finished(int)"), self.forward)
self.tabLayout.addWidget(self.algInstructions,0,0)
self.tabLayout.addWidget(self.normalModeDialog, 0, 1)
self.tabLayout.addWidget(self.batchModeDialog, 0, 1)
self.algMode = QtGui.QComboBox()
self.algMode.addItems([NORMAL_MODE, BATCH_MODE])
if canEdit:
self.algMode.connect(self.algMode, QtCore.SIGNAL("currentIndexChanged(QString)"), self.mainDialog.changeAlgMode)
self.tabLayout.addWidget(self.algMode, 1, 1)
else:
self.buttonBox = QtGui.QDialogButtonBox()
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.backwardButton = QtGui.QPushButton()
self.backwardButton.setText("< Previous step")
self.buttonBox.addButton(self.backwardButton, QtGui.QDialogButtonBox.ActionRole)
QtCore.QObject.connect(self.backwardButton, QtCore.SIGNAL("clicked()"), self.backward)
self.forwardButton = QtGui.QPushButton()
self.forwardButton.setText("Skip step >")
self.buttonBox.addButton(self.forwardButton, QtGui.QDialogButtonBox.ActionRole)
QtCore.QObject.connect(self.forwardButton, QtCore.SIGNAL("clicked()"), self.forward)
self.closeButton = QtGui.QPushButton()
self.closeButton.setText("Finish Workflow")
self.buttonBox.addButton(self.closeButton, QtGui.QDialogButtonBox.ActionRole)
QtCore.QObject.connect(self.closeButton, QtCore.SIGNAL("clicked()"), self.close)
self.tabLayout.addWidget(self.buttonBox, 1, 1)
self.setLayout(self.tabLayout)
self.executed = self.normalModeDialog.executed
class ScriptEditorDialog(BASE, WIDGET):
hasChanged = False
def __init__(self, filePath=None, parent=None):
super(ScriptEditorDialog, self).__init__(parent)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.searchWidget.setVisible(False)
if iface is not None:
self.toolBar.setIconSize(iface.iconSize())
self.setStyleSheet(iface.mainWindow().styleSheet())
self.actionOpenScript.setIcon(
QgsApplication.getThemeIcon('/mActionScriptOpen.svg'))
self.actionSaveScript.setIcon(
QgsApplication.getThemeIcon('/mActionFileSave.svg'))
self.actionSaveScriptAs.setIcon(
QgsApplication.getThemeIcon('/mActionFileSaveAs.svg'))
self.actionRunScript.setIcon(
QgsApplication.getThemeIcon('/mActionStart.svg'))
self.actionCut.setIcon(
QgsApplication.getThemeIcon('/mActionEditCut.svg'))
self.actionCopy.setIcon(
QgsApplication.getThemeIcon('/mActionEditCopy.svg'))
self.actionPaste.setIcon(
QgsApplication.getThemeIcon('/mActionEditPaste.svg'))
self.actionUndo.setIcon(
QgsApplication.getThemeIcon('/mActionUndo.svg'))
self.actionRedo.setIcon(
QgsApplication.getThemeIcon('/mActionRedo.svg'))
self.actionFindReplace.setIcon(
QgsApplication.getThemeIcon('/mActionFindReplace.svg'))
self.actionIncreaseFontSize.setIcon(
QgsApplication.getThemeIcon('/mActionIncreaseFont.svg'))
self.actionDecreaseFontSize.setIcon(
QgsApplication.getThemeIcon('/mActionDecreaseFont.svg'))
# Connect signals and slots
self.actionOpenScript.triggered.connect(self.openScript)
self.actionSaveScript.triggered.connect(self.save)
self.actionSaveScriptAs.triggered.connect(self.saveAs)
self.actionRunScript.triggered.connect(self.runAlgorithm)
self.actionCut.triggered.connect(self.editor.cut)
self.actionCopy.triggered.connect(self.editor.copy)
self.actionPaste.triggered.connect(self.editor.paste)
self.actionUndo.triggered.connect(self.editor.undo)
self.actionRedo.triggered.connect(self.editor.redo)
self.actionFindReplace.toggled.connect(self.toggleSearchBox)
self.actionIncreaseFontSize.triggered.connect(self.editor.zoomIn)
self.actionDecreaseFontSize.triggered.connect(self.editor.zoomOut)
self.editor.textChanged.connect(lambda: self.setHasChanged(True))
self.leFindText.returnPressed.connect(self.find)
self.btnFind.clicked.connect(self.find)
self.btnReplace.clicked.connect(self.replace)
self.lastSearch = None
self.run_dialog = None
self.filePath = None
if filePath is not None:
self._loadFile(filePath)
self.setHasChanged(False)
def update_dialog_title(self):
"""
Updates the script editor dialog title
"""
if self.filePath:
path, file_name = os.path.split(self.filePath)
else:
file_name = self.tr('Untitled Script')
if self.hasChanged:
file_name = '*' + file_name
self.setWindowTitle(
self.tr('{} - Processing Script Editor').format(file_name))
def closeEvent(self, event):
settings = QgsSettings()
settings.setValue("/Processing/stateScriptEditor", self.saveState())
settings.setValue("/Processing/geometryScriptEditor",
self.saveGeometry())
if self.hasChanged:
ret = QMessageBox.question(
self, self.tr('Save Script?'),
self.
tr('There are unsaved changes in this script. Do you want to keep those?'
),
QMessageBox.Save | QMessageBox.Cancel | QMessageBox.Discard,
QMessageBox.Cancel)
if ret == QMessageBox.Save:
self.saveScript(False)
event.accept()
elif ret == QMessageBox.Discard:
event.accept()
else:
event.ignore()
else:
event.accept()
def openScript(self):
if self.hasChanged:
ret = QMessageBox.warning(
self, self.tr("Unsaved changes"),
self.tr("There are unsaved changes in the script. Continue?"),
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if ret == QMessageBox.No:
return
scriptDir = ScriptUtils.scriptsFolders()[0]
fileName, _ = QFileDialog.getOpenFileName(
self, self.tr("Open script"), scriptDir,
self.tr("Processing scripts (*.py *.PY)"))
if fileName == "":
return
with OverrideCursor(Qt.WaitCursor):
self._loadFile(fileName)
def save(self):
self.saveScript(False)
def saveAs(self):
self.saveScript(True)
def saveScript(self, saveAs):
newPath = None
if self.filePath is None or saveAs:
scriptDir = ScriptUtils.scriptsFolders()[0]
newPath, _ = QFileDialog.getSaveFileName(
self, self.tr("Save script"), scriptDir,
self.tr("Processing scripts (*.py *.PY)"))
if newPath:
if not newPath.lower().endswith(".py"):
newPath += ".py"
self.filePath = newPath
if self.filePath:
text = self.editor.text()
try:
with codecs.open(self.filePath, "w", encoding="utf-8") as f:
f.write(text)
except IOError as e:
QMessageBox.warning(
self, self.tr("I/O error"),
self.tr("Unable to save edits:\n{}").format(str(e)))
return
self.setHasChanged(False)
QgsApplication.processingRegistry().providerById(
"script").refreshAlgorithms()
def setHasChanged(self, hasChanged):
self.hasChanged = hasChanged
self.actionSaveScript.setEnabled(hasChanged)
self.update_dialog_title()
def runAlgorithm(self):
if self.run_dialog and not sip.isdeleted(self.run_dialog):
self.run_dialog.close()
self.run_dialog = None
_locals = {}
try:
exec(self.editor.text(), _locals)
except Exception as e:
error = QgsError(traceback.format_exc(), "Processing")
QgsErrorDialog.show(error, self.tr("Execution error"))
return
alg = None
try:
alg = algfactory.instances.pop().createInstance()
except IndexError:
for name, attr in _locals.items():
if inspect.isclass(attr) and issubclass(
attr,
(QgsProcessingAlgorithm, QgsProcessingFeatureBasedAlgorithm
)) and attr.__name__ not in (
"QgsProcessingAlgorithm",
"QgsProcessingFeatureBasedAlgorithm"):
alg = attr()
break
if alg is None:
QMessageBox.warning(
self, self.tr("No script found"),
self.tr("Seems there is no valid script in the file."))
return
alg.setProvider(
QgsApplication.processingRegistry().providerById("script"))
alg.initAlgorithm()
self.run_dialog = alg.createCustomParametersWidget(self)
if not self.run_dialog:
self.run_dialog = AlgorithmDialog(alg, parent=self)
canvas = iface.mapCanvas()
prevMapTool = canvas.mapTool()
self.run_dialog.show()
if canvas.mapTool() != prevMapTool:
try:
canvas.mapTool().reset()
except:
pass
canvas.setMapTool(prevMapTool)
def find(self):
textToFind = self.leFindText.text()
caseSensitive = self.chkCaseSensitive.isChecked()
wholeWord = self.chkWholeWord.isChecked()
if self.lastSearch is None or textToFind != self.lastSearch:
self.editor.findFirst(textToFind, False, caseSensitive, wholeWord,
True)
else:
self.editor.findNext()
def replace(self):
textToReplace = self.leReplaceText.text()
self.editor.replaceSelectedText(textToReplace)
def toggleSearchBox(self, checked):
self.searchWidget.setVisible(checked)
if (checked):
self.leFindText.setFocus()
def _loadFile(self, filePath):
with codecs.open(filePath, "r", encoding="utf-8") as f:
txt = f.read()
self.editor.setText(txt)
self.hasChanged = False
self.editor.setModified(False)
self.editor.recolor()
self.filePath = filePath
self.update_dialog_title()
def testCreation(self):
alg = QgsApplication.processingRegistry().createAlgorithmById('native:centroids')
a = AlgorithmDialog(alg)
self.assertEqual(a.mainWidget().alg, alg)
def executeAlgorithm(self):
config = {}
if self.in_place_mode:
config['IN_PLACE'] = True
alg = self.algorithmTree.selectedAlgorithm().create(
config) if self.algorithmTree.selectedAlgorithm(
) is not None else None
if alg is not None:
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 self.in_place_mode and not [
d for d in alg.parameterDefinitions()
if d.name() not in ('INPUT', 'OUTPUT')
]:
parameters = {}
feedback = MessageBarProgress(algname=alg.displayName())
ok, results = execute_in_place(alg,
parameters,
feedback=feedback)
if ok:
iface.messageBar().pushSuccess(
'',
self.tr(
'{algname} completed. %n feature(s) processed.',
n=results['__count']).format(
algname=alg.displayName()))
feedback.close()
# MessageBarProgress handles errors
return
if alg.countVisibleParameters() > 0:
dlg = alg.createCustomParametersWidget(self)
if not dlg:
dlg = AlgorithmDialog(alg, self.in_place_mode,
iface.mainWindow())
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(algname=alg.displayName())
context = dataobjects.createContext(feedback)
parameters = {}
ret, results = execute(alg, parameters, context, feedback)
handleAlgorithmResults(alg, context, feedback)
feedback.close()
def setParamValue(self, param, widget, alg=None):
if isinstance(param, ParameterFieldsMapping):
return param.setValue(widget.value())
return AlgorithmDialog.setParamValue(self, param, widget, alg)
def executeAlgorithm(self, alg_id, parent, in_place=False, as_batch=False):
"""Executes a project model with GUI interaction if needed.
:param alg_id: algorithm id
:type alg_id: string
:param parent: parent widget
:type parent: QWidget
:param in_place: in place flag, defaults to False
:type in_place: bool, optional
:param as_batch: execute as batch flag, defaults to False
:type as_batch: bool, optional
"""
config = {}
if in_place:
config['IN_PLACE'] = True
alg = QgsApplication.instance().processingRegistry(
).createAlgorithmById(alg_id, config)
if alg is not None:
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 as_batch:
dlg = BatchAlgorithmDialog(alg, iface.mainWindow())
dlg.setAttribute(Qt.WA_DeleteOnClose)
dlg.show()
dlg.exec_()
else:
in_place_input_parameter_name = 'INPUT'
if hasattr(alg, 'inputParameterName'):
in_place_input_parameter_name = alg.inputParameterName()
if in_place and not [
d
for d in alg.parameterDefinitions() if d.name() not in
(in_place_input_parameter_name, 'OUTPUT')
]:
parameters = {}
feedback = MessageBarProgress(algname=alg.displayName())
ok, results = execute_in_place(alg,
parameters,
feedback=feedback)
if ok:
iface.messageBar().pushSuccess(
'',
self.
tr('{algname} completed. %n feature(s) processed.',
n=results['__count']).format(
algname=alg.displayName()))
feedback.close()
# MessageBarProgress handles errors
return
if alg.countVisibleParameters() > 0:
dlg = alg.createCustomParametersWidget(parent)
if not dlg:
dlg = AlgorithmDialog(alg, in_place,
iface.mainWindow())
canvas = iface.mapCanvas()
prevMapTool = canvas.mapTool()
dlg.show()
dlg.exec_()
if canvas.mapTool() != prevMapTool:
try:
canvas.mapTool().reset()
except Exception:
pass
canvas.setMapTool(prevMapTool)
else:
feedback = MessageBarProgress(algname=alg.displayName())
context = dataobjects.createContext(feedback)
parameters = {}
ret, results = execute(alg, parameters, context, feedback)
handleAlgorithmResults(alg, context, feedback)
feedback.close()
def testCreation(self):
alg = QgsApplication.processingRegistry().algorithmById(
'native:centroids')
a = AlgorithmDialog(alg)
self.assertEqual(a.mainWidget.alg, alg)
def testRange(self):
# minimal test to check if wrapper generate GUI for each processign context
self.checkConstructWrapper(QgsProcessingParameterRange('test'),
RangeWidgetWrapper)
alg = QgsApplication.processingRegistry().createAlgorithmById(
'native:centroids')
dlg = AlgorithmDialog(alg)
param = QgsProcessingParameterRange(
name='test',
description='test',
type=QgsProcessingParameterNumber.Double,
defaultValue="0.0,100.0")
wrapper = RangeWidgetWrapper(param, dlg)
widget = wrapper.createWidget()
# range values check
# check initial value
self.assertEqual(widget.getValue(), '0.0,100.0')
# check set/get
widget.setValue("100.0,200.0")
self.assertEqual(widget.getValue(), '100.0,200.0')
# check that min/max are mutually adapted
widget.setValue("200.0,100.0")
self.assertEqual(widget.getValue(), '100.0,100.0')
widget.spnMax.setValue(50)
self.assertEqual(widget.getValue(), '50.0,50.0')
widget.spnMin.setValue(100)
self.assertEqual(widget.getValue(), '100.0,100.0')
# check for integers
param = QgsProcessingParameterRange(
name='test',
description='test',
type=QgsProcessingParameterNumber.Integer,
defaultValue="0.1,100.1")
wrapper = RangeWidgetWrapper(param, dlg)
widget = wrapper.createWidget()
# range values check
# check initial value
self.assertEqual(widget.getValue(), '0.0,100.0')
# check rounding
widget.setValue("100.1,200.1")
self.assertEqual(widget.getValue(), '100.0,200.0')
widget.setValue("100.6,200.6")
self.assertEqual(widget.getValue(), '101.0,201.0')
# check set/get
widget.setValue("100.1,200.1")
self.assertEqual(widget.getValue(), '100.0,200.0')
# check that min/max are mutually adapted
widget.setValue("200.1,100.1")
self.assertEqual(widget.getValue(), '100.0,100.0')
widget.spnMax.setValue(50.1)
self.assertEqual(widget.getValue(), '50.0,50.0')
widget.spnMin.setValue(100.1)
self.assertEqual(widget.getValue(), '100.0,100.0')
def setParamValue(self, param, widget, alg=None):
if param.name in self.customParam.keys():
if isinstance(self.customParam[param.name], QComboBox):
return param.setValue(widget.currentText())
return AlgorithmDialog.setParamValue(self, param, widget, alg)
def testDistance(self):
self.checkConstructWrapper(QgsProcessingParameterDistance('test'),
DistanceWidgetWrapper)
alg = QgsApplication.processingRegistry().createAlgorithmById(
'native:centroids')
dlg = AlgorithmDialog(alg)
param = QgsProcessingParameterDistance('test')
wrapper = DistanceWidgetWrapper(param, dlg)
widget = wrapper.createWidget()
# test units
widget.show()
# crs values
widget.setUnitParameterValue('EPSG:3111')
self.assertEqual(widget.label.text(), 'meters')
self.assertFalse(widget.warning_label.isVisible())
self.assertTrue(widget.units_combo.isVisible())
self.assertFalse(widget.label.isVisible())
self.assertEqual(widget.units_combo.currentData(),
QgsUnitTypes.DistanceMeters)
widget.setUnitParameterValue('EPSG:4326')
self.assertEqual(widget.label.text(), 'degrees')
self.assertTrue(widget.warning_label.isVisible())
self.assertFalse(widget.units_combo.isVisible())
self.assertTrue(widget.label.isVisible())
widget.setUnitParameterValue(QgsCoordinateReferenceSystem('EPSG:3111'))
self.assertEqual(widget.label.text(), 'meters')
self.assertFalse(widget.warning_label.isVisible())
self.assertTrue(widget.units_combo.isVisible())
self.assertFalse(widget.label.isVisible())
self.assertEqual(widget.units_combo.currentData(),
QgsUnitTypes.DistanceMeters)
widget.setUnitParameterValue(QgsCoordinateReferenceSystem('EPSG:4326'))
self.assertEqual(widget.label.text(), 'degrees')
self.assertTrue(widget.warning_label.isVisible())
self.assertFalse(widget.units_combo.isVisible())
self.assertTrue(widget.label.isVisible())
# layer values
vl = QgsVectorLayer("Polygon?crs=epsg:3111&field=pk:int", "vl",
"memory")
widget.setUnitParameterValue(vl)
self.assertEqual(widget.label.text(), 'meters')
self.assertFalse(widget.warning_label.isVisible())
self.assertTrue(widget.units_combo.isVisible())
self.assertFalse(widget.label.isVisible())
self.assertEqual(widget.units_combo.currentData(),
QgsUnitTypes.DistanceMeters)
vl2 = QgsVectorLayer("Polygon?crs=epsg:4326&field=pk:int", "vl",
"memory")
widget.setUnitParameterValue(vl2)
self.assertEqual(widget.label.text(), 'degrees')
self.assertTrue(widget.warning_label.isVisible())
self.assertFalse(widget.units_combo.isVisible())
self.assertTrue(widget.label.isVisible())
# unresolvable values
widget.setUnitParameterValue(vl.id())
self.assertEqual(widget.label.text(), '<unknown>')
self.assertFalse(widget.warning_label.isVisible())
self.assertFalse(widget.units_combo.isVisible())
self.assertTrue(widget.label.isVisible())
# resolvable text value
QgsProject.instance().addMapLayer(vl)
widget.setUnitParameterValue(vl.id())
self.assertEqual(widget.label.text(), 'meters')
self.assertFalse(widget.warning_label.isVisible())
self.assertTrue(widget.units_combo.isVisible())
self.assertFalse(widget.label.isVisible())
self.assertEqual(widget.units_combo.currentData(),
QgsUnitTypes.DistanceMeters)
widget.setValue(5)
self.assertEqual(widget.getValue(), 5)
widget.units_combo.setCurrentIndex(
widget.units_combo.findData(QgsUnitTypes.DistanceKilometers))
self.assertEqual(widget.getValue(), 5000)
widget.setValue(2)
self.assertEqual(widget.getValue(), 2000)
widget.setUnitParameterValue(vl.id())
self.assertEqual(widget.getValue(), 2)
widget.setValue(5)
self.assertEqual(widget.getValue(), 5)
widget.deleteLater()
def setParamValue(self, param, widget, alg=None):
if isinstance(param, ParameterFieldsMapping):
return param.setValue(widget.value())
return AlgorithmDialog.setParamValue(self, param, widget, alg)
