Algo de flot - Un peu d'historique

Extrait de l'introduction de "New Distance-Directed Algorithms for Maximum Flow and Parametric Maximum Flow Problems"

The maximum flow problem is one of the most fundamental network problems and has been investigated extensively in the literature (for example, by Ford and Fulkerson 1956, Dinic 1970, Edmonds and Karp 1972, Karzanov 1974, Cherkasky 1977, Malhotra et. al 1978, Galil 1980, Galil and Naamad 1980, Sleator and Tarjan 1983, Gabow 1985, Goldberg 1985, Goldberg and Tarjan 1986, Ahuja and Orlin 1987). Efficient algorithms for computing maximum flows are important not only because they are applied directly to the analysis of traffic or communication networks, but are often employed in the subproblems of other network problems. Some of the network problems whose algorithms use the maximum flow algorithm as a subroutine are the time-cost tradeoff problem in CPM networks (Fulkerson 1961, Kelley 1961), the parametric network feasibility problem (Minieka 1972), the network design problem (Hu 1974) and the minimax transportation problem (Ahuja 1986). Moreover, it plays an important role in solving the minimum cost flow problem (Rock 1980, Tardos 1985, Bland and Jensen 1985). Recently, Goldberg and Tarjan (1987) have developed the fastest known algorithm for the minimum cost flow problem using an extension of their maximum flow algorithm as a major subroutine.


Ford and Fulkerson (1956) formulated the maximum flow problem and solved it using their augmenting path algorithm. Edmonds and Karp (1972) showed that by augmenting flows along shortest paths, the augmenting path algorithm runs in time O(nm 2 ) on networks with n nodes and m arcs. Independently, Dinic (1970) suggested an O(n 2 m) algorithm which proceeds by constructing shortest path networks (known as layered networks) and establishing blocking (or maximal) flows in these networks. Dinic's algorithm has been studied extensively by researchers who dramatically improved its worst case running time using sophisticated data structures. Most notable among these improvements is the 'dynamic trees' algorithm Their algorithm runs in O(nm log n) developed by Sleator and Tarjan (1983). steps. Gabow's (1985) scaling algorithm also uses Dinic's algorithm as a major subroutine.


Recently, Goldberg (1985) and Goldberg and Tarjan (1986) developed a new approach to solve the maximum flow problem that does not construct layered networks but instead maintains "distance labels". Informally, a distance label of a node is an integral lower bound on the length of the shortest augmenting path from that node to the sink. A distance label is called exact if it equals the length of the shortest augmenting path, and approximate otherwise. Distance labels have several advantages over layered networks. They are simpler to understand, easier to manipulate and have led to more efficient algorithms. We refer to algorithms that utilize distance labels as distance-directed algorithms. Goldberg (1985) developed the first distance-directed algorithm. Subsequently, Goldberg and Tarjan (1986) developed improved distance-directed algorithms. Currently, the fastest algorithm to solve the maximum flow problem, due to Ahuja and Orlin (1987a), is also a distance-directed algorithm. Its running time is O(nm + n 2 log U) steps, where U is an upper bound on the capacities of arcs directed from the source. So far all the proposed distance-directed algorithms have been preflow based algorithms, similar in essence to Karzanov's (1974) algorithm.

Installation d'une plateforme de dev MSYS-MinGW

En quelques points résumés, la facon d'installer un environnement de développement complet sur windows..

1.Procédure d'installation d'une plateforme de développement MSYS/MINGW

Installation de MingGW
URL : http://www.mingw.org
Fichier : MinGW-3.1.0-1.exe
Folder : X:\mingw

Installation MSYS
URL : http://www.mingw.org
Info : Environnement posix sous win32 pour execution de script. Repose sur MingW
Fichier : MSYS-1.0.10.exe
Folder : X:\msys

Installation de MSYS Developer Tool Kit
URL : http://www.mingw.org/
Info : Divers outils supplémentaires dont automake, autoconf, libtool, autogen, guile, cvs, openssl, openssh, inetutils,perl ..
Fichier : msysDTK-1.0.1.exe
Folder : X:\msys

2.Exemple d'IDE Open-Source

Bloodshed Dev-C++
URL : http://www.bloodshed.net/devcpp.html
Fichier : devcpp-4.9.9.2_nomingw_setup.exe

3.Ressources

