Attention c'est assez technique:
 
j'ai un programme qui tourne sur une machine et qui utilise les module A.py et B.py
 
Je voudrais modifier des fonction (ou des classes) dans A.py et B.py et que les modifications soient prises en compte par mon programme dynamiquement sans redemarrer mon programme.  
 
Ca c'est le premier defi.  
 
Le deuxieme c'est de creer un module C.py et modifier mon programme dynamiquement pour que sans redemarrer mon programme il utilise des  fonctions (ou des classes) dans C.py.
 
Donc j'ai regard la fonction reload pour faire ca mais ca marche pas terrible. Il faut peut etre surcharger la fonction __import__. Mon livre( python 2.1 bible) me dit que c'est mal de faire ca et qu'il faut plutot utiliser les librairies imp, ihooks et rexec.  
 
A votre avis comment faire?
 
Vraiment si y'a pas moyen de faire ca sans arreter le programmme, comment faire pour l'arreter et le redemarrer automatiquement?
 
merci de votre attention :-)

c'est quoi le probleme avec reload() ?
 

 
__import__('C')
 
 

précise le probleme, la c'est pas clair.
 
 

pourquoi faire ?? l'utiliser devrait suffire.
 
 

soit A le programme.
 
1. lancer un programme F en tache de fond
2. quitter le programme A
3. F lance A
4. quitter F

en gros tu veux faire un système de plugins c'est ça ? ça veut dire quoi "marche pas terrible" ?

drapal

 
+1

Quand je dis que reload ca marche pas terrible c'est que j'ai fait des tests qui montre les limitations de la fonction reload.
 
-Vous voulez du code???  
-Yeeessss!!!!
-Bon d'accord.
 
trois module:
 
moduleRecharge.py
 
import time
import moduleSource
 
if __name__=='__main__':
    while 1:
        time.sleep(2)
        reload(moduleSource)
        ms=moduleSource.ModuleSource()
        ms.afficher()
 
moduleSource.py
#import moduleSource2
 
class ModuleSource:
    def __init__(self):
        print 'nouvelle instance ModuleSource'
 
    def afficher(self):
        print  self.retourneCoucou()
        #print  self.retourneCoucou2()
     
    def retourneCoucou(self):
        return 'coucou'
 
#    def retourneCoucou2(self):
#        m = moduleSource2.ModuleSource2()
#        m.retourneCoucou2()
 
moduleSource2.py
class ModuleSource2:
    def __init__(self):
        print 'nouvelle instance ModuleSource2'
 
    def retourneCoucou2(self):
        print 'dans retourneCoucou2 (moduleSource2)'
        return 'coucou3'
 
Tests
Test1:
1. On lance moduleRecharge.py
2. "coucou" est ecrit toutes les seconde
3. on modifie dans moduleSource la fonction retourneCoucou en lui faisant retourner "coucou2"
--> dynamiquement la modif est bien prise en compte et coucou2 s'affiche toutes les seconde
 
Test2:
4. now on enleve tous les commentaires de moduleSource.
et la au lieu de voir  s'afficher toutes les secondes coucou2 et coucou3 on a coucou2 et None.
 
Voila, c'est un echec cuisant.  
 
Je vais de mon cote essayer d'utiliser __import__.

euh j'ai touvé ou etait le probleme pour mon exemple.  
C'est un petit bug debile.
 
dans module source faut remplacer
 
#    def retourneCoucou2(self):
#        m = moduleSource2.ModuleSource2()
#        m.retourneCoucou2()  
 
par:
 
#    def retourneCoucou2(self):
#        m = moduleSource2.ModuleSource2()
#        return m.retourneCoucou2()  
 
et la ca marche.
 
Je vais pouvoir compliquer mes tests :-)

#    def retourneCoucou2(self):
#        m = moduleSource2.ModuleSource2()
#        m.retourneCoucou2()
 
Cette fonction ne retourne rien. C'est un bug de ton code.
 
Edit : grilled

héhé