Open QGIS. Go to , or click on the hammer icon.
You will see the QGIS Plugin Builder dialog with a form. You can
fill the form with details relating to our plugin. The Class
name will be the name of the Python Class containing the logic of the
plugin. This will also be the name of the folder containing all the plugin
files. Enter SaveAttributes as the class name. The Plugin
name is the name under which your plugin will appear in the
Plugin Manager. Enter the name as Save Attributes. Add a
description in the Description field. The Module
name will be the name of the main python file for the plugin. Enter it as
save_attributes. Leave the version numbers as they are. The
Text for menu item value will be how the users will find your
plugin in QGIS menu. Enter it as Save Attributes as CSV. Enter your name
and email address in the appropriate fields. The Menu field
will decide where your plugin item is added in QGIS. Since our plugin is for
vector data, select Vector. Check the Flag the plugin as
experimental box at the bottom. Click OK.
Next, you will be prompted to choose a directory for your plugin. You need
to browse to the QGIS python plugin directory on your computer and select
Select Folder.
Note
You can always find your current profile folder by going to
Settings->User Profiles->Open active profile folder.
The plugin folder will be within the python folder.
Next, press the generate button. You will see a confirmation dialog once your plugin template is created.
Note the path to the plugin folder.
Before we can use the newly created plugin, we need to compile the
resources.qrc file that was created by Plugin Builder. Launch the
OSGeo4W Shell on windows or a terminal on Mac or Linux.
Browse to the plugin directory where the output of Plugin Builder was
created. You can use the cd command followed by the path to the
directory.
cd /home/ian/.local/share/QGIS/QGIS3/profiles/default/python/plugins/save_attributes
Once you are in the directory, type pb_tool compile. This will run the pyrcc5
command that we had installed as part of Qt bindings for Python.
Note
If you get the message the pb_tool is not found, you will need to run the
command pip install --user pb_tool to install it.
This process used to use make but that is now deprecated.
Now we are ready to have a first look at the brand new plugin we created.
Close QGIS and launch it again. Go to and enable the Save Attributes plugin in the
Installed tab. You will notice that there is a new icon
in the toolbar and a new menu entry under . Select it to launch
the plugin dialog.
You will notice a new blank dialog named Save Attributes. Close
this dialog.
We will now design our dialog box and add some user interface elements to
it. Open the Qt Designer program and to the Open….
Browse to the plugin directory and select the
save_attributes_dialog_base.ui file. Click Open.
You will see the blank dialog from the plugin. You can drag-and-drop
elements from the left-hand panel on the dialog. We will add a
Combo Box type of Input Widgets. Drag it to the
plugin dialog.
Resize the combo box and adjust its size. Now drag a Label type
Display Widget on the dialog.
Click on the label text and enter Select a layer.
Save this file by going to . Note the name of the combo box object is
comboBox. To interact with this object using python code, we will have
to refer to it by this name.
Let’s reload our plugin so we can see the changes in the dialog
window. Go to .
Select SaveAttributes in the Configure Plugin reloader
dialog.
Now click the Save Attributes as CSV button. You will see the
newly designed dialog box.
Let’s add some logic to the plugin that will populate the combo box with
the layers loaded in QGIS. Go to the plugin directory and load the file
save_attributes.py in a text editor.
First, insert at the top of the file with the other imports:
from qgis.core import QgsProject
Then scroll down to the end and find the
run(self) method. This method will be called when you click the toolbar
button or select the plugin menu item. Add the following code at the
beginning of the method. This code gets the layers loaded in QGIS and adds
it to the comboBox object from the plugin dialog.
layers = [layer for layer in QgsProject.instance().mapLayers().values()]
layer_list = []
for layer in layers:
layer_list.append(layer.name())
self.dlg.comboBox.addItems(layer_list)
Back in the main QGIS window, reload the plugin by going to
. Alternatively, you can just press F5. To test this
new functionality, we must load some layers in QGIS. After you load some
data, launch the plugin by going to .
You will see that our combo box is now populated with the layer names that
are loaded in QGIS.
Let’s add remaining user interface elements. Switch back to Qt Designer
and load the save_attributes_dialog_base.ui file. Add a Label
Display Widget and change the text to Select output file.
Add a LineEdit type Input Widget that will show the output
file path that the user has chosen. Next, add a Push Button type
Button and change the button label to .... Note the object
names of the widgets that we will have to use to interact with them. Save
the file.
We will now add python code to open a file browser when the user clicks the
... push button and show the select path in the line edit widget. Open
the save_attributes.py file in a text editor. Add QFileDialog to
QtWidgets list of imports at the top of the file.
Add a new method called select_output_file with the following code.
This code will open a file browser and populate the line edit widget with
the path of the file that the user chose. Note, how getSaveFileName
returns a tuple with the filename and the filter used.
def select_output_file(self):
filename, _filter = QFileDialog.getSaveFileName(self.dlg, "Select output file ","", '*.csv')
self.dlg.lineEdit.setText(filename)
Now we need to add code so that when the … button is clicked,
select_output_file method is called. Scroll down to the run
method and add the following line in the block starting if
self.first_start == True:. This code will connect
the select_output_file method to the clicked signal of the push
button widget.
self.dlg.pushButton.clicked.connect(self.select_output_file)
We also need to clear the file name that was used previously (if any), so
add this line above the comboBox.clear() line.
self.dlg.lineEdit.clear()
Back in QGIS, reload the plugin and open the Save Attributes`
dialog. If all went fine, you will be able to click the ... button and
select an output text file from your disk.
When you click OK on the plugin dialog, nothing happens. That
is because we have not added the logic to pull attribute information from
the layer and write it to the text file. We now have all the pieces in
place to do just that. Find the place in the run method where it says
pass. Replace it with the code below. The explanation for this code
can be found in Using the QGIS Python console (QGIS3).
filename = self.dlg.lineEdit.text()
with open(filename, 'w') as output_file:
selectedLayerIndex = self.dlg.comboBox.currentIndex()
selectedLayer = layers[selectedLayerIndex]
fieldnames = [field.name() for field in selectedLayer.fields()]
# write header
line = ','.join(name for name in fieldnames) + '\n'
output_file.write(line)
# wirte feature attributes
for f in selectedLayer.getFeatures():
line = ','.join(str(f[name]) for name in fieldnames) + '\n'
output_file.write(line)
Now our plugin is ready. Reload the plugin and try it out. You will find
that the output text file you chose will have the attributes from the
vector layer. You can zip the plugin directory and share it with your
users. They can unzip the contents to their plugin directory and try out
your plugin. If this was a real plugin, you would upload it to the QGIS
Plugin Repository so that all QGIS users will
be able to find and download your plugin.
# -*- coding: utf-8 -*-
"""
/***************************************************************************
SaveAttributes
A QGIS plugin
This plugin saves attributes of the selected layer
Generated by Plugin Builder: http://g-sherman.github.io/Qgis-Plugin-Builder/
-------------------
begin : 2019-02-26
git sha : $Format:%H$
copyright : (C) 2019 by Ian Turton, Astun Technology
email : ian@astun.com
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
"""
from PyQt5.QtCore import QSettings, QTranslator, qVersion, QCoreApplication
from PyQt5.QtGui import QIcon
from PyQt5.QtWidgets import QAction, QFileDialog
# Initialize Qt resources from file resources.py
from .resources import *
# Import the code for the dialog
from .save_attributes_dialog import SaveAttributesDialog
import os.path
from qgis.core import QgsProject
class SaveAttributes:
"""QGIS Plugin Implementation."""
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(
self.plugin_dir,
'i18n',
'SaveAttributes_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&Save Attributes')
# Check if plugin was started the first time in current QGIS session
# Must be set in initGui() to survive plugin reloads
self.first_start = None
# noinspection PyMethodMayBeStatic
def tr(self, message):
"""Get the translation for a string using Qt translation API.
We implement this ourselves since we do not inherit QObject.
:param message: String for translation.
:type message: str, QString
:returns: Translated version of message.
:rtype: QString
"""
# noinspection PyTypeChecker,PyArgumentList,PyCallByClass
return QCoreApplication.translate('SaveAttributes', message)
def add_action(
self,
icon_path,
text,
callback,
enabled_flag=True,
add_to_menu=True,
add_to_toolbar=True,
status_tip=None,
whats_this=None,
parent=None):
"""Add a toolbar icon to the toolbar.
:param icon_path: Path to the icon for this action. Can be a resource
path (e.g. ':/plugins/foo/bar.png') or a normal file system path.
:type icon_path: str
:param text: Text that should be shown in menu items for this action.
:type text: str
:param callback: Function to be called when the action is triggered.
:type callback: function
:param enabled_flag: A flag indicating if the action should be enabled
by default. Defaults to True.
:type enabled_flag: bool
:param add_to_menu: Flag indicating whether the action should also
be added to the menu. Defaults to True.
:type add_to_menu: bool
:param add_to_toolbar: Flag indicating whether the action should also
be added to the toolbar. Defaults to True.
:type add_to_toolbar: bool
:param status_tip: Optional text to show in a popup when mouse pointer
hovers over the action.
:type status_tip: str
:param parent: Parent widget for the new action. Defaults None.
:type parent: QWidget
:param whats_this: Optional text to show in the status bar when the
mouse pointer hovers over the action.
:returns: The action that was created. Note that the action is also
added to self.actions list.
:rtype: QAction
"""
icon = QIcon(icon_path)
action = QAction(icon, text, parent)
action.triggered.connect(callback)
action.setEnabled(enabled_flag)
if status_tip is not None:
action.setStatusTip(status_tip)
if whats_this is not None:
action.setWhatsThis(whats_this)
if add_to_toolbar:
# Adds plugin icon to Plugins toolbar
self.iface.addToolBarIcon(action)
if add_to_menu:
self.iface.addPluginToMenu(
self.menu,
action)
self.actions.append(action)
return action
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
icon_path = ':/plugins/save_attributes/icon.png'
self.add_action(
icon_path,
text=self.tr(u'save attributes'),
callback=self.run,
parent=self.iface.mainWindow())
# will be set False in run()
self.first_start = True
def unload(self):
"""Removes the plugin menu item and icon from QGIS GUI."""
for action in self.actions:
self.iface.removePluginMenu(
self.tr(u'&Save Attributes'),
action)
self.iface.removeToolBarIcon(action)
def select_output_file(self):
filename, _filter = QFileDialog.getSaveFileName(self.dlg, "Select output file ","", '*.csv')
self.dlg.lineEdit.setText(filename)
def run(self):
"""Run method that performs all the real work"""
# Create the dialog with elements (after translation) and keep reference
# Only create GUI ONCE in callback, so that it will only load when the plugin is started
if self.first_start == True:
self.first_start = False
self.dlg = SaveAttributesDialog()
# wire up output file button
self.dlg.pushButton.clicked.connect(self.select_output_file)
# clear previous file name
self.dlg.lineEdit.clear()
#clear the combo list of old layers
self.dlg.comboBox.clear()
# get list of layers
layers = [layer for layer in QgsProject.instance().mapLayers().values()]
layer_list = []
# add them to combo box
for layer in layers:
layer_list.append(layer.name())
self.dlg.comboBox.addItems(layer_list)
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
filename = self.dlg.lineEdit.text()
with open(filename, 'w') as output_file:
selectedLayerIndex = self.dlg.comboBox.currentIndex()
selectedLayer = layers[selectedLayerIndex]
fieldnames = [field.name() for field in selectedLayer.fields()]
# write header
line = ','.join(name for name in fieldnames) + '\n'
output_file.write(line)
# wirte feature attributes
for f in selectedLayer.getFeatures():
line = ','.join(str(f[name]) for name in fieldnames) + '\n'
output_file.write(line)