Mingw32 packages repository
URL : https://sourceforge.net/projects/mingwrep/
Info : Packages de librairies open-source compilées pour MinGW

GnuWin32
URL : http://gnuwin32.sourceforge.net/
Info : Fournit Win32 (MS Windows 95 / 98 / ME / NT / 2000 / XP) ports of tools with a GNU or similar open source license.

4.Divers

Chemin de recherche de gcc sous msys-mingw:
gcc -print-search-dirs

Python Distutils

 

Un résumé de comment utiliser le module distutils..
Python 2.4

EN COURS DE REDACTION

 

1.Afficher la liste des commandes distutils disponibles

python setup.py --help-commands

  build                  build everything needed to install
  build_py       "build" pure Python modules (copy to build directory)
  build_ext       build C/C++ extensions (compile/link to build directory)
  build_clib       build C/C++ libraries used by Python extensions
  build_scripts "build" scripts (copy and fixup #! line)
  clean             clean up output of 'build' command

  install                     install everything from build directory
  install_lib              install all Python modules (extensions and pure Python)
  install_headers   install C/C++ header files
  install_scripts     install scripts (Python or otherwise)
  install_data       install data files

  sdist            create a source distribution (tarball, zip file, etc.)
  
  bdist               create a built (binary) distribution
  bdist_dumb*   create a "dumb" built distribution
  bdist_rpm*     create an RPM distribution
  bdist_wininst* create an executable installer for MS Windows
* On utilisera plutot la commande --format adjointe à bdist ou sdist

  register         register the distribution with the Python package index

2.Créer un package pour distribuer un module sous forme dite *binaire*

Commandes :
python setup.py --bdist         ( format par défaut fichier zip )
python setup.py --bdist --formats=zip        fichier zip
python setup.py --bdist --formats=wininst fichier windows installer

Liste des formats de distributions :
python setup.py --bdist --help-formats

3.Créer un package pour distribuer les sources d'un module

Commandes :
python setup.py --sdist         ( format par défaut fichier zip )
python setup.py --sdist --formats=zip        fichier zip
python setup.py --sdist --formats=wininst fichier windows installer

Liste des formats de distributions :
python setup.py --sdist --help-formats

Résultat :
Une arborescence contenant les sources du module

manifest (log d'exécution de la commande sdist)
dist\name-version\
                       package1\ (les différents packages embarqués)
                       package2\
                       PKG-INFO (fichier d'information constitué d'infos de setup.py)
                       setup.py (le fichier setup.py qui a été exécuté)
                       readme.txt (copie d'un fichier readme.txt si présent au meme niveau que setup.py)

Remarques :
- La commande sdist ne prend pas en compte les fichiers déclarés dans data_files

 

Le fichier setup.py des différents cas

from distutils.sysconfig import *
from distutils.core import setup
from glob import glob
import os
import sys




setup(name="VoileIRC-API",
version="0.36",
description="VoileIRC Packaging : API IRC",
author="NoMorgan",
author_email=nomorgan@toto.com,
url=http://www.toto.net/corailnumerique,
packages=["voileirc","voileirc.config","voileirc.error","voileirc.event","voileirc.irc",
"voileirc.log","voileirc.net","voileirc.security","voileirc.tools",
"voileirc.web","voileirc.ia"],
package_dir={"voileirc":"voileirc"},
data_files=[(get_python_lib().split(sys.prefix)[1] + "\\voileirc", ['voileirc/README.txt']), (get_python_lib().split(sys.prefix)[1] + "\\voileirc\\data", ['voileirc/data/log.ini','voileirc/data/test.xml'])] )

packages : Liste des modules et sous-modules concernés par la commande
package_dir : chemin depuis le répertoire courant, c-a-d celui où se trouve setup.py, pour trouver les différents modules cités dans packages. Si certains sont des sous-modules, il n'est nécessaire que de préciser le chemin du module parent.
data_files : Liste de fichiers considérés comme des données du module. (par exemple : fichier image, xml ..)

PaP - Créer un client d'un WebService sous forme d'objet COM en VB.NET

[- Avec une utilisation minimale de Visual Studio.Net] [- Il est conseillé d'utiliser la console lancée depuis "Invite de commandes Visual Studio.Net", car les variables d'environnement sont configurées (path,etc..)] Objectif : créer un composant COM grâce à VB.NET jouant le rôle du client du webservice 1.Environnement URL du fichier descriptif (fichier wsdl) du webservice: http://www.site.com:8080/mywebservice?wsdl 2.Génération d'une classe "proxy" en vb.net Cette classe jouera de rôle entre l'application utilisatrice du composant COM et le WebService. En mode console, utilisation de l'outil du SDK.Net nommé "wsdl" : wsdl /language:VB /out:ProxyWebService.vb http://www.site.com:8080/mywebservice?wsdl /language:VB -> génération d'une classe en VB.NET /out:ProxyWebService.vb -> nom du fichier généré Si pour une raison de configuration de proxy, vous obtenez un message d'erreur, recopiez le fichier wsdl en local avec l'extension .wsdl et utilisez : wsdl /language:VB /out:ProxyWebService.vb C:\dev\fichierWSDL.wsdl 3.Création d'un objet COM en VB.NET Suivre l'article suivant : [PaP - Objet COM en VB.NET] Sauf pour les étapes 3,4,6,7 étape 3 : Importer - Ajouter au début de maClasse.vb (avant le namespace) Imports Microsoft.VisualBasic Imports System Imports System.ComponentModel Imports System.Diagnostics Imports System.Web.Services Imports System.Web.Services.Protocols Imports System.Xml.Serialization (en réalité ceux qui sont dans ProxyWebService.vb) étape 4 : Méthodes - Modifier la déclaration de la classe maClasse En ajoutant tous les attributs de la classe ProxyWebService ainsi que la déclaration de son héritage à la classe maClasse Conserver : ComClass(maClasse.ClassId, maClasse.InterfaceId, maClasse.EventsId) Ex : <System.Diagnostics.DebuggerStepThroughAttribute(), _ System.ComponentModel.DesignerCategoryAttribute("code"), _ System.Web.Services.WebServiceBindingAttributeName:="WSSoapBinding", [Namespace]:=http://www.no.com/ws), _ System.Xml.Serialization.SoapIncludeAttribute(GetType(Attribute)), _ ComClass(maClasse.ClassId, maClasse.InterfaceId, maClasse.EventsId)> Public Class maClasse Inherits System.Web.Services.Protocols.SoapHttpClientProtocol .... End Class - Insérer les méthodes de la classe ProxyWebService dans maClasse - Insérer dans le namespace monNamespace du fichier maClasse.vb, les éventuelles autres classes du fichier ProxyWebService.vb directement en dessous de la classe maClasse - Si une configuration de proxy web est nécessaire Dans la méthode New() : (ou dans une méthode Init(..) qqconque) Dim URLToByPass() As String = {".*"} ' RegExp d'URL ne devant pas passer par le proxy Dim objProxy As New System.Net.WebProxy("http://proxy:81/", True, URLToByPass) ' l'argument 'True' indique que les adresses locales ne doivent pas passer par le proxy. Malgrè tout il vaut mieux quand même préciser URLToByPass objProxy.Credentials = System.Net.CredentialCache.DefaultCredentials Me.Proxy = objProxy étape 6 : Importer - Au début du fichier Assembly.vb,ajouter Imports System Imports System.Attribute Imports System.Reflection Imports System.Runtime.InteropServices étape 7 : Compiler la DLL - En mode console, en se plaçant dans le répertoire du projet set assemblies=System.Web.Services.dll,System.Xml.dll,System.dll[etc..] mettre ici toutes les autres références éventuellement nécessaires Il faut déterminer dans quelle DLL sont incluses les déclarations de type Import. On peut se servir de Visual Studio par exemple, en ajoutant une référence à la bibliothèque importer (menu "Références" dans l'explorateur de solutions) et consulter la propriété "Chemin d'accès". - Compilation : vbc *.vb /out:bin\nomFichier.dll /target:library /r:%assemblies%

Installation et Utilisation de Installer5 (packaging Py/Win)

 

Installer 5 permet de créer un executable à partir de sources python. Il crée un .exe à partir des sources d'un projet.

Il réunit ainsi dans un répertoire :
* un fichier .exe contenant les sources compilées
* le fichier python22.dll
* les différents fichiers .pyd (lilbrairie dynamique python) employés par le projet

[rédigé avec les versions Installer 5b4 et python 2.2.1]

1. Download l'archive installer5b4 à http://www.mcmillan-inc.com/installer_dnld.html

2. La décompresser dans un répertoire ex: c:\dev\installer

3. En mode console, se placer dans c:\dev\installer

4. Création d'un fichier .spec, contenant les détails du projet à packager.

Code:

makespec.py c:\projet\fichier_principal.py

notes:
- lors de la création du .spec, les sources n'ont pas besoin d'avoir été compilées, installer se charge de les compiler
- le fichier_principal est celui qui doit contenir le point d'entrée de l'application

5. Création du package (répertoire contenant le .exe, la DLL python et les .pyd).

Code:

build.py fichier_principal\fichier_principal.spec

notes:
- un répertoire du nom du fichier source principal a été crée dans c:\installer
- le répertoire fichier_principal\dist+fichier_principal\ contient tous les fichiers nécessaires à une installation de l'application sur un poste windows quelconque

Divers 2004 - Python

Module re (Regular Expression) - Search vs Match

"Python offers two different primitive operations based on regular expressions: match and search. If you are accustomed to Perl's semantics, the search operation is what you're looking for. See the search() function and corresponding method of compiled regular expression objects.

Note that match may differ from search using a regular expression beginning with "^": "^" matches only at the start of the string, or in MULTILINE mode also immediately following a newline. The ``match'' operation succeeds only if the pattern matches at the start of the string regardless of mode, or at the starting position given by the optional pos argument regardless of whether a newline precedes it. "

La différence entre match et search réside dans l'emploi de ^ et sa signification. Search considère que "^" représente le début de toutes les lignes. Match considère que "^" représente uniquement le premier caractère de la chaine à analyser et non le premier caratère de chaque nouvelle ligne.

Illustration :

Code:

>>> re.compile("^a",re.M).match("\na") # echec >>> re.compile("^a",re.M).search("\na") # success >>> re.compile("^a",re.M).match("toto\nabc") # echec >>> re.compile("^a",re.M).search("toto\nabc") # succes - ici search est valide car "^" indique pour lui le début de n'importe qu'elle nouvelle ligne

Si on précise une position de départ d'analyse dans la chaine, cette position de départ est représentée par "^", dans ce cas match considére que le premier caractère est celui possédant comme index la position

Illustration :

Code:

>>> re.compile("^bonjour",re.M).match("salut\nbonjour\ntout le monde") # echec >>> re.compile("^bonjour",re.M).match("salut\nbonjour\ntout le monde",6) # success - la position 6 est le \n

[note:re.compile(RegExp).match(Expression a tester, pos debut de test, pos fin)]

Exemples de la documentation :

Code:

re.compile("a").match("ba", 1) # succeeds re.compile("^a").search("ba", 1) # fails; 'a' not at start re.compile("^a").search("\na", 1) # fails; 'a' not at start re.compile("^a", re.M).search("\na", 1) # succeeds re.compile("^a", re.M).search("ba", 1) # fails; no preceding \n

Autres exemples :

Code:

>>> re.compile("toto\n^a",re.M).match("toto\nabc") # succes

Exemples d'utilisation de variable :

Code:

>>> re.match("(?P<name>.+) (?!(?P=name))","55 55") # echec >>> re.match("(?P<name>.+) (?!(?P=name))","55 56") # succes

Méthodes Statiques

A partir de la version 2.2, python gère les méthodes statiques via la fonction staticmethod() :

Code:

class C: def foo(x, y): print "staticmethod", x, y foo = staticmethod(foo) C.foo(1, 2)

Traitements sur List ou Tuple

Pour appliquer un traitement à tous les éléments d'une liste, ou d'un tuple, et celà, récursivement.

exemple:
on veut multiplier par deux toutes les valeurs de l
l = [1 , [ 4 , 3 ] , 2 , [ [3,9],8] ]
l = [2 , [ 8 , 6 ] , 4 , [ [6,18],16] ]

fonction récursive de parcours :

Code:

def function(sequence): if (type(sequence) is list) or (type(sequence) is tuple): index = 0 for val in sequence: function(val) pass else: print sequence # traitment pass pass

fonction récursive pour modifier tous les éléments :
(attention, seul le type list peut être modifié en python)

Code:

def function(sequence): if (type(sequence) is list): index = 0 for val in sequence: sequence[index] = function(val) index = index + 1 pass return sequence else: return sequence * 2# traitment pass pass

SGBDR et SGBDOO en Python

SGBDR écrit en Python :
Gadfly
l'enregistrement direct d'objets pythons en base, avec construction automatique d'une table mappant l'objet en question

SGBDOO Python :
Durus - Systeme de Persistance d'objet et Transaction
ZODB - Idem en plus avancé, utilisé dans Zope

Liens

Site officiel
http://www.python.org

Plusieurs liens python
http://www.python-eggs.org/links.html

Packaging de script python sous Windows
http://www.mcmillan-inc.com/install5_ann.html
http://starship.python.net/crew/theller/py2exe/

IDE Performant - HAP Python Remote Debugger
http://hapdebugger.sourceforge.net/

Psyco - optimiser lexecution dun code python
"Psyco is a specializing compiler for the Python language"
http://psyco.sourceforge.net/

Pyrex - permet d'écrire des extensions a python compilées en C
"A Language for Writing Python Extension Modules"
http://www.cosc.canterbury.ac.nz/~greg/python/Pyrex/

Plex - Module python implémentant GNU Flex (=Lex) - Analyseur lexical
http://www.cosc.canterbury.ac.nz/~greg/python/Plex/

"The Biopython Project is an international association of developers of freely available Python tools for computational molecular biology"
http://www.biopython.org/

Python Performance Tips
http://manatee.mojam.com/~skip/python/fastpython.html

SciPy
"Python for Scientific Computing Workshop"
http://www.scipy.org/

Numerical Python
"Numerical Python adds a fast, compact, multidimensional array language facility to Python"
http://pfdubois.com/numpy/

[Intégration autres langages]
Weave - "a Tool for Inline C/C++ in Python"
http://www.scipy.org/site_content/weave
PyInline - "Inline for Python"
http://pyinline.sourceforge.net/

[Crypto]
*Eric A. Young
http://www.python.org/workshops/1995-12/papers/kuchling.html
*PyCrypto
http://www.amk.ca/python/code/crypto.html
et http://www.amk.ca/python/writing/pycrypt/ (doc. complète sur la cryptologie)

[Framework Jeux]
PyGame
http://www.pygame.org/
PyKyra
http://sourceforge.net/projects/kyra

PythonWare Daily Python-URL (WebLOG Dev Python)
http://www.pythonware.com/daily/

Etendre le langage Python

Introduction
Il s'agit là d'étendre le langage en lui rattachant de nouveaux types de données, de nouvelles fonctionnalités, de nouveaux modules.

Pour celà, deux facons:

Il suffit de créer un module en langage python et de placer les fichiers .py dans le repertoire /lib de python.
Dans certains cas, cette méthode peut être limitée.

Il s'agit cette fois d'écrire des fonctionnalités, des nouveaux types de données ... en C ou C++. Dans ce cas là, on passe par la librairie python, qui représente le coeur du langage.

C'est la deuxième méthode qui est détaillée ici.

En employant le C/C++ pour intégrer de nouvelles fonctionnalités à python, on va développer des modules statiques ou dynamiques

L'écriture de ces modules se base sur la librairie python livrée avec le langage. On utilise alors des fonctions, macros et constantes définies dans cette librairie.
(Lot d'éléments commencant par py, API Doc à http://www.python.org/doc/current/api/api.html)

Module dynamique :
Il faut ici compiler le nouveau module sous forme de shared object (.so) pour Unix ou de DLL pour Windows.

Je ne traite ici que de la compilation de module dynamique pour windows.
Il s'agit de créer des fichiers .pyd, sorte d'équivalent aux DLLs.
L'exemple suivant se base sur un environnement MinGW (GNU Win32) et python2.2.1 pour windows.
(Se reporter à la configuration d'une plateforme GNU Win32,
si vous désirez compiler des .pyd en environnement de developpement Visual Studio 6, et non GNU Win32, se reporter a la documentation livrée avec python)

A.La librairie python

Pour tout développement sur un environnement MinGW (gnu win32) il faut d'abord effectuer un travail préliminaire sur la librairie python. Elle contient le code compilé de l'interpréteur. Cette librairie a été écrite en C. Sur un syteme windows, elle se présente sous la forme de 3 fichiers
* system\python22.dll (librairie dynamique systeme)
* c:\python22\include\python.h (include à utiliser dans les modules)
* c:\python22\libs\python.lib (librairie statique)
Elle est directement exploitable avec Visual Studio, mais pour MinGW il nous faut obtenir les équivalents de ces fichiers.

1.Localiser le fichier python22.dll sur le syteme windows (en général dans \system32\)
2.Copier la dll dans un répertoire c:\lib
3.Lancer un mode console (ne pas oublier davoir régler le path pour la plateforme GNU)
4.Se placer dans le repertoire c:\lib
5.Utiliser pexports pour créer le fichier .def

Code:

pexports python22.dll >python22.def

6.Utiliser dlltool pour créer le fichier .a

Code:

dlltool --dllname python22.dll --def python22.def --output-lib libpython22.a

B.Réalisation d'un module

1.Création du fichier source
Le fichier source C/C++ doit contenir les différents éléments du module. Il doit se baser sur les fonctions, macros et constantes de python définis dans python.h (tout ce qui commence par Py).

Donc premier cas : Utiliser les fonctions C/C++ de la librairie python (de python.h). Et écrire entièrement le module. Ca sera le cas de l'exemple plus bas.

On peut ici utiliser un scrypt python qui, une fois paramétrer, va nous créer un fichier.c contenant toutes les déclarations nécessaires en exploitant les éléménts Py. Il génère en fin de compte un squelette vide, dans lequel il ne reste plus qu'a déposer le code C/C++.
Il s'agit de modulator.py et se trouve dans l'arborescence CVS des sources pythons à python\dist\src\Tools\modulator.

Deuxième cas : Compiler sous forme de module du code C/C++ déja existant. Il faut ici créer un wrapper du code existant. En général on utilise des outils se chargeant de ce travail.

Comme SWIG (http://www.swig.org). Il génère un fichier intermédiaire en analysant le code source C/C++ existant et y crée des fonctions qui vont faire appel à ce meme code source. SWIG est un générateur de wrapper. (Il supporte d'autres langagaes que python, comme perl ou ruby)

On peut aussi employer la librairie Boost.python, ( http://www.boost.org ) qui est une librairie C++ comprenant des classes et méthodes pour écrire à la main un wrapper.

Exemple 1er cas : Fichier C, représentant le module "myexemple" contenant une fonction "systeme" :

Code:

#include <Python.h> static PyObject * myexemple_system(PyObject *self, PyObject *args) {     char *command;     int sts;     if (!PyArg_ParseTuple(args, "s", &command))         return NULL;     sts = system(command);     return Py_BuildValue("i", sts); } static PyMethodDef SpamMethods[] = {      {"system",  myexemple_system, METH_VARARGS,      "Execute une commande shell."},      {NULL, NULL, 0, NULL}        /* Sentinel */ }; void initmyexemple(void) {     (void) Py_InitModule("myexemple", SpamMethods); }

2.Compilation de myexemple.c

Code:

gcc -g -Wall -I c:\python22\include -fpic -c myexemple.c

Un fichier myexemple.o est alors généré. Pour chaque include que le fichier source utilise en plus de python.h, rajouter

Code:

-I rep_include

3.Compilation en module dynamique
En deux étapes:

* Génération d'un fichier .def
Tout d'abord créer dans le meme repertoire que myexemple.o, un fichier myexemple.def contenant :

Code:

EXPORTS    initmyexemple

* Compilation du fichier .pyd

Code:

dllwrap --dllname myexemple.pyd --driver-name gcc --def myexemple.def -o myexemple.pyd myexemple.o -s --entry _DllMain@12 --target=i386-mingw32 -Lc:\lib -lpython22

Un fichier myexemple.pyd est alors généré. Pour chaque librairie utilisée en plus de celle de python, placer son chemin dans l'argument -L et le nom de la librairie avec -l.
Par exemple, pour c:\dev\lib\libmonfichier.a :

Code:

-Lc:\dev\lib -lmonfichier

4.Déploiement
Il suffit de copier le fichier myexemple.pyd dans c:\python22\DLLs. Pour le tester en mode console, essayer :

Code:

import myexemple

Module statique :

Il faut recompiler l'interpréteur lui-même en meme temps que le nouveau module. On utilise cette façon de procéder quand on veut intégrer définitivement le module à python. Ou encore sur un systeme d'exploitation ne supportant pas le chargement dynamique.
Il faut alors placer le fichier .C contenant le code source du module dans Modules/ directory et modifier le fichier de configuration Modules/Setup.local en ajoutant la ligne

Code:

nom_module nom_fichier.o

.
(pour chaque librairie utilisée, ajouter à la ligne -lmalib)
Il reste à relancer la compilation de l'interpréteur par un make

Ressources Webs :
Instructions for Python Extensions with GCC/mingw32

 

Intégration de code c inline dans un code python

 

Introduction

Il est possible avec certains modules comme PyInline ou Weave d'intégrer du code d'autres langages à l'intérieur même du code python.

Il est en fait compilé en direct à l'intérieur du code python. Il faut évidement avoir présent sur la machine un compilateur du langage concerné. (Pour le C, en environnement Windows, VC++6.0 fonctionne tel quel).

Analyse de performance de code "inline":
http://www.scipy.org/site_content/weave/python_performance.html

Test simple avec InLine

Environnement:
-Microsoft Visual C++ 6.0 installé
-Python 2.3 installé

Installation:
-dl package PyInline 0.03 sur http://sourceforge.net/project/showfiles.php?group_id=34103&release_id=50179
-lancer python setup.py install

Test:
-dans l'interpréteur python:

>>> import PyInline >>> m= PyInline.build(code="""         ... int my_add(int a,intb) {         ...    return a+b;         ... }         ... """,language="C") running build running build_ext building '_PyInline_de9a14d2a39aa28e67cab7f2a2a9727d' extension creating build creating build\temp.win32-2.3 creating build\temp.win32-2.3\Release C:\Program Files\Microsoft Visual Studio\VC98\BIN\cl.exe /c /nologo /Ox /MD /W3 /GX /DNDEBUG -IC:\Python23\include -IC:\Python23\PC /Tc_PyInline_de9a14d2a39aa28 e67cab7f2a2a9727d.c /Fobuild\temp.win32-2.3\Release\_PyInline_de9a14d2a39aa28e67 cab7f2a2a9727d.obj _PyInline_de9a14d2a39aa28e67cab7f2a2a9727d.c creating build\lib.win32-2.3 C:\Program Files\Microsoft Visual Studio\VC98\BIN\link.exe /DLL /nologo /INCREME NTAL:NO /LIBPATH:C:\Python23\libs /LIBPATH:C:\Python23\PCBuild /EXPORT:init_PyIn line_de9a14d2a39aa28e67cab7f2a2a9727d build\temp.win32-2.3\Release\_PyInline_de9 a14d2a39aa28e67cab7f2a2a9727d.obj /OUT:build\lib.win32-2.3\_PyInline_de9a14d2a39 aa28e67cab7f2a2a9727d.pyd /IMPLIB:build\temp.win32-2.3\Release\_PyInline_de9a14d 2a39aa28e67cab7f2a2a9727d.lib    Creating library build\temp.win32-2.3\Release\_PyInline_de9a14d2a39aa28e67cab 7f2a2a9727d.lib and object build\temp.win32-2.3\Release\_PyInline_de9a14d2a39aa2 8e67cab7f2a2a9727d.exp >>> m.my_add(3,8) 11

Compilation de la librairie ming (librairie flash) pour python

 

Ming est une librairie de génération de fichier flash.

[rédigé pour les versions suivantes : ming 0.2a et python2.2.1]
A.préalable
1.installer une plateforme GNU pour windows, voir article précédent
2.downloader la librairie ming (http://ming.sourceforge.net/)
3.la décompresser dans un repertoire de travail ex c:\ming


B.creation des librairies pour unix de python a partir des librairies windows
1.localiser le fichier python22.dll sur le syteme windows (en général dans \system32\)
2.copier la dll dans c:\ming\py_ext
3.lancer un mode console (ne pas oublier davoir régler le path pour la plateforme GNU)
4.se placer dans le repertoire c:\ming\py_ext
5.utiliser pexports pour créer le fichier .def

Code:

pexports python22.dll >python22.def

6.utiliser dlltool pour créer le fichier .a

Code:

dlltool --dllname python22.dll --def python22.def --output-lib libpython22.a

C.paramétrage de la compilation de ming
(les fichiers makefile sont tres mal fait, on les réorganise pour les utiliser dans le cas qui nous interresse)
1.modifier le fichier makefile dans c:\ming\src

*enlever la ligne:







Code:

ranlib libming.a  # bsd requires this?

2.modifier le fichier makefile dans c:\ming\py_ext

*modifier le parametre PYINCDIR:







Code:

PYINCDIR = c:\python22\include

*dans la section mingc.pyd, remplacer par:








Code:

dllwrap --dllname mingc.pyd --driver-name gcc --def mingc.def -o mingc.pyd ming_wrap.o -s --entry _DllMain@12 --target=i386-mingw32 -L. -lpython22 -lming

D.compilation
1.en mode console se placer dans c:\ming
2.compiler la librairie static libming.a avec
make static
3.copier le fichier c:\ming\libming.a dans c:\py_ext
4.se placer dans c:\ming\py_ext
5.compiler la librairie dynamique pour python mingc.pyd avec
make mingc.pyd


E.deploiement et test
1.copier le fichier mingc.pyd de c:\ming\py_ext dans c:\python22\DLLs
2.lancer python en mode console et taper
import mingc
si aucun message d'erreur n'apparait, la librairie est alors installée

Interfacer une base MySQL avec Python

 

Pour accéder à une base MySQL depuis un programme python, il faut utiliser un module python supplémentaire.

Il se nomme MySQLdb, on peut le trouver à http://sourceforge.net/projects/mysql-python/

Installation du module
1. Download la derniere version pour windows en .exe
2. Choisir le répertoire python c:\python22 et le répertoire d'installation des librairies C:\dev\Python22\Lib\site-packages

Test du module
Tester l'instruction

Code:

import MySQLdb

Exemple d'utilisation

Code:

import MySQLdb # Create a connection object and create a cursor Con = MySQLdb.Connect(host="127.0.0.1", port=3306, user="nomorgan", passwd="pass",db="mysql") Cursor = Con.cursor() # Make SQL string and execute it sql = "SELECT * FROM User" Cursor.execute(sql) # Fetch all results from the cursor into a sequence and close the connection Results = Cursor.fetchall() print Results Con.close()

PaP - Créer un objet COM en VB.NET

 

[- Avec une utilisation minimale de Visual Studio.Net]
[- Il est conseillé d'utiliser la console lancée depuis "Invite de commandes Visual Studio.Net", car les variables d'environnement sont configurées (path,etc..)]

1.Environnement de travail
- Créer un projet Visual Studio.NET
Projet Visual Basic / Bibliothèque de classe (type du projet:ClassLibrary, nom du projet:sans importance)

- Ajouter un nouvel élément au projet (type élément:COM Class) (ex : maClasse)
- Effacer le fichier Class1.vb

2.Namespace
- Dans maClasse.vb , ajouter un Namespace (ex : monNamespace)

Namespace monNamespace
       ‘ tout le code du fichier
End Namespace

3.Importer
- Ajouter au début de maClasse.vb (avant le namespace)
        Imports Microsoft.VisualBasic

4.Méthodes
- Retravailler la classe maClasse afin d’ajouter les méthodes de l’objet (ex : maFonctionTest)

Public Function maFonctionTest() As String
    return « hello from maFonctionTest »
End Function

5.Signature
- En mode console, générer un fichier de clé

>sn –k fichier.snk

- Editer le fichier Assembly.vb, à la fin du fichier
                  <Assembly: AssemblyKeyFileAttribute("fichier.snk")>
(éventuellement mettre le path complet vers le fichier.snk)

6.Importer
- Au début du fichier Assembly.vb,ajouter
Imports System
Imports System.Attribute

7.Compiler la DLL
- En mode console, en se plaçant dans le répertoire du projet

set assemblies=System.Web.Services.dll,System.Xml.dll [etc..] mettre ici toutes les références nécessaires
Il faut déterminer dans quelle DLL sont incluses les déclarations de type Import. On peut se servir de Visual Studio par exemple, en ajoutant une référence à la bibliothèque importer (menu "Références" dans l'explorateur de solutions) et consulter la propriété "Chemin d'accès".

- Compilation :
vbc *.vb /out:bin\nomFichier.dll /target:library /r:%assemblies%

8.Enregistrer la DLL
- En mode console, en se plaçant dans le répertoire du projet

RegAsm.exe bin\nomFichier.dll /tlb /codebase

9.Test de la DLL en vbscript

set obj = createobject("monNamespace.maClasse")
msgbox "Création objet OK"
msgbox obj.maFonctionTest ()
set obj = Nothing