Archive for the 'Python' Category

INTERFACE AVEC FTPLIB

le but de ce tutoral est de vous familiariser avec le protocole FTP (File Transfert Protocole), qui est un protocole de transfert de fichiers généralement utilisé par les Web Master pour mettre a jour leurs sites sur les serveurs hébergements. Cependant le protocole FTP peut être utilisé à d’autres fins plus importants par exemple dans l’échange de données entre deux clients (entreprises). Les grandes entreprises sont très retentissantes à partager leurs bases de données avec d’autres clients quelque que soit le juteux marcher qui les lit . A juste titre car la corruption des données ou leurs perte peut tout simplement ruiner une entreprises , et le licenciement de  ses employés ne serait que une question de semaines . Pour toutes ces raisons  il faut trouver un  espace de partage de données

entres les deux clients tout en permettant à chacun de garder précieusement ses bases de données.

Le protocole FTP permet alors de regeler ce problème puisque c’est un ensemble de spécifications que les deux parties peuvent implémenter chacun de son cote (interfaces et Fonctions).

L’exemple suivant traitent le retrait des informations depuis un serveur FTP, chaque partie

est alors libre de traiter les données trouvées sur le FTP et une fois le traitement terminé de le déposer pour l’autre partie .Je ne maitrise pas les autres langages de programmation , mais  sachez

que vous pouvez implémenter le FTP sur tous les grands  langages de programmations (Perls, Ruby, Python.., sh ).

Cet exemple montre comment se connecter et extraire quelques fichier d’un FTP dans un dossier local.

https://github.com/aliounedia/degeer/tree/master/degeer

https://github.com/aliounedia/degeer/blob/master/degeer/ftp_client.py

Noter que ftplib est un pure module python  (dans la librairie standard)

A+ 🙂

Publicités

GoogleMap/Django/JQuery

Salut ;

Je ne vais pas vous ennuyer car c’est le ramadan et tout le monde est fatigué alors passons a l’essentiel.Comment Utiliser Google Map et Django ? 😉

C’est très simple d’abords  obtenez une clef chez google , allez y je vous attends

http://code.google.com/intl/fr/apis/maps/signup.html

Ok ,vous avez votre clef , créer un fichier html et mettez y code code .Je ne vais pas renter dans les

détails mais sachez que c’est du JQUERY  http://docs.jquery.com

—-

<html>
<body>
<head>
<script type="text/javascript" src="http://maps.google.com/maps?file=api&amp;v=2&amp;key=VOTRE_CLEF"></script>
<script type="text/javascript" src="/static/jquery-1.4.2.min.js"></script>
<script type="text/javascript" src="/static/jquery.gmap-1.1.0-min.js"></script>
<style type ='text/css'>
   body {font-family:"Times New Roman",Georgia,Serif;; font-size:8px;}
   table { width: 900px; margin: 0 auto; border-style:solid ; border-width:1px; border-color:#C0C0C0;}
   div#map { width: 900px;height: 800px; margin: 0 auto; border-style :solid ; border-width: 1px; border-color:#C0C0C0;}
   th{ border-style:solid ; border-width:1px; border-color:#C0C0C0;}
   td{border-style:solid ; border-width:1px; border-color:#C0C0C0;}
</style>
</head>

<body >
<!--script src="http://maps.google.com/maps?file=api&key=" type="text/javascript"></script-->
<script src="/static/labeledmarker.js" type="text/javascript"></script>
<script type="text/javascript">
$(function() {
        var gm = google.maps;
        if(gm.BrowserIsCompatible()) {
                var INITIAL_ZOOM = 7;

                /* initialize the map with the full
                * map-type, zoom, and pan controls */
                var map = new gm.Map2($("#map").get(0));
                map.addControl(new gm.LargeMapControl());
                map.addControl(new gm.MapTypeControl());
                map.disableDoubleClickZoom();
                /* when the document is unloaded, allow the gmap
                * to release it's resoures (especially for IE6) */
                $(document.body).unload(function() {
                        google.maps.Unload();
                });

                /* we're adding a new location, so center
                * the map over... guatemala! (what?) */
                var lat = 14.497401;
                var lon = -14.452362;
                var latlon = new gm.LatLng(lat, lon);
                map.setCenter(latlon, INITIAL_ZOOM);

                var sprite = function(offset) {
                        var icon = new GIcon(G_DEFAULT_ICON);
                        icon.sprite = {
                        //"image": "/static/locations/images/markers.png",
                        "top": offset * 34
                };
                return icon;
                };

                /* iterate each of the markers (ALL locations),
                * and add a sprite to the map for each one */
                $("td[marker]").each(function() {
                    var loc = $(this);
                    var point = new GLatLng(loc.attr("lat"), loc.attr("lng"));
                    var marker = new LabeledMarker(point, { "labelText": loc.attr("code"), "labelClass": "caption", "icon": sprite(loc.attr("marker")) });
                    marker.bindInfoWindow(this);
                    map.addOverlay(marker);
                });
        }
});
</script>

<table>
     <tr>
         <td>
            <div id="map">
                &nbsp;
            </div>
        </td>
    </tr>
</table>
<table id="markers">
    <tr>
	<th>Nom Village</th><th>Latitude</th><th>Longitude</th><th>Dernier SMS</th>
    </tr>

{% for village in villages %}
    <tr>
        <td>{{village.village_name}}</td>
        <td>{{village.latitude}}</td>
        <td>{{village.longitude}}</td>
	<td  code="" marker="test" lat="{{village.latitude}}" lng="{{village.longitude}}">
            {{village.last_message}}
	</td>
    </tr>
{% endfor %}
</table>
</body>
</html>

—–

Dans le code ci -dessus vous devez remplacer votre clef dans l’ entête ou j’ai mis [VOTRE_CLEF] .

Vous remarquez qu’il y’ a aussi la syntaxe de template de django ,cela montre juste que cette page

est servie par une vue django c-dessous.

—-

def handle (req):
    list = []
    for  village in Village.objects.all() :
        try:
              last_message =village.message_set.latest('received')
              list.append(
                  # Decimal is not Serializable
                  {'longitude':str(village.longitude),
                   'latitude':str(village.latitude),
                   'village_name':str(village.name) ,
                   'last_message':str(last_message)
                 })
        except Exception,  e:
              print  'Hum!Village n a pas de message?'
              print e
    print  list
    return render_to_response ('map.html' , { "villages": list})

—-

Bien entendu si je ne vous donne pas le fichier models.py  et le fichier url.py cette vue ne servira a rein .donc voici le model de donnée qui est associé a cette vue

from django.db import models
from datetime import datetime
# Create your models here.
class Village(models.Model):
    name = models.CharField (max_length = 20 , default = 'koalack')
    longitude =models.DecimalField (max_digits =10, decimal_places =5)
    latitude  =models.DecimalField (max_digits =10, decimal_places =5)

    def __unicode__(self):
        return self.name

class Message(models.Model):
    text = models.TextField  ()
    village =models.ForeignKey (Village)
    received = models.DateTimeField (default = datetime.utcnow())
    def __unicode__(self):
        return self.text

Et enfin voci le fichier urls.py  qui est associé a ce model.

from django.conf.urls.defaults import *

# Uncomment the next two lines to enable the admin:
from django.contrib import admin
admin.autodiscover()
from mapg.googlemap import views
urlpatterns = patterns('',
    # Example:
    # (r'^mapg/', include('mapg.foo.urls')),

    # Uncomment the admin/doc line below and add 'django.contrib.admindocs'
    # to INSTALLED_APPS to enable admin documentation:
    # (r'^admin/doc/', include('django.contrib.admindocs.urls')),

    # Uncomment the next line to enable the admin:
    url(r'^$' , views.handle , name="handle"),
    url(r'^cal/?$' , views.calendar_handler , name="calendar"),
    (r'^admin/', include(admin.site.urls)),
    (r'^static/(?P<path>.*)' , 'django.views.static.serve' ,
     {'document_root':'/home/dia/mapg/googlemap/static'})
)

--

S’il vous plait n’oubliez pas de prendre les biblitheques Jquery  manquantes et de mettre dans votre base des données latitude , longitude et le village associé par exemple

Moi dans ma base j’ai par exemple  [‘Keur Samba Loabé’ ,  ‘14.222’, ‘14.00005 »].

Et voici ce que vous obtenez si vous faites tout ce qui est necessaire  .Aplus 😉

def handle (req):
 »’Cette vue est uniquement appellee par JQUERY
et retourne la deniere message pour tous les villages »’
list = []
for  village in Village.objects.all() :
try:
last_message =village.message_set.latest(‘received’)
list.append(
# Decimal is not Serializable
{‘longitude’:str(village.longitude),
‘latitude’:str(village.latitude),
‘village_name’:str(village.name) ,
‘last_message’:str(last_message)
})
except Exception,  e:
print  ‘Hum!Village n a pas de message?’
print e
print  list
return render_to_response (‘map.html’ , { « villages »: list})

Synchronisation des Processus sous PYTHON

Bonjour  😉
Je vais essayer de vous montrer comment python gère les processus
concurrents. Pour cela ,nous allons écrire un programme  qui lance deux
processus en parallèles .
Chaque processus a un rôle d’incrémenter le compteur des processus
(self.thread_counter) .
Mais vous risquez d’avoir de grandes surprises si vous vous attendez
que les deux processus incrémentent  le compteur a tour de rôle .
vous risquez d’avoir un truc du genre :

>> : (95257 ,1)
>> : (95257, 2)

Vous voyez bien ici  dans l’exécution  que a  partir d’une certaine certaine
valeur ,les deux processus affichent la même valeurs , bizarre non 😉
En fait c’est très logique , le processus numéro un vient de prendre le compteur
et aussi tôt il l’incrémente , alors que  le processus deux avait déjà pris
le compteur  pour l’incrémenter.
Et comme les deux processus ont incrémenté la même variable (même valeur initiale ) , un seul comptage est
reflété  par la console .

Solution  :
———-

Python , a plusieurs façon de  gérer la concurrence entre les
processus  , mais je suis très séduit par la syntaxe que
je vais vous proposer, il est très simple et très élégant .
>> Utilez le  module lock de Thread
Voici les deux codes  , le premier n’est pas synchrone  , le second  code  l’est  😉

import threading
import sys
import os
import  time
class  ThreadConcurent:

    # The counter loop
    thread_counter = 0

    # Amelioration par rapport au premier
    a_lock  = thread.allocate_lock ()
    def __ini__(self):
         self.running = False

    def thread_first (self):
         """
         This is the first thread , it will be executed
         at the same moment thread  two.
         The  purpose is to see the way the (self.thread_counter) is
         printed  to the prompt
         """
         def fun ():
             while self.running:
                    self.thread_counter +=1
                    print  ("\r\n >> : (%s ,%s)"%(self.thread_counter , "1"))
             return  None
         # Im going  to start the thread
         threading.Thread (target = fun , args =()).start ()

    def thread_second (self):
         def  fun ():
             while self.running:
                with self.a_lock:
                    # Portion de code partagee entre les deux processus
                    # Verouille l'acces au ressource utilise dans  la portion
                    # de ce code au autres processus

                    self.thread_counter +=1
                    print  ("\r\n >> : (%s, %s)"%(self.thread_counter , "2"))
             return None 

         # Im going to start  the thread two
         threading.Thread (target =fun , args = ()).start()

    def start_all_threads  (self):
        print "Starting all threads"
        self.running = True
        self.thread_first ()
        self.thread_second()

    def stop_all_threads (self):
        self.running =False

if __name__=="__main__":

              th_c  =ThreadConcurent ()
              th_c.start_all_threads()

              # Wait anywone need to stop thread
              while (True):
                  try:

                      # Wait  2 second for requested stopping thread
                      time.sleep (2)
                  except KeyboardInterrupt:
                      th_c.running =False
                      print "Stoping  all threads"
                      sys.exit ("Execution stopped")

---
Synchronisation des processus améliorée.
---

import threading
import sys
import os
import time
import thread
class  ThreadConcurent:

    # The counter loop
    thread_counter = 0

    # Amelioration par rapport au premier
    a_lock  = thread.allocate_lock ()
    def __ini__(self):
         self.running = False

    def thread_first (self):
         """
         This is the first thread , it will be executed
         at the same moment thread  two.
         The  purpose is to see the way the (self.thread_counter) is
         printed  to the prompt
         """
         def fun ():
             while self.running:
                # Increment the thread_counter from thread one
                with self.a_lock:
                    # Portion de code partagee entre les deux processus
                    # Verouille l'acces au ressource utilise dans  la portion
                    # de ce code au autres processus

                    self.thread_counter +=1
                    print  ("\r\n >> : (%s ,%s)"%(self.thread_counter , "1"))
             return  None
         # Im going  to start the thread
         threading.Thread (target = fun , args =()).start ()

    def thread_second (self):
         def  fun ():
             while self.running:
                with self.a_lock:
                    # Portion de code partagee entre les deux processus
                    # Verouille l'acces au ressource utilise dans  la portion
                    # de ce code au autres processus

                    self.thread_counter +=1
                    print  ("\r\n >> : (%s, %s)"%(self.thread_counter , "2"))
             return None 

         # Im going to start  the thread two
         threading.Thread (target =fun , args = ()).start()

    def start_all_threads  (self):
        print "Starting all threads"
        self.running = True
        self.thread_first ()
        self.thread_second()

    def stop_all_threads (self):
        self.running =False

if __name__=="__main__":

              th_c  =ThreadConcurent ()
              th_c.start_all_threads()

              # Wait anywone need to stop thread
              while (True):
                  try:

                      # Wait  2 second for requested stopping thread
                      time.sleep (2)
                  except KeyboardInterrupt:
                      th_c.running =False
                      print "Stoping  all threads"
                      sys.exit ("Execution stopped")
import threading
import sys
import os
import  time
class  ThreadConcurent:

# The counter loop
thread_counter = 0

# Amelioration par rapport au premier
a_lock  = thread.allocate_lock ()
def __ini__(self):
self.running = False

def thread_first (self):
«  » »
This is the first thread , it will be executed
at the same moment thread  two.
The  purpose is to see the way the (self.thread_counter) is
printed  to the prompt
«  » »
def fun ():
while self.running:
self.thread_counter +=1
print  (« \r\n >> : (%s ,%s) »%(self.thread_counter , « 1 »))
return  None
# Im going  to start the thread
threading.Thread (target = fun , args =()).start ()

def thread_second (self):
def  fun ():
while self.running:
with self.a_lock:
# Portion de code partagee entre les deux processus
# Verouille l’acces au ressource utilise dans  la portion
# de ce code au autres processus

self.thread_counter +=1
print  (« \r\n >> : (%s, %s) »%(self.thread_counter , « 2 »))
return None

# Im going to start  the thread two
threading.Thread (target =fun , args = ()).start()

def start_all_threads  (self):
print « Starting all threads »
self.running = True
self.thread_first ()
self.thread_second()

def stop_all_threads (self):
self.running =False

if __name__== »__main__ »:

th_c  =ThreadConcurent ()
th_c.start_all_threads()

# Wait anywone need to stop thread
while (True):
try:

# Wait  2 second for requested stopping thread
time.sleep (2)
except KeyboardInterrupt:
th_c.running =False
print « Stoping  all threads »
sys.exit (« Execution stopped »)

PYTHON ET PROGRAMMATION OBJET

Bonjour  j’espère que vous êtes bien réveillé ,car nous allons faire de l’abstraction aujourd’hui  😉

Je commence par poser le problématique suivant :

–  Un corps Humain  veut que sa main gauche prenne une Banane et le donne a sa main droite , Comment programmer cela en Python .

L’exemple  est simple  , c’est le but  😉  rendre tout simple .

Mais sachez que  les  systèmes les plus complexes sont conçus a partir de ces questions basiques  ( Prends un objet  , traite le ,  donne le a un autre objet)

Car les logiciels informatique tentent a résoudre des problèmes réels  , que nous nous posons au quotidien  .

Bon  assez de bla bla   ,voici  le code  .

class  Body:
    # La class Etre humain
    # The human body 

    def __init__(self):
        self.dispatch_banane =   0
        self.bras_gauche     =   BrasGauche (self.dispatch_to_bras)
        self.bras_droit      =   BrasDroit

    def dispatch_to_bras (self , **kwargs ):
        print "Dispatch function appellee par le bras gauche\
        et dispatch la banane au bras droit "
        self.dispatch_banane +=1
        ins  =self.bras_droit (kwargs) 

        print "\n Bras droit argument"
        print unicode (ins)

    def run (self):
        self.bras_gauche.run ()

class  BrasDroit:
    # La class Bras droit  qui recoit  la banane de la classe
    # bras gauche
    def __init__(self , banane):
        self.banane  =  banane

    def __unicode__(self):
        return "[banane  : %s]"%self.banane 

class  BrasGauche:
    # La classe Bras gauche qui va prendre la
    # Banane et la donne  au bras  droit
    def __init__(self , dispatch_to_bras):
         self.dispatch_to_bras  = dispatch_to_bras 

    def run (self):
        banane  = {"prix"  : 100 , "poids" : 2 , "location": "casamance"}
        self.dispatch_to_bras (**banane)

if __name__=="__main__":
    # Demarre le corp humain
    # Start  human body
    body = Body ()
    body.run ()

Âpres  avoir exécuter ce code   ,la main gauche prendra la banane et la passera a la main droite  , et celle ci aura bien sa banane   , demain on lui donnera de la viande 😉

class  Body:
# La class Etre humain
# The human body

def __init__(self):
self.dispatch_banane =   0
self.bras_gauche     =   BrasGauche (self.dispatch_to_bras)
self.bras_droit      =   BrasDroit

def dispatch_to_bras (self , **kwargs ):
print « Dispatch function appellee par le bras gauche\
et dispatch la banane au bras droit « 
self.dispatch_banane +=1
ins  =self.bras_droit (kwargs)

print « \n Bras droit argument »
print unicode (ins)

def run (self):
self.bras_gauche.run ()

class  BrasDroit:
# La class Bras droit  qui recoit  la banane de la classe
# bras gauche
def __init__(self , banane):
self.banane  =  banane

def __unicode__(self):
return « [banane  : %s] »%self.banane

class  BrasGauche:
# La classe Bras gauche qui va prendre la
# Banane et la donne  au bras  droit
def __init__(self , dispatch_to_bras):
self.dispatch_to_bras  = dispatch_to_bras

def run (self):
banane  = {« prix »  : 100 , « poids » : 2 , « location »: « casamance »}
self.dispatch_to_bras (**banane)

if __name__== »__main__ »:
# Demarre le corp humain
# Start  human body
body = Body ()
body.run ()

PYTHON DECORATOR

Salut  , c’est encore moi 😉

Un truc très puissant sous python dont je me suis  demandé  pendant très longtemps (Mais à quoi sert ce truc?)  est le (decorator).

Les (decorators) sous python sont comme des enveloppes de fonctions .Ils permettent de faire des contrôles sur les fonctions en court-circuitant leur  exécution .

Les cas d’utilisations peuvent  être multiples .

1. contrôle sur les arguments passés à une fonction

2.contrôle des droits d’exécution sur des fonctions.

d’ailleurs DJANGO lui même l’utilise  très souvent dans son implémentation .

Vous avec sans doute vu à maintes reprises sous DJANGO la structure  suivante:

Celle ci permet de vérifier si l’utilisateur qui tente d ‘ exécuter la fonction est bien authentifié .

————————-
@login_required
def view():
pass
————————-
L’exemple ci-dessous permet d’effectuer un contrôle sur les arguments passés à la fonction .
Si « Alioune » ne figure pas parmi les arguments , la fonction ne sera jamais exécutée .

——————————————-

def check_args (func):
    """ Viens que je te mate avant que tu t'executes """
    def wrapper(self , *args , **kwargs):
        if  "Alioune"  not in args:
            raise Exception (
                "arguements :%s " %args)
        else:
            func (self, *args , **kwargs)

    return wrapper
class KeyWorder:
    """ Basic Keyworder class """
    # la fonction _check_args verifie si _alioune_ est dans la
    # liste des arguments avant de permettre l'execution de la fonction
    @check_args
    def handle_args(self , *args , **kwargs):
        """ Une fonction qui traite quelque chose """
        print  (
            "Ah <check_args>  m'a laissé passé , bon je continue alors")
        print  ("args  : %s  " %
               ''.join(args))
        print  ("kargs  : %s " %
               ''.join([ "%s :%s " %(k ,v)
                        for (k,v ) in  kwargs.items() ]))

if __name__ =="__main__":
    args   =[ "Alioune" ,"Jean" ]
    kwargs ={ "rien" : "rien du tout" }
    kwd   = KeyWorder ()
    kwd.handle_args (*args)

——————————————-