Class: QgsProcessingAlgorithm¶
- class qgis.core.QgsProcessingAlgorithm¶
Bases:
sip.wrapper
Abstract base class for processing algorithms.
New in version 3.0.
QgsProcessingAlgorithm() Constructor for QgsProcessingAlgorithm.
initAlgorithm()
should be called after creating an algorithm to ensure it can correctly configure itsparameterDefinitions()
andoutputDefinitions()
. Alternatively, callingcreate()
will return a pre-initialized copy of the algorithm.Methods
Adds an output
definition
to the algorithm.Adds a parameter
definition
to the algorithm.Returns a JSON serializable variant map containing the specified
parameters
andcontext
settings.Returns a Python command string which can be executed to run the algorithm using the specified
parameters
.Returns a command string which will execute the algorithm using the specified
parameters
via the command line qgis_process tool.Returns
True
if the algorithm can execute.Checks the supplied
parameter
values to verify that they satisfy the requirements of this algorithm in the suppliedcontext
.Returns the number of visible (non-hidden) parameters defined by this algorithm.
Creates a copy of the algorithm, ready for execution.
If an algorithm subclass implements a custom parameters widget, a copy of this widget should be constructed and returned by this method.
Creates an expression context relating to the algorithm.
Creates a new instance of the algorithm class.
Returns a list of destination parameters definitions utilized by the algorithm.
Returns the translated algorithm name, which should be used for any user-visible display of the algorithm name.
Returns the flags indicating how and when the algorithm operates and should be exposed to users.
Returns the name of the group this algorithm belongs to.
Returns the unique ID of the group this algorithm belongs to.
Returns
True
if this algorithm generates HTML outputs.Returns a localised help string for the algorithm.
Returns a url pointing to the algorithm's help page.
Returns an icon for the algorithm.
Returns the unique ID for the algorithm, which is a combination of the algorithm provider's ID and the algorithms unique name (e.g.
Initializes the algorithm using the specified
configuration
.Returns a user-friendly string to use as an error when a point cloud layer input could not be loaded.
Returns a user-friendly string to use as an error when a raster layer input could not be loaded.
Returns a user-friendly string to use as an error when a sink parameter could not be created.
Returns a user-friendly string to use as an error when a source parameter could not be loaded.
Returns the algorithm name, used for identifying the algorithm.
Returns a matching output by
name
.Returns an ordered list of output definitions utilized by the algorithm.
Evaluates the parameter with matching
name
to an annotation layer.Evaluates the parameter with matching
name
to a static boolean value.Evaluates the parameter with matching
name
to a static boolean value.Evaluates the parameter with matching
name
to a color, or returns an invalid color if the parameter was not set.Evaluates the parameter with matching
name
to a source vector layer file path of compatible format.Evaluates the parameter with matching
name
to a source vector layer file path and layer name of compatible format.Evaluates the parameter with matching
name
to a connection name string.Evaluates the parameter with matching
name
to a coordinate reference system.Evaluates the parameter with matching
name
to a database table name string.Evaluates the parameter with matching
name
to a DateTime, or returns an invalid date time if the parameter was not set.Evaluates the parameter with matching
name
to a static double value.Evaluates the parameter with matching
name
to a enum value.Evaluates the parameter with matching
name
to a static enum string.Evaluates the parameter with matching
name
to list of static enum strings.Evaluates the parameter with matching
name
to list of enum values.Evaluates the parameter with matching
name
to an expression.Evaluates the parameter with matching
name
to a rectangular extent.Returns the coordinate reference system associated with an extent parameter value.
Evaluates the parameter with matching
name
to a rectangular extent, and returns a geometry covering this extent.Evaluates the parameter with matching
name
to a list of fields.Evaluates the parameter with matching
name
to a file/folder name.Evaluates the parameter with matching
name
to a list of files (forQgsProcessingParameterMultipleLayers
inQgsProcessing
:TypeFile mode).Evaluates the parameter with matching
name
to a file based output destination.Evaluates the parameter with matching
name
to a geometry.Returns the coordinate reference system associated with a geometry parameter value.
Evaluates the parameter with matching
name
to a static integer value.Evaluates the parameter with matching
name
to a list of integer values.Evaluates the parameter with matching
name
to a map layer.Evaluates the parameter with matching
name
to a list of map layers.Evaluates the parameter with matching
name
to a print layout.Evaluates the parameter with matching
name
to a print layout item, taken from the specifiedlayout
.Evaluates the parameter with matching
name
to a matrix/table of values.Evaluates the parameter with matching
name
to a mesh layer.Evaluates the parameter with matching
name
to a output layer destination.Evaluates the parameter with matching
name
to a point.Evaluates the parameter with matching
name
to a point cloud layer.Returns the coordinate reference system associated with an point parameter value.
Evaluates the parameter with matching
name
to a range of values.Evaluates the parameter with matching
name
to a raster layer.Evaluates the parameter with matching
name
to a database schema name string.Evaluates the parameter with matching
name
to a feature sink.Evaluates the parameter with matching
name
to a feature source.Evaluates the parameter with matching
name
to a static string value.Evaluates the parameter with matching
name
to a list of strings (e.g.Evaluates the parameter with matching
name
to a vector layer.Returns a matching parameter by
name
.Returns an ordered list of parameter definitions utilized by the algorithm.
Should be called in the main thread following the completion of
runPrepared()
.Allows the algorithm to perform any required cleanup tasks.
Prepares the algorithm for execution.
Prepares the algorithm to run using the specified
parameters
.Pre-processes a set of
parameters
, allowing the algorithm to clean their values.Runs the algorithm using the specified
parameters
.Returns the provider to which this algorithm belongs.
Removes the parameter with matching
name
from the algorithm, and deletes any existing definition.Executes the algorithm using the specified
parameters
.Runs the algorithm, which has been prepared by an earlier call to
prepare()
.Associates this algorithm with its provider.
Returns an optional translated short description of the algorithm.
Returns a localised short helper string for the algorithm.
Returns the vector properties which will be used for the
sink
with matching name.Checks whether this algorithm supports in-place editing on the given
layer
Default implementation returnsFalse
.Returns a path to an SVG version of the algorithm's icon.
Returns a list of tags which relate to the algorithm, and are used to assist users in searching for suitable algorithms.
Checks whether the coordinate reference systems for the specified set of
parameters
are valid for the algorithm.Returns a user-friendly string to use as an error when a feature cannot be written into a sink.
Attributes
- Available = 1¶
- class Flag¶
Bases:
int
- FlagCanCancel = 16¶
- FlagCustomException = 1024¶
- FlagDeprecated = 6¶
- FlagDisplayNameIsLiteral = 128¶
- FlagHideFromModeler = 4¶
- FlagHideFromToolbox = 2¶
- FlagKnownIssues = 512¶
- FlagNoThreading = 64¶
- FlagNotAvailableInStandaloneTool = 8192¶
- FlagPruneModelBranchesBasedOnAlgorithmResults = 2048¶
- FlagRequiresMatchingCrs = 32¶
- FlagRequiresProject = 16384¶
- FlagSkipGenericModelLogging = 4096¶
- FlagSupportsBatch = 8¶
- FlagSupportsInPlaceEdits = 256¶
- class Flags¶
- class Flags(Union[QgsProcessingAlgorithm.Flags, QgsProcessingAlgorithm.Flag])
- class Flags(QgsProcessingAlgorithm.Flags)
Bases:
sip.wrapper
- NotAvailable = 0¶
- class PropertyAvailability¶
Bases:
int
- class VectorProperties¶
- class VectorProperties(QgsProcessingAlgorithm.VectorProperties)
Bases:
sip.wrapper
- availability¶
- crs¶
- fields¶
- wkbType¶
- addOutput(self, outputDefinition: QgsProcessingOutputDefinition) bool ¶
Adds an output
definition
to the algorithm. Ownership of the definition is transferred to the algorithm. ReturnsTrue
if the output could be successfully added, orFalse
if the output could not be added (e.g. as a result of a duplicate name).This should usually be called from a subclass’
initAlgorithm()
implementation.Note that in some cases output creation can be automatically performed when calling
addParameter()
. See the notes inaddParameter()
for a description of when this occurs.See also
See also
- Parameters:
outputDefinition (QgsProcessingOutputDefinition) –
- Return type:
bool
- addParameter(self, parameterDefinition: QgsProcessingParameterDefinition, createOutput: bool = True) bool ¶
Adds a parameter
definition
to the algorithm. Ownership of the definition is transferred to the algorithm. ReturnsTrue
if parameter could be successfully added, orFalse
if the parameter could not be added (e.g. as a result of a duplicate name).This should usually be called from a subclass’
initAlgorithm()
implementation.If the
createOutput
argument isTrue
, then a corresponding output definition will also be created (and added to the algorithm) where appropriate. E.g. when adding aQgsProcessingParameterVectorDestination
andcreateOutput
isTrue
, then aQgsProcessingOutputVectorLayer
output will be created and added to the algorithm. There is no need to calladdOutput()
to manually add a corresponding output for this vector. IfcreateOutput
isFalse
then this automatic output creation will not occur.See also
See also
- Parameters:
parameterDefinition (QgsProcessingParameterDefinition) –
createOutput (bool = True) –
- Return type:
bool
- asMap(self, parameters: Dict[str, Any], context: QgsProcessingContext) Dict[str, Any] ¶
Returns a JSON serializable variant map containing the specified
parameters
andcontext
settings.New in version 3.24.
- Parameters:
parameters (Dict[str) –
context (QgsProcessingContext) –
- Return type:
Dict[str, Any]
- asPythonCommand(self, parameters: Dict[str, Any], context: QgsProcessingContext) str ¶
Returns a Python command string which can be executed to run the algorithm using the specified
parameters
.Algorithms which cannot be run from a Python command should return an empty string.
- Parameters:
parameters (Dict[str) –
context (QgsProcessingContext) –
- Return type:
str
- asQgisProcessCommand(self, parameters: Dict[str, Any], context: QgsProcessingContext) Tuple[str, bool] ¶
Returns a command string which will execute the algorithm using the specified
parameters
via the command line qgis_process tool.Note that some combinations of parameter types and values cannot be represented as a qgis_process string.
- Parameters:
parameters (Dict[str) – algorithm parameters
context (QgsProcessingContext) – processing context
- Return type:
Tuple[str, bool]
- Returns:
equivalent qgis_process command
ok: will be set to
True
if the command was successfully generated
New in version 3.24.
- canExecute(self) Tuple[bool, str] ¶
Returns
True
if the algorithm can execute. Algorithm subclasses can returnFalse
here to indicate that they are not able to execute, e.g. as a result of unmet external dependencies. If specified, theerrorMessage
argument will be filled with a localised error message describing why the algorithm cannot execute.- Return type:
Tuple[bool, str]
- checkParameterValues(self, parameters: Dict[str, Any], context: QgsProcessingContext) Tuple[bool, str] ¶
Checks the supplied
parameter
values to verify that they satisfy the requirements of this algorithm in the suppliedcontext
. Themessage
parameter will be filled with explanatory text if validation fails. Overridden implementations should also check this base class implementation.- Return type:
Tuple[bool, str]
- Returns:
True
if parameters are acceptable for the algorithm.- Parameters:
parameters (Dict[str) –
context (QgsProcessingContext) –
- countVisibleParameters(self) int ¶
Returns the number of visible (non-hidden) parameters defined by this algorithm.
- Return type:
int
- create(self, configuration: Dict[str, Any] = {}) QgsProcessingAlgorithm ¶
Creates a copy of the algorithm, ready for execution.
This method returns a new, preinitialized copy of the algorithm, ready for executing.
The
configuration
argument allows passing of a map of configuration settings to the algorithm, allowing it to dynamically adjust its initialized parameters and outputs according to this configuration. This is generally used only for algorithms in a model, allowing them to adjust their behavior at run time according to some user configuration.Raises a
QgsProcessingException
if a new algorithm instance could not be created, e.g. if there is an issue with the subclass’createInstance()
method.See also
- Parameters:
configuration (Dict[str) –
- Return type:
- createCustomParametersWidget(self, parent: QWidget = None) QWidget ¶
If an algorithm subclass implements a custom parameters widget, a copy of this widget should be constructed and returned by this method. The base class implementation returns
None
, which indicates that an autogenerated parameters widget should be used.- Parameters:
parent (QWidget = None) –
- Return type:
QWidget
- createExpressionContext(self, parameters: Dict[str, Any], context: QgsProcessingContext, source: QgsProcessingFeatureSource = None) QgsExpressionContext ¶
Creates an expression context relating to the algorithm. This can be called by algorithms to create a new expression context ready for evaluating expressions within the algorithm. Optionally, a
source
can be specified which will be used to populate the context if it implements theQgsExpressionContextGenerator
interface.- Parameters:
parameters (Dict[str) –
context (QgsProcessingContext) –
source (
QgsProcessingFeatureSource
= None) –
- Return type:
- createInstance(self) QgsProcessingAlgorithm ¶
Creates a new instance of the algorithm class.
This method should return a ‘pristine’ instance of the algorithm class.
- Return type:
- destinationParameterDefinitions(self) List[QgsProcessingParameterDefinition] ¶
Returns a list of destination parameters definitions utilized by the algorithm.
See also
- Return type:
- displayName(self) str ¶
Returns the translated algorithm name, which should be used for any user-visible display of the algorithm name.
Algorithm display names should be short, e.g. ideally no more than 3 or 4 words. The name should use sentence case (e.g. “Raster layer statistics”, not “Raster Layer Statistics”).
See also
See also
- Return type:
str
- flags(self) QgsProcessingAlgorithm.Flags ¶
Returns the flags indicating how and when the algorithm operates and should be exposed to users. Default flags are FlagSupportsBatch and FlagCanCancel.
- Return type:
- group(self) str ¶
Returns the name of the group this algorithm belongs to. This string should be localised.
See also
See also
- Return type:
str
- groupId(self) str ¶
Returns the unique ID of the group this algorithm belongs to. This string should be fixed for the algorithm, and must not be localised. The group id should be unique within each provider. Group id should contain lowercase alphanumeric characters only and no spaces or other formatting characters.
See also
- Return type:
str
- hasHtmlOutputs(self) bool ¶
Returns
True
if this algorithm generates HTML outputs.- Return type:
bool
- helpString(self) str ¶
Returns a localised help string for the algorithm. Algorithm subclasses should implement either
helpString()
orhelpUrl()
.See also
See also
Deprecated since version Unused,: will be removed in QGIS 4.0
- Return type:
str
- helpUrl(self) str ¶
Returns a url pointing to the algorithm’s help page.
See also
See also
- Return type:
str
- icon(self) QIcon ¶
Returns an icon for the algorithm.
See also
- Return type:
QIcon
- id(self) str ¶
Returns the unique ID for the algorithm, which is a combination of the algorithm provider’s ID and the algorithms unique name (e.g. “qgis:mergelayers” ).
See also
See also
- Return type:
str
- initAlgorithm(self, configuration: Dict[str, Any] = {})¶
Initializes the algorithm using the specified
configuration
.This should be called directly after creating algorithms and before retrieving any
parameterDefinitions()
oroutputDefinitions()
.Subclasses should use their implementations to add all required input parameter and output definitions (which can be dynamically adjusted according to
configuration
).Dynamic configuration can be used by algorithms which alter their behavior when used inside processing models. For instance, a “feature router” type algorithm which sends input features to one of any number of outputs sinks based on some preconfigured filter parameters can use the init method to create these outputs based on the specified
configuration
.See also
See also
- Parameters:
configuration (Dict[str) –
- invalidPointCloudError(parameters: Dict[str, Any], name: str) str ¶
Returns a user-friendly string to use as an error when a point cloud layer input could not be loaded.
The
parameters
argument should give the algorithms parameter map, and thename
should correspond to the invalid point cloud parameter name.See also
See also
See also
New in version 3.32.
- Parameters:
parameters (Dict[str) –
name (str) –
- Return type:
str
- invalidRasterError(parameters: Dict[str, Any], name: str) str ¶
Returns a user-friendly string to use as an error when a raster layer input could not be loaded.
The
parameters
argument should give the algorithms parameter map, and thename
should correspond to the invalid raster parameter name.See also
See also
See also
New in version 3.2.
- Parameters:
parameters (Dict[str) –
name (str) –
- Return type:
str
- invalidSinkError(parameters: Dict[str, Any], name: str) str ¶
Returns a user-friendly string to use as an error when a sink parameter could not be created.
The
parameters
argument should give the algorithms parameter map, and thename
should correspond to the invalid sink parameter name.See also
See also
See also
New in version 3.2.
- Parameters:
parameters (Dict[str) –
name (str) –
- Return type:
str
- invalidSourceError(parameters: Dict[str, Any], name: str) str ¶
Returns a user-friendly string to use as an error when a source parameter could not be loaded.
The
parameters
argument should give the algorithms parameter map, and thename
should correspond to the invalid source parameter name.See also
See also
See also
New in version 3.2.
- Parameters:
parameters (Dict[str) –
name (str) –
- Return type:
str
- name(self) str ¶
Returns the algorithm name, used for identifying the algorithm. This string should be fixed for the algorithm, and must not be localised. The name should be unique within each provider. Names should contain lowercase alphanumeric characters only and no spaces or other formatting characters.
See also
See also
See also
- Return type:
str
- outputDefinition(self, name: str) QgsProcessingOutputDefinition ¶
Returns a matching output by
name
. Matching is done in a case-insensitive manner.See also
- Parameters:
name (str) –
- Return type:
- outputDefinitions(self) List[QgsProcessingOutputDefinition] ¶
Returns an ordered list of output definitions utilized by the algorithm.
See also
See also
- Return type:
- parameterAsAnnotationLayer(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) QgsAnnotationLayer ¶
Evaluates the parameter with matching
name
to an annotation layer.Annotation layers will be taken from
context
’s active project. Callers do not need to handle deletion of the returned layer.Warning
Working with annotation layers is generally not thread safe (unless the layers are from a
QgsProject
loaded directly in a background thread). Ensure your algorithm returns the QgsProcessingAlgorithm.FlagNoThreading flag or only accesses annotation layers from aprepareAlgorithm()
orpostProcessAlgorithm()
step.New in version 3.22.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
- parameterAsBool(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) bool ¶
Evaluates the parameter with matching
name
to a static boolean value.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
bool
- parameterAsBoolean(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) bool ¶
Evaluates the parameter with matching
name
to a static boolean value.New in version 3.8.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
bool
- parameterAsColor(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) QColor ¶
Evaluates the parameter with matching
name
to a color, or returns an invalid color if the parameter was not set.New in version 3.10.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
QColor
- parameterAsCompatibleSourceLayerPath(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext, compatibleFormats: Iterable[str], preferredFormat: str = '', feedback: QgsProcessingFeedback = None) str ¶
Evaluates the parameter with matching
name
to a source vector layer file path of compatible format.If the parameter is evaluated to an existing layer, and that layer is not of the format listed in the
compatibleFormats
argument, then the layer will first be exported to a compatible format in a temporary location. The function will then return the path to that temporary file.compatibleFormats
should consist entirely of lowercase file extensions, e.g. ‘shp’.The
preferredFormat
argument is used to specify to desired file extension to use when a temporary layer export is required.When an algorithm is capable of handling multi-layer input files (such as Geopackage), it is preferable to use
parameterAsCompatibleSourceLayerPathAndLayerName()
which may avoid conversion in more situations.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
compatibleFormats (Iterable[str]) –
preferredFormat (str = '') –
feedback (
QgsProcessingFeedback
= None) –
- Return type:
str
- parameterAsCompatibleSourceLayerPathAndLayerName(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext, compatibleFormats: Iterable[str], preferredFormat: str = '', feedback: QgsProcessingFeedback = None) Tuple[str, str] ¶
Evaluates the parameter with matching
name
to a source vector layer file path and layer name of compatible format.If the parameter is evaluated to an existing layer, and that layer is not of the format listed in the
compatibleFormats
argument, then the layer will first be exported to a compatible format in a temporary location. The function will then return the path to that temporary file.compatibleFormats
should consist entirely of lowercase file extensions, e.g. ‘shp’.The
preferredFormat
argument is used to specify to desired file extension to use when a temporary layer export is required. This defaults to shapefiles, because shapefiles are the future (don’t believe the geopackage hype!).This method should be preferred over
parameterAsCompatibleSourceLayerPath()
when an algorithm is able to correctly handle files with multiple layers. UnlikeparameterAsCompatibleSourceLayerPath()
, it will not force a conversion in this case and will return the target layer name in thelayerName
argument.- Parameters:
parameters (Dict[str) – input parameter value map
name (str) – name of target parameter
context (QgsProcessingContext) – processing context
compatibleFormats (Iterable[str]) – a list of lowercase file extensions compatible with the algorithm
preferredFormat (str = '') – preferred format extension to use if conversion if required
feedback (
QgsProcessingFeedback
= None) – feedback object
- Return type:
Tuple[str, str]
- Returns:
path to source layer, or nearly converted compatible layer
layerName: will be set to the target layer name for multi-layer sources (e.g. Geopackage)
New in version 3.10.
- parameterAsConnectionName(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) str ¶
Evaluates the parameter with matching
name
to a connection name string.New in version 3.14.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
str
- parameterAsCrs(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) QgsCoordinateReferenceSystem ¶
Evaluates the parameter with matching
name
to a coordinate reference system.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
- parameterAsDatabaseTableName(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) str ¶
Evaluates the parameter with matching
name
to a database table name string.New in version 3.14.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
str
- parameterAsDateTime(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) QDateTime ¶
Evaluates the parameter with matching
name
to a DateTime, or returns an invalid date time if the parameter was not set.New in version 3.14.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
QDateTime
- parameterAsDouble(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) float ¶
Evaluates the parameter with matching
name
to a static double value.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
float
- parameterAsEnum(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) int ¶
Evaluates the parameter with matching
name
to a enum value.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
int
- parameterAsEnumString(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) str ¶
Evaluates the parameter with matching
name
to a static enum string.New in version 3.18.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
str
- parameterAsEnumStrings(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) List[str] ¶
Evaluates the parameter with matching
name
to list of static enum strings.New in version 3.18.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
List[str]
- parameterAsEnums(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) List[int] ¶
Evaluates the parameter with matching
name
to list of enum values.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
List[int]
- parameterAsExpression(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) str ¶
Evaluates the parameter with matching
name
to an expression.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
str
- parameterAsExtent(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext, crs: QgsCoordinateReferenceSystem = QgsCoordinateReferenceSystem()) QgsRectangle ¶
Evaluates the parameter with matching
name
to a rectangular extent.If
crs
is set, and the original coordinate reference system of the parameter can be determined, then the extent will be automatically reprojected so that it is in the specifiedcrs
. In this case the extent of the reproject rectangle will be returned.See also
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
crs (
QgsCoordinateReferenceSystem
= QgsCoordinateReferenceSystem()) –
- Return type:
- parameterAsExtentCrs(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) QgsCoordinateReferenceSystem ¶
Returns the coordinate reference system associated with an extent parameter value.
See also
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
- parameterAsExtentGeometry(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext, crs: QgsCoordinateReferenceSystem = QgsCoordinateReferenceSystem()) QgsGeometry ¶
Evaluates the parameter with matching
name
to a rectangular extent, and returns a geometry covering this extent.If
crs
is set, and the original coordinate reference system of the parameter can be determined, then the extent will be automatically reprojected so that it is in the specifiedcrs
. UnlikeparameterAsExtent()
, the reprojected rectangle returned by this function will no longer be a rectangle itself (i.e. this method returns the geometry of the actual reprojected rectangle, whileparameterAsExtent()
returns just the extent of the reprojected rectangle).See also
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
crs (
QgsCoordinateReferenceSystem
= QgsCoordinateReferenceSystem()) –
- Return type:
- parameterAsFields(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) List[str] ¶
Evaluates the parameter with matching
name
to a list of fields.Deprecated since version use:
parameterAsStrings()
instead.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
List[str]
- parameterAsFile(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) str ¶
Evaluates the parameter with matching
name
to a file/folder name.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
str
- parameterAsFileList(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) List[str] ¶
Evaluates the parameter with matching
name
to a list of files (forQgsProcessingParameterMultipleLayers
inQgsProcessing
:TypeFile mode).New in version 3.10.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
List[str]
- parameterAsFileOutput(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) str ¶
Evaluates the parameter with matching
name
to a file based output destination.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
str
- parameterAsGeometry(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext, crs: QgsCoordinateReferenceSystem = QgsCoordinateReferenceSystem()) QgsGeometry ¶
Evaluates the parameter with matching
name
to a geometry.If
crs
is set then the geometry will be automatically reprojected so that it is in the specifiedcrs
.See also
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
crs (
QgsCoordinateReferenceSystem
= QgsCoordinateReferenceSystem()) –
- Return type:
- parameterAsGeometryCrs(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) QgsCoordinateReferenceSystem ¶
Returns the coordinate reference system associated with a geometry parameter value.
See also
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
- parameterAsInt(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) int ¶
Evaluates the parameter with matching
name
to a static integer value.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
int
- parameterAsInts(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) List[int] ¶
Evaluates the parameter with matching
name
to a list of integer values.New in version 3.4.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
List[int]
- parameterAsLayer(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) QgsMapLayer ¶
Evaluates the parameter with matching
name
to a map layer.Layers will either be taken from
context
’s active project, or loaded from external sources and stored temporarily in thecontext
. In either case, callers do not need to handle deletion of the returned layer.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
- parameterAsLayerList(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext, flags: QgsProcessing.LayerOptionsFlags | QgsProcessing.LayerOptionsFlag = QgsProcessing.LayerOptionsFlags()) List[QgsMapLayer] ¶
Evaluates the parameter with matching
name
to a list of map layers. Theflags
are used to set options for loading layers (e.g. skip index generation).- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
flags (Union[QgsProcessing.LayerOptionsFlags) –
- Return type:
List[QgsMapLayer]
- parameterAsLayout(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) QgsPrintLayout ¶
Evaluates the parameter with matching
name
to a print layout.Warning
This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.
New in version 3.8.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
- parameterAsLayoutItem(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext, layout: QgsPrintLayout) QgsLayoutItem ¶
Evaluates the parameter with matching
name
to a print layout item, taken from the specifiedlayout
.Warning
This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.
New in version 3.8.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
layout (QgsPrintLayout) –
- Return type:
- parameterAsMatrix(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) List[Any] ¶
Evaluates the parameter with matching
name
to a matrix/table of values. Tables are collapsed to a 1 dimensional list.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
List[Any]
- parameterAsMeshLayer(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) QgsMeshLayer ¶
Evaluates the parameter with matching
name
to a mesh layer.Layers will either be taken from
context
’s active project, or loaded from external sources and stored temporarily in thecontext
. In either case, callers do not need to handle deletion of the returned layer.New in version 3.6.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
- parameterAsOutputLayer(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) str ¶
Evaluates the parameter with matching
name
to a output layer destination.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
str
- parameterAsPoint(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext, crs: QgsCoordinateReferenceSystem = QgsCoordinateReferenceSystem()) QgsPointXY ¶
Evaluates the parameter with matching
name
to a point.If
crs
is set then the point will be automatically reprojected so that it is in the specifiedcrs
.See also
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
crs (
QgsCoordinateReferenceSystem
= QgsCoordinateReferenceSystem()) –
- Return type:
- parameterAsPointCloudLayer(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext, flags: QgsProcessing.LayerOptionsFlags | QgsProcessing.LayerOptionsFlag = QgsProcessing.LayerOptionsFlags()) QgsPointCloudLayer ¶
Evaluates the parameter with matching
name
to a point cloud layer. Theflags
are used to set options for loading layer (e.g. skip index generation).Layers will either be taken from
context
’s active project, or loaded from external sources and stored temporarily in thecontext
. In either case, callers do not need to handle deletion of the returned layer.New in version 3.22.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
flags (Union[QgsProcessing.LayerOptionsFlags) –
- Return type:
- parameterAsPointCrs(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) QgsCoordinateReferenceSystem ¶
Returns the coordinate reference system associated with an point parameter value.
See also
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
- parameterAsRange(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) List[float] ¶
Evaluates the parameter with matching
name
to a range of values.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
List[float]
- parameterAsRasterLayer(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) QgsRasterLayer ¶
Evaluates the parameter with matching
name
to a raster layer.Layers will either be taken from
context
’s active project, or loaded from external sources and stored temporarily in thecontext
. In either case, callers do not need to handle deletion of the returned layer.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
- parameterAsSchema(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) str ¶
Evaluates the parameter with matching
name
to a database schema name string.New in version 3.14.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
str
- parameterAsSink(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext, fields: QgsFields, geometryType: Qgis.WkbType = Qgis.WkbType.NoGeometry, crs: QgsCoordinateReferenceSystem = QgsCoordinateReferenceSystem(), sinkFlags: QgsFeatureSink.SinkFlags | QgsFeatureSink.SinkFlag = QgsFeatureSink.SinkFlags(), createOptions: Dict[str, Any] = {}, datasourceOptions: Iterable[str] = [], layerOptions: Iterable[str] = []) Tuple[QgsFeatureSink, str] ¶
Evaluates the parameter with matching
name
to a feature sink.Sinks will either be taken from
context
’s active project, or created from external providers and stored temporarily in thecontext
.The
fields
,geometryType
andcrs
parameters dictate the properties of the resulting feature sink.The
destinationIdentifier
argument will be set to a string which can be used to retrieve the layer corresponding to the sink, e.g. via callingQgsProcessingUtils.mapLayerFromString()
.The
createOptions
argument is used to pass on creation options such as layer name.The
datasourceOptions
andlayerOptions
arguments is used to pass on GDAL-specific format driver options.This function creates a new object and the caller takes responsibility for deleting the returned object.
- Raises:
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
fields (QgsFields) –
geometryType (Qgis.WkbType = Qgis.WkbType.NoGeometry) –
crs (
QgsCoordinateReferenceSystem
= QgsCoordinateReferenceSystem()) –sinkFlags (Union[QgsFeatureSink.SinkFlags) –
createOptions (Dict[str) –
datasourceOptions (Iterable[str] = []) –
layerOptions (Iterable[str] = []) –
- Return type:
Tuple[
QgsFeatureSink
, str]
- parameterAsSource(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) QgsProcessingFeatureSource ¶
Evaluates the parameter with matching
name
to a feature source.Sources will either be taken from
context
’s active project, or loaded from external sources and stored temporarily in thecontext
.This function creates a new object and the caller takes responsibility for deleting the returned object.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
- parameterAsString(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) str ¶
Evaluates the parameter with matching
name
to a static string value.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
str
- parameterAsStrings(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) List[str] ¶
Evaluates the parameter with matching
name
to a list of strings (e.g. field names or point cloud attributes).New in version 3.32.
- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
List[str]
- parameterAsVectorLayer(self, parameters: Dict[str, Any], name: str, context: QgsProcessingContext) QgsVectorLayer ¶
Evaluates the parameter with matching
name
to a vector layer.Layers will either be taken from
context
’s active project, or loaded from external sources and stored temporarily in thecontext
. In either case, callers do not need to handle deletion of the returned layer.- Parameters:
parameters (Dict[str) –
name (str) –
context (QgsProcessingContext) –
- Return type:
- parameterDefinition(self, name: str) QgsProcessingParameterDefinition ¶
Returns a matching parameter by
name
. Matching is done in a case-insensitive manner, but exact case matches will be preferred.See also
- Parameters:
name (str) –
- Return type:
- parameterDefinitions(self) List[QgsProcessingParameterDefinition] ¶
Returns an ordered list of parameter definitions utilized by the algorithm.
See also
See also
See also
- Return type:
- postProcess(self, context: QgsProcessingContext, feedback: QgsProcessingFeedback) Dict[str, Any] ¶
Should be called in the main thread following the completion of
runPrepared()
. This method allows the algorithm to perform any required cleanup tasks. The returned variant map includes the results evaluated by the algorithm.Note
This method modifies the algorithm instance, so it is not safe to call on algorithms directly retrieved from
QgsProcessingRegistry
andQgsProcessingProvider
. Instead, a copy of the algorithm should be created withclone()
andprepare()
/runPrepared()
called on the copy.- Parameters:
context (QgsProcessingContext) –
feedback (QgsProcessingFeedback) –
- Return type:
Dict[str, Any]
- postProcessAlgorithm(self, context: QgsProcessingContext, feedback: QgsProcessingFeedback) Dict[str, Any] ¶
Allows the algorithm to perform any required cleanup tasks. The returned variant map includes the results evaluated by the algorithm. These may be output layer references, or calculated values such as statistical calculations.
The
context
argument specifies the context in which the algorithm was run.Postprocess progress should be reported using the supplied
feedback
object. Additionally, well-behaved algorithms should periodically checkfeedback
to determine whether the post processing should be canceled and exited early.postProcessAlgorithm should be used to handle any thread-sensitive cleanup which is required by the algorithm. It will always be called from the same thread that
context
has thread affinity with. While this will generally be the main thread, it is not guaranteed. For instance, algorithms which are run as a step in a larger model or as a subcomponent of a script-based algorithm will call postProcessAlgorithm from the same thread as that model/script it being executed in.postProcessAlgorithm will not be called if the
prepareAlgorithm()
step failed (returnedFalse
), or if an exception was raised by theprocessAlgorithm()
step.- Return type:
Dict[str, Any]
- Returns:
A map of algorithm outputs. These may be output layer references, or calculated values such as statistical calculations. Implementations which return a non-empty map will override any results returned by
processAlgorithm()
.
See also
See also
- Parameters:
context (QgsProcessingContext) –
feedback (QgsProcessingFeedback) –
- prepare(self, parameters: Dict[str, Any], context: QgsProcessingContext, feedback: QgsProcessingFeedback) bool ¶
Prepares the algorithm for execution. This must be run in the main thread, and allows the algorithm to pre-evaluate input parameters in a thread-safe manner. This must be called before calling
runPrepared()
(which is safe to do in any thread).See also
See also
Note
This method modifies the algorithm instance, so it is not safe to call on algorithms directly retrieved from
QgsProcessingRegistry
andQgsProcessingProvider
. Instead, a copy of the algorithm should be created withclone()
andprepare()
/runPrepared()
called on the copy.- Parameters:
parameters (Dict[str) –
context (QgsProcessingContext) –
feedback (QgsProcessingFeedback) –
- Return type:
bool
- prepareAlgorithm(self, parameters: Dict[str, Any], context: QgsProcessingContext, feedback: QgsProcessingFeedback) bool ¶
Prepares the algorithm to run using the specified
parameters
. Algorithms should implement their logic for evaluating parameter values here. The evaluated parameter results should be stored in member variables ready for a call toprocessAlgorithm()
.The
context
argument specifies the context in which the algorithm is being run.prepareAlgorithm should be used to handle any thread-sensitive preparation which is required by the algorithm. It will always be called from the same thread that
context
has thread affinity with. While this will generally be the main thread, it is not guaranteed. For instance, algorithms which are run as a step in a larger model or as a subcomponent of a script-based algorithm will call prepareAlgorithm from the same thread as that model/script it being executed in.Note that the processAlgorithm step uses a temporary context with affinity for the thread in which the algorithm is executed, making it safe for processAlgorithm implementations to load sources and sinks without issue. Implementing prepareAlgorithm is only required if special thread safe handling is required by the algorithm.
Algorithm preparation progress should be reported using the supplied
feedback
object. Additionally, well-behaved algorithms should periodically checkfeedback
to determine whether the algorithm should be canceled and exited early.If the preparation was successful algorithms must return
True
. If aFalse
value is returned this indicates that the preparation could not be completed, and the algorithm execution will be canceled.- Return type:
bool
- Returns:
True
if preparation was successful.
See also
See also
- Parameters:
parameters (Dict[str) –
context (QgsProcessingContext) –
feedback (QgsProcessingFeedback) –
- preprocessParameters(self, parameters: Dict[str, Any]) Dict[str, Any] ¶
Pre-processes a set of
parameters
, allowing the algorithm to clean their values.This method is automatically called after users enter parameters, e.g. via the algorithm dialog. This method should NOT be called manually by algorithms.
- Parameters:
parameters (Dict[str) –
- Return type:
Dict[str, Any]
- processAlgorithm(self, parameters: Dict[str, Any], context: QgsProcessingContext, feedback: QgsProcessingFeedback) Dict[str, Any] ¶
Runs the algorithm using the specified
parameters
. Algorithms should implement their custom processing logic here.The
context
argument gives a temporary context with thread affinity matching the thread in which the algorithm is being run. This is a cut-back copy of the context passed to theprepareAlgorithm()
andpostProcessAlgorithm()
steps, but it is generally safe for most algorithms to utilize this context for loading layers and creating sinks. Any loaded layers or sinks created within this temporary context will be transferred back to the main execution context upon successful completion of theprocessAlgorithm()
step.Algorithm progress should be reported using the supplied
feedback
object. Additionally, well-behaved algorithms should periodically checkfeedback
to determine whether the algorithm should be canceled and exited early.This method will not be called if the
prepareAlgorithm()
step failed (returnedFalse
).Implementations of processAlgorithm can throw the
QgsProcessingException
exception to indicate that a fatal error occurred within the execution.- Return type:
Dict[str, Any]
- Returns:
A map of algorithm outputs. These may be output layer references, or calculated values such as statistical calculations. Unless the algorithm subclass overrides the
postProcessAlgorithm()
step this returned map will be used as the output for the algorithm.
See also
See also
- Parameters:
parameters (Dict[str) –
context (QgsProcessingContext) –
feedback (QgsProcessingFeedback) –
- provider(self) QgsProcessingProvider ¶
Returns the provider to which this algorithm belongs.
- Return type:
- removeParameter(self, name: str)¶
Removes the parameter with matching
name
from the algorithm, and deletes any existing definition.- Parameters:
name (str) –
- run(self, parameters: Dict[str, Any], context: QgsProcessingContext, feedback: QgsProcessingFeedback, configuration: Dict[str, Any] = {}, catchExceptions: bool = True) Tuple[Dict[str, Any], bool] ¶
Executes the algorithm using the specified
parameters
. This method internally creates a copy of the algorithm before running it, so it is safe to call on algorithms directly retrieved fromQgsProcessingRegistry
andQgsProcessingProvider
.The
context
argument specifies the context in which the algorithm is being run.Algorithm progress should be reported using the supplied
feedback
object.If specified,
ok
will be set toTrue
if algorithm was successfully run.If
catchExceptions
is set toFalse
, thenQgsProcessingException
raised during the algorithm run will not be automatically caught and will be raised instead.- Return type:
Tuple[Dict[str, Any], bool]
- Returns:
A map of algorithm outputs. These may be output layer references, or calculated values such as statistical calculations.
Note
this method can only be called from the main thread. Use
prepare()
,runPrepared()
andpostProcess()
if you need to run algorithms from a background thread, or use theQgsProcessingAlgRunnerTask
class.- Parameters:
parameters (Dict[str) –
context (QgsProcessingContext) –
feedback (QgsProcessingFeedback) –
configuration (Dict[str) –
catchExceptions (bool = True) –
- runPrepared(self, parameters: Dict[str, Any], context: QgsProcessingContext, feedback: QgsProcessingFeedback) Dict[str, Any] ¶
Runs the algorithm, which has been prepared by an earlier call to
prepare()
. This method is safe to call from any thread. ReturnsTrue
if the algorithm was successfully executed. AfterrunPrepared()
has finished, thepostProcess()
method should be called from the main thread to allow the algorithm to perform any required cleanup tasks and return its final result.See also
See also
Note
This method modifies the algorithm instance, so it is not safe to call on algorithms directly retrieved from
QgsProcessingRegistry
andQgsProcessingProvider
. Instead, a copy of the algorithm should be created withclone()
andprepare()
/runPrepared()
called on the copy.- Parameters:
parameters (Dict[str) –
context (QgsProcessingContext) –
feedback (QgsProcessingFeedback) –
- Return type:
Dict[str, Any]
- setProvider(self, provider: QgsProcessingProvider)¶
Associates this algorithm with its provider. No transfer of ownership is involved.
- Parameters:
provider (QgsProcessingProvider) –
- shortDescription(self) str ¶
Returns an optional translated short description of the algorithm. This should be at most a single sentence, e.g. “Converts 2D features to 3D by sampling a DEM raster.”
New in version 3.2.
- Return type:
str
- shortHelpString(self) str ¶
Returns a localised short helper string for the algorithm. This string should provide a basic description about what the algorithm does and the parameters and outputs associated with it.
See also
See also
- Return type:
str
- sinkProperties(self, sink: str, parameters: Dict[str, Any], context: QgsProcessingContext, sourceProperties: Dict[str, QgsProcessingAlgorithm.VectorProperties]) QgsProcessingAlgorithm.VectorProperties ¶
Returns the vector properties which will be used for the
sink
with matching name.The
parameters
argument specifies the values of all parameters which would be used to generate the sink. These can be used alongside the providedcontext
in order to pre-evaluate inputs when required in order to determine the sink’s properties.The
sourceProperties
map will contain the vector properties of the various sources used as inputs to the algorithm. These will only be available in certain circumstances (e.g. when the algorithm is used within a model), so implementations will need to be adaptable to circumstances when eithersourceParameters
is empty orparameters
is empty, and use whatever information is passed in order to make a best guess determination of the output properties.New in version 3.14.
- Parameters:
sink (str) –
parameters (Dict[str) –
context (QgsProcessingContext) –
sourceProperties (Dict[str) –
- Return type:
- supportInPlaceEdit(self, layer: QgsMapLayer) bool ¶
Checks whether this algorithm supports in-place editing on the given
layer
Default implementation returnsFalse
.- Return type:
bool
- Returns:
True
if the algorithm supports in-place editing
New in version 3.4.
- Parameters:
layer (QgsMapLayer) –
- svgIconPath(self) str ¶
Returns a path to an SVG version of the algorithm’s icon.
See also
- Return type:
str
- tags(self) List[str] ¶
Returns a list of tags which relate to the algorithm, and are used to assist users in searching for suitable algorithms. These tags should be localised.
- Return type:
List[str]
- validateInputCrs(self, parameters: Dict[str, Any], context: QgsProcessingContext) bool ¶
Checks whether the coordinate reference systems for the specified set of
parameters
are valid for the algorithm. For instance, the base implementation performs checks to ensure that all input CRS are equal ReturnsTrue
ifparameters
have passed the CRS check.- Parameters:
parameters (Dict[str) –
context (QgsProcessingContext) –
- Return type:
bool
- writeFeatureError(sink: QgsFeatureSink, parameters: Dict[str, Any], name: str) str ¶
Returns a user-friendly string to use as an error when a feature cannot be written into a sink.
The
sink
argument is the sink into which the feature cannot be written.The
parameters
argument should give the algorithms parameter map, and thename
should correspond to the sink parameter name.New in version 3.22.
- Parameters:
sink (QgsFeatureSink) –
parameters (Dict[str) –
name (str) –
- Return type:
str