Outdated version of the documentation. Find the latest one here.

Développer des Extensions Python

Il est possible de créer des extensions dans le langage de programmation Python. Comparé aux extensions classiques développées en C++, celles-ci devraient être plus faciles à écrire, comprendre, maintenir et distribuer du fait du caractère dynamique du langage python.

Python plugins are listed together with C++ plugins in QGIS plugin manager. They’re being searched for in these paths:

  • UNIX/Mac: ~/.qgis/python/plugins et (qgis_prefix)/share/qgis/python/plugins

  • Windows: ~/.qgis/python/plugins et (qgis_prefix)/python/plugins

Home directory (denoted by above ~) on Windows is usually something like C:\Documents and Settings\(user) (on Windows XP or earlier) or C:\Users\(user). Since Quantum GIS is using Python 2.7, subdirectories of these paths have to contain an __init__.py fily to be considered Python packages that can be imported as plugins.

Étapes:

  1. Idée: Avoir une idée de ce que vous souhaitez faire avec votre nouvelle extension. Pourquoi le faites-vous? Quel problème souhaitez-vous résoudre? N’y a-t-il pas déjà une autre extension pour ce problème?

  2. Create files: Create the files described next. A starting point (__init.py__). Fill in the Métadonnées de l’extension (metadata.txt) A main python plugin body (mainplugin.py). A form in QT-Designer (form.ui), with its resources.qrc.
  3. Write code: Write the code inside the mainplugin.py
  4. Test: Fermez et ré-ouvrez QGIS et importez à nouveau votre extension. Vérifiez si tout est OK.

  5. Publish: Publish your plugin in QGIS repository or make your own repository as an “arsenal” of personal “GIS weapons”

Écriture d’une extension

Since the introduction of python plugins in QGIS, a number of plugins have appeared - on Plugin Repositories wiki page you can find some of them, you can use their source to learn more about programming with PyQGIS or find out whether you are not duplicating development effort. QGIS team also maintains an Dépôt officiel des extensions Python. Ready to create a plugin but no idea what to do? Python Plugin Ideas wiki page lists wishes from the community!

Fichiers de l’extension

Here’s the directory structure of our example plugin:

PYTHON_PLUGINS_PATH/
  MyPlugin/
    __init__.py    --> *required*
    mainPlugin.py  --> *required*
    metadata.txt   --> *required*
    resources.qrc  --> *likely useful*
    resources.py   --> *compiled version, likely useful*
    form.ui        --> *likely useful*
    form.py        --> *compiled version, likely useful*

A quoi correspondent ces fichiers?

  • __init__.py = The starting point of the plugin. It has to have the classFactory method and may have any other initialisation code.
  • mainPlugin.py = The main working code of the plugin. Contains all the information about the actions of the plugin and the main code.
  • resources.qrc = The .xml document created by QT-Designer. Contains relative paths to resources of the forms.
  • resources.py = La traduction en Python du fichier resources.qrc décrit ci-dessus.

  • form.ui = The GUI created by QT-Designer.
  • form.py = La traduction en Python du fichier form.ui décrit ci-dessus.

  • metadata.txt = Required for QGIS >= 1.8.0. Containts general info, version, name and some other metadata used by plugins website and plugin infrastructure. Since QGIS 2.0 the metadata from __init__.py are not accepted anymore and the metadata.txt is required.

Here is an online automated way of creating the basic files (skeleton) of a typical QGIS Python plugin.

Also there is a QGIS plugin called Plugin Builder that creates plugin template from QGIS and doesn’t require internet connection. This is the recommended option, as it produces 2.0 compatible sources.

Warning

If you plan to upload the plugin to the Dépôt officiel des extensions Python you must check that your plugin follows some additional rules, required for plugin Validation

Contenu de l’extension

Ici vous pouvez trouver des informations et des exemples sur ce qu’il faut ajouter dans chacun des fichiers de la structure de fichiers décrite ci-dessus.

Métadonnées de l’extension

First, plugin manager needs to retrieve some basic information about the plugin such as its name, description etc. File metadata.txt is the right place to put this information.

Important

Toutes les métadonnées doivent être encodées en UTF-8.

Nom de la métadonnée

Requis

Notes

nom

Vrai

texte court contenant le nom de l’extension

qgisMinimumVersion

Vrai

dotted notation of minimum QGIS version
qgisMaximumVersion

Faux

