In “Running Processing tools“, we explored the basics of running Processing tools from PyQGIS. This time, we’ll look into how to chain multiple tools into a workflow.

In this example, we’ll be building a workflow that computes which cities are located along the Danube river (data from NaturalEarthData). We’ll first use the GUI to run the corresponding tools (Extract by attribute, Buffer, and Extract by location) and test our workflow. Then we will go forward and create a PyQGIS version of the workflow.

After using the GUI, we can look up the corresponding code in the Processing history. It looks something like this:

processing.run("native:extractbyexpression",
    {'INPUT':'E:/Geodata/NaturalEarth/natural_earth_vector.gpkg|layername=ne_110m_rivers_lake_centerlines',
    'EXPRESSION':'name = \'Donau\'','OUTPUT':'memory:'})
processing.run("native:buffer",
    {'INPUT':'MultiLineString?crs=EPSG:4326&...','DISTANCE':0.1,'SEGMENTS':5,
    'END_CAP_STYLE':0,'JOIN_STYLE':0,'MITER_LIMIT':2,'DISSOLVE':False,'OUTPUT':'memory:'})
processing.run("native:extractbylocation",
    {'INPUT':'E:/Geodata/NaturalEarth/natural_earth_vector.gpkg|layername=ne_110m_populated_places',
    'PREDICATE':[0],'INTERSECT':'MultiPolygon?crs=EPSG:4326&...','OUTPUT':'memory:'})

These code snippets from the Processing history provide us with a guide to the necessary syntax but we cannot use the code directly. When we want to convert this to a script, we need to take care of handling the intermediate results. Above, these intermediate results are stored in memory layers. The memory layer resulting from Extract by attribute is passed to the Buffer tool input as 'MultiLineString?crs=EPSG:4326&...'. For our script, we need to go a different way and store a reference to the result in a variable.

The following script shows how the results of one tool can be passed to the next: in case of the tools we are using in this example, processing.run() always returns a dictionary with just one entry called 'OUTPUT'.  This way, we store the result layer of Extract by expression in the variable danube. Then we use the danube layer as an input for the buffer tool, and so on:

my_gpkg = 'E:/Geodata/NaturalEarth/natural_earth_vector.gpkg'
rivers = f'{my_gpkg}|layername=ne_110m_rivers_lake_centerlines'
places = f'{my_gpkg}|layername=ne_110m_populated_places'

expression = "name = 'Donau'"
danube = processing.run("native:extractbyexpression",
    {'INPUT':rivers,'EXPRESSION':expression,'OUTPUT':'memory:'}
    )['OUTPUT']

buffer_distance = 0.1 #degrees 

buffered_danube = processing.run("native:buffer",
    {'INPUT':danube,'DISTANCE':buffer_distance,'SEGMENTS':5,'END_CAP_STYLE':0,
    'JOIN_STYLE':0,'MITER_LIMIT':2,'DISSOLVE':False,'OUTPUT':'memory:'}
    )['OUTPUT']

places_along_danube = processing.run("native:extractbylocation",
    {'INPUT':places,'PREDICATE':[0],'INTERSECT':buffered_danube,'OUTPUT':'memory:'}
    )['OUTPUT']

QgsProject.instance().addMapLayer(places_along_danube)

for feature in places_along_danube.getFeatures():
    print(feature["name"])

Don’t worry if the syntax of some Processing tools looks a bit complex. Remember that you can look up the correct syntax for every Processing tool you’ve run through the GUI in the Processing history.

Running this script, returns us the following four cities:

Bratislava
Belgrade
Budapest
Vienna 

These are the basics of chaining Processing tools to build more complex workflows. The key is to figure out the correct syntax by examining the Processing history. Then we can store the results in variables and pass them on to successive tools. Finally, we can load the results and explore, style, or print them.

Next

PyQGIS 101 is a work in progress. I’d appreciate any feedback, particularly from beginners!