python:wrapper [triskele]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Passerelle C++/Python ======

Cette section ne concerne que les développeurs qui souhaitent comprendre la manière dont les fonctionnalités Triskele peuvent être invoquées depuis un programme Python.

L'explication s'appuie sur un exemple d'une fonction et d'une classe écrite en C++. Les codes sources sont dans un répertoire :
|<code>
drwxr-xr-x 3 4096  build
-rw-r--r-- 1  825  CMakeLists.txt
drwxr-xr-x 2 4096  __pycache__
-rw-r--r-- 1  681  pywrapper.cpp
-rw-r--r-- 1  325  test.cpp
-rw-r--r-- 1  228  test.hpp
-rwxr-xr-x 1  336  test.py
</code> | <code>
répertoire pour créer les exécutables
Règles de fabrication des binaires
répertoire créé automatiquement par python (accélération)
code passerelle
code C++
interface C++
programme python 
</code> |

<WRAP center round download 60%>
Ensemble des sources {{ :python:boostpythontest.tgz |boostpythontest.tgz}} (5 fichiers)
</WRAP>

===== Code C++ =====

L'interface C++ est simple mais couvre plusieurs situations :
  * appel de fonction (hors classe)
  * construction d'un objet
  * surcharge de constructeur
  * accès d'attribut en lecture/écriture (par valeur et par méthode)
  * invocation de méthode

L'interface se trouve dans le fichier entête C++ (''headers'')

{{ :python:test.hpp |}}
<code c++>
#include<string>

using namespace std;
</code>
Déclaration d'une fonction
<code c++>
string getMsg ();
</code>
Déclaration d'une classe
<code c++>
class Mem {
private:
  string msg;

public:
  int id;

  Mem (string msg);
  Mem (string msg, int id);
  virtual ~Mem ();

  void set (string msg);
  string get ();
};
</code>

Le programme proprement dit (les données initiales et le comportement) se trouve dans un fichier ''cpp''.

{{ :python:test.cpp |}}
<code c++>
#include <iostream>

#include "test.hpp"
</code>
La trace sera affichée au moment de l'appel dans l'environnement C++.
<code c++>
string
getMsg () {
  cerr << "coucou" << endl;
  return "hello, world";
}
</code>
Exemple de constructeurs surchargés.
<code c++>
Mem::Mem (string msg)
  : Mem (msg, 0) {
}

Mem::Mem (string msg, int id)
  : msg (msg), id (id) {
}

Mem::~Mem () {
}
</code>
Les accesseurs pour être utilisés pour simuler l'accès à un attribut python.
<code c++>
void
Mem::set (string msg) {
  this->msg = msg;
}

string
Mem::get () {
  return msg;
}
</code>

===== Code Python =====

La première ligne permet de sélectionner le bon interpréteur.

{{ :python:test.py |}}
<code python>
#! /usr/bin/python3
</code>
Le nom du module correspond au nom de fichier suivi de l'extension ''.so''.
<code python>
from libtest import getMsgPy, MemPy
</code>
Appel d'une fonction
<code python>
print (getMsgPy ())
</code>
Création d'un objet C++ avec appel de constructeur.
<code python>
word = MemPy ('A')
</code>
Liaison lecture/écriture d'un attribut.
<code python>
word.id = 1;
print (f"m:{word.getPy ()} id:{word.idPy}")
word.setPy ('B')
print (f"m:{word.getPy ()} id:{word.idPy}")

word2 = MemPy ('C', 1)
print (f"m:{word2.getPy ()} id:{word2.idPy}")
</code>
Utilisation des accesseurs.
<code python>
word2.msgPy = word.msgPy+"2"
print (word2.msgPy)
</code>

===== Passerelle =====

La liaison ce fait grâce à la bibliothèque Boost avec un ensemble de déclarations.

{{ :python:pywrapper.cpp |}}
<code c++>
#include <boost/python.hpp>

#include "test.hpp"

using namespace boost::python;
</code>
''libtest'' est le nom du fichier sans l'extension ''.so''. Si l'on fait deux bibliothèques (par exemple ''libtest.so'' et ''libtestdebug.so''), il faudra deux déclarations.
<code c++>
BOOST_PYTHON_MODULE (libtest) {
</code>
Le nom entre guillemets est l'identifiant utilisé dans le programme python. Il peut être le même qu'en C++, mais ici cela permet de montrer la différence entre le contexte C++ et Python.
L'identifiant ''getMsg'' est directement un pointeur sur la fonction.
<code c++>
  def ("getMsgPy", getMsg);
</code>
La déclaration d'un constructeur est optionnelle.
<code c++>
  class_<Mem> ("MemPy", init<string>())
</code>
On peut même ajouter la déclaration d'autres constructeurs.
<code c++>
    .def (init<string, int>())
</code>
Comme l'invocation de la méthode ''.def'' retourne un pointeur sur le même objet, on peut faire une cascade d'appel (il ne faut pas de ";" entre chaque).
Un pointeur sur un membre (ici une méthode) de la classe ''Men'' permet la liaison avec le code C++.
<code c++>
    .def ("getPy", &Mem::get)
    .def ("setPy", &Mem::set)
</code>
La liaison entre l'identifiant Python et l'homologue C++ permet d'utiliser la variable Python à droite ou à gauche d'un signe égale (on dit ''leftvalue'' lorsque l'on peut affecter une valeur)
<code c++>
    .def_readwrite ("idPy", &Mem::id)
</code>
Ici on a recours à des accesseurs.
Il faudra ne pas oublier le ";" pour clore la série de déclaration.
<code c++>
    .add_property ("msgPy", &Mem::get, &Mem::set)
    ;
}
</code>

===== Compilation =====

Pour simplifier la création de la librairie C++ qui sera vu comme un module Python, nous avons utilisé ''cmake''.

{{ :python:cmakelists.txt |}}
<code cmake>
cmake_minimum_required (VERSION 3.5)
set (PROJ_NAME "test")
project (${PROJ_NAME})
set (CMAKE_CXX_STANDARD 11)
set (CXX_STANDARD_REQUIRED ON)
</code>

<WRAP center round important 60%>
Il est important de produire une bibliothèque dynamique (''SHARED'') pour qu'elle soit chargée à la volée dans l'environnement Python.
</WRAP>
<code cmake>
set (BUILD_SHARED_LIBS ON)
</code>
Nous allons dépendre d'autres bibliothèques.
<code cmake>
find_package (PythonLibs 3 REQUIRED)
find_package (Boost REQUIRED python3 system chrono)
</code>
Nous créons une liste de sources pour constituer notre bibliothèque.
<code cmake>
list (APPEND libTestSrc
  "test.cpp"
  "pywrapper.cpp"
  )
</code>
Répertoire où l'on trouve les entêtes nécessaires à la compilation.
<code cmake>
include_directories (
  PUBLIC
  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
  ${Boost_INCLUDE_DIRS}
  ${PYTHON_INCLUDE_DIRS}
  )
</code>
Compilation de tous les modules C++ et préparation de l'archive.
<code cmake>
add_library (test SHARED
  ${libTestSrc}
  )
</code>
<WRAP center round important 60%>
Cette directive est indispensable. Sans quoi, on aura l'illusion que tout est fait, mais au moment du chargement du module par python, il ne sera pas trouver les dépendance. Il faudrait alors charger dans l'environnement python les autres bibliothèques (Boost, pythonLib).
</WRAP>
<code cmake>
target_link_libraries (test
  ${PYTHON_LIBRARIES}
  ${Boost_LIBRARIES}
  )
</code>

Installation du package ''libboost-python-dev''.
<code bash>
sudo apt-get install -y libboost-python-dev
</code>

Nous allons créer les binaires dans un sous-répertoire ''build''.
<code bash>
mkdir build/
cd build/
cmake ..
make -j $(nproc)
</code>

<WRAP center round important 60%>
L'interpréteur va rechercher les modules python à importer (des bibliothèques dynamiques) en fonction d'un chemin qui peut contenir des répertoires relatifs ou absolus.
</WRAP>
Nous avons indiqué "." car nous exécutons le programme dans le sous-répertoire. Si nous avions exécuté depuis l'endroit où se trouve le programme Python, il aurait fallu indiquer "./build/".
<code bash>
export PYTHONPATH=".:/usr/local/lib/python3/"
</code>

Nous pouvons explicitement rendre le programme python exécutable et l'invoquer.
<code bash>
chmod a+x ../test.py
../test.py 
</code>
Voici le résultat en commençant par la trace réalisée dans l'environnement C++.
<code bash>
coucou
hello, world
m:A id:0
m:B id:0
m:C id:1
B2
</code>
Sidebar

User Tools

Site Tools

Page Tools