dotted notation of maximum QGIS version
description

Vrai

short text which describes the plugin, no HTML allowed
about

Faux

longer text which describes the plugin in details, no HTML allowed
version

Vrai

short string with the version dotted notation

auteur

Vrai

nom de l’auteur

e-mail

Vrai

e-mail de l’auteur, n’apparaîtra pas sur le site web

changelog

Faux

texte, peut être multi-lignes, pas de HTML autorisé

expérimental

Faux

indicateur booléen, Vrai ou Faux

obsolète

Faux

indicateur booléen, Vrai or Faux, s’applique à l’extension entière et pas simplement à la version chargée

tags

Faux

comma separated list, spaces are allowe inside individual tags

page d’accueil

Faux

une URL valide pointant vers la page d’accueil de l’extension

dépôt

Faux

une URL valide pour le dépôt du code source

tracker

Faux

une URL valide pour les billets et rapports de bugs

icône

Faux

un nom de fichier ou un chemin relatif (par rapport au dossier racine de l’extension, fichiers compressés)

catégorie

Faux

soit Raster, Vecteur, Base de Données ou Web

By default, plugins are placed in the Plugins menu (we will see in the next section how to add a menu entry for your plugin) but they can also be placed the into Raster, Vector, Database and Web menus.

A corresponding “category” metadata entry exists to specify that, so the plugin can be classified accordingly. This metadata entry is used as tip for users and tells them where (in which menu) the plugin can be found. Allowed values for “category” are: Vector, Raster, Database or Web. For example, if your plugin will be available from Raster menu, add this to metadata.txt:

category=Raster

Note

If qgisMaximumVersion is empty, it will be automatically set to the major version plus .99 when uploaded to the Dépôt officiel des extensions Python.

An example for this metadata.txt:

; the next section is mandatory

[general]
name=HelloWorld
[email protected]
author=Just Me
qgisMinimumVersion=2.0
description=This is an example plugin for greeting the world.
    Multiline is allowed:
    lines starting with spaces belong to the same
    field, in this case to the "description" field.
    HTML formatting is not allowed.
about=This paragraph can contain a detailed description
    of the plugin. Multiline is allowed, HTML is not.
version=version 1.2
; end of mandatory metadata

; start of optional metadata
category=Raster
changelog=The changelog lists the plugin versions
    and their changes as in the example below:
    1.0 - First stable release
    0.9 - All features implemented
    0.8 - First testing release

; Tags are in comma separated value format, spaces are allowed within the
; tag name.
; Tags should be in english language. Please also check for existing tags and
; synoninms before creating a new one.
tags=wkt,raster,hello world

; these metadata can be empty, they will eventually become mandatory.
homepage=http://www.itopen.it
tracker=http://bugs.itopen.it
repository=http://www.itopen.it/repo
icon=icon.png

; experimental flag (applies to the single version)
experimental=True

; deprecated flag (applies to the whole plugin and not only to the uploaded version)
deprecated=False

; if empty, it will be automatically set to major version + .99
qgisMaximumVersion=2.0

__init__.py

This file is required by Python’s import system. Also, Quantum GIS requires that this file contains a classFactory() function, which is called when the plugin gets loaded to QGIS. It receives reference to instance of QgisInterface and must return instance of your plugin’s class from the mainplugin.py - in our case it’s called TestPlugin (see below). This is how __init__.py should look like:

def classFactory(iface):
  from mainPlugin import TestPlugin
  return TestPlugin(iface)

## any other initialisation needed

mainPlugin.py

This is where the magic happens and this is how magic looks like: (e.g. mainPlugin.py):

from PyQt4.QtCore import *
from PyQt4.QtGui import *
from qgis.core import *

# initialize Qt resources from file resouces.py
import resources

class TestPlugin:

  def __init__(self, iface):
    # save reference to the QGIS interface
    self.iface = iface

  def initGui(self):
    # create action that will start plugin configuration
    self.action = QAction(QIcon(":/plugins/testplug/icon.png"), "Test plugin", \
      self.iface.mainWindow())
    self.action.setObjectName("testAction")
    self.action.setWhatsThis("Configuration for test plugin")
    self.action.setStatusTip("This is status tip")
    QObject.connect(self.action, SIGNAL("triggered()"), self.run)

    # add toolbar button and menu item
    self.iface.addToolBarIcon(self.action)
    self.iface.addPluginToMenu("&Test plugins", self.action)

    # connect to signal renderComplete which is emitted when canvas
    # rendering is done
    QObject.connect(self.iface.mapCanvas(), SIGNAL("renderComplete(QPainter *)"), \
      self.renderTest)

  def unload(self):
    # remove the plugin menu item and icon
    self.iface.removePluginMenu("&Test plugins",self.action)
    self.iface.removeToolBarIcon(self.action)

    # disconnect form signal of the canvas
    QObject.disconnect(self.iface.mapCanvas(), SIGNAL("renderComplete(QPainter *)"), \
      self.renderTest)

  def run(self):
    # create and show a configuration dialog or something similar
    print "TestPlugin: run called!"

  def renderTest(self, painter):
    # use painter for drawing to map canvas
    print "TestPlugin: renderTest called!"

The only plugin functions that must exist in the main plugin source file (e.g. mainPlugin.py) are:: - __init__ –> which gives access to Quantum GIS’ interface - initGui() –> called when the plugin is loaded - unload() –> called when the plugin is unloaded

You can see that in the above example, the ``:func:`addPluginToMenu`<http://qgis.org/api/classQgisInterface.html#ad1af604ed4736be2bf537df58d1399c3>`_ is used. This will add the corresponding menu action to the Plugins menu. Alternative methods exist to add the action to a different menu. Here is a list of those methods:

  • addPluginToRasterMenu()
  • addPluginToVectorMenu()
  • addPluginToDatabaseMenu()
  • addPluginToWebMenu()

Tous ont la même syntaxe que la méthode addPluginToMenu().

Ajouter votre extension dans un des menus prédéfinis est une méthode recommandée pour conserver la cohérence de l’organisation des entrées d’extensions. Toutefois, vous pouvez ajouter votre propre groupe de menus directement à la barre de menus, comme le montre l’exemple suivant:

def initGui(self):
    self.menu = QMenu(self.iface.mainWindow())
    self.menu.setObjectName("testMenu")
    self.menu.setTitle("MyMenu")

    self.action = QAction(QIcon(":/plugins/testplug/icon.png"), "Test plugin", \
      self.iface.mainWindow())
    self.action.setObjectName("testAction")
    self.action.setWhatsThis("Configuration for test plugin")
    self.action.setStatusTip("This is status tip")
    QObject.connect(self.action, SIGNAL("triggered()"), self.run)
    self.menu.addAction(self.action)

    menuBar = self.iface.mainWindow().menuBar()
    menuBar.insertMenu(self.iface.firstRightStandardMenu().menuAction(), self.menu)

def unload(self):
    self.menu.deleteLater()

Don’t forget to set QAction and QMenu objectName to a name specific to your plugin so that it can be customized.

Resource File

You can see that in initGui() we’ve used an icon from the resource file (called resources.qrc in our case):

<RCC>
  <qresource prefix="/plugins/testplug" >
     <file>icon.png</file>
  </qresource>
</RCC>

It is good to use a prefix that will not collide with other plugins or any parts of QGIS, otherwise you might get resources you did not want. Now you just need to generate a Python file that will contain the resources. It’s done with pyrcc4 command:

pyrcc4 -o resources.py resources.qrc

And that’s all... nothing complicated :) If you’ve done everything correctly you should be able to find and load your plugin in the plugin manager and see a message in console when toolbar icon or appropriate menu item is selected.

When working on a real plugin it’s wise to write the plugin in another (working) directory and create a makefile which will generate UI + resource files and install the plugin to your QGIS installation.

Documentation

La documentation sur l’extension peut être écrite sous forme de fichiers d’aide HTML. Le module qgis.utils fournit une fonction, showPluginHelp(), qui ouvrira le fichier d’aide dans un navigateur, de la même manière que pour l’aide de QGIS.

La fonction showPluginHelp`() recherche les fichiers d’aide dans le même dossier que le module d’appel. elle recherchera, dans l’ordre, index-ll_cc.html, index-ll.html, index-en.html, index-en_us.html et index.html, affichant celui qu’elle trouve en premier. Ici, ll_cc est pour la locale de QGIS. Ceci permet d’inclure des traductions multiples dans la documentation de l’extension.

The showPluginHelp() function can also take parameters packageName, which identifies a specific plugin for which the help will be displayed, filename, which can replace “index” in the names of files being searched, and section, which is the name of an html anchor tag in the document on which the browser will be positioned.