From 3bf4d24b4c5724ee97917f2fe4af3c65bc7ef376 Mon Sep 17 00:00:00 2001 From: eficas <> Date: Thu, 6 Mar 2003 14:36:12 +0000 Subject: [PATCH] =?utf8?q?Antoine=20Yessayan=20a=20modifi=C3=A9=20la=20bo?= =?utf8?q?=C3=AEte=20=C3=A0=20outils=20permettant=20d'instrumenter=20du=20?= =?utf8?q?Python.?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit developpeur.py En particulier, les outils ne sont actifs que si les développeurs sont déclarés dans ce fichier ; modification.py propose une fonction permettant de tracer lors de l'execution d'Eficas une intervention effectuée par l'un des développeurs ; execute.py permet d'organiser l'instruction exec in contexte. --- Utilites/__init__.py | 16 +++-- Utilites/appels.py | 143 ++++++++++++++++++++++++++----------- Utilites/developpeur.py | 36 ++++++++++ Utilites/execute.py | 71 +++++++++++++++++++ Utilites/funcname.py | 100 ++++++++++++++++++++++++++ Utilites/ici.py | 97 ++++++++++++++----------- Utilites/message.py | 106 ++++++++++++++++------------ Utilites/modification.py | 46 ++++++++++++ Utilites/pause.py | 74 ++++++++++++-------- Utilites/scrute.py | 148 ++++++++++++++++++++++++++++----------- 10 files changed, 635 insertions(+), 202 deletions(-) create mode 100644 Utilites/developpeur.py create mode 100644 Utilites/execute.py create mode 100644 Utilites/funcname.py create mode 100644 Utilites/modification.py diff --git a/Utilites/__init__.py b/Utilites/__init__.py index 19d51f8f..d109f6c8 100644 --- a/Utilites/__init__.py +++ b/Utilites/__init__.py @@ -1,5 +1,5 @@ """ - $Id: __init__.py,v 1.2 2003/02/04 10:40:57 eficas Exp $ + $Id: __init__.py,v 1.3 2003/02/06 15:11:22 eficas Exp $ Le package UTILITES contient les fonctions permettant d'instrumenter un script : @@ -10,14 +10,22 @@ ##__all__ = [ "ici" , "message" , "scrute" , "pause" , "appels" ] -from pause import * + +try : + from developpeur import * +except : + pass from ici import * +from execute import * +from pause import * from scrute import * from message import * from appels import * +from modification import * if __name__ == "__main__" : - print dir() - print "import du package effectué !" + MODIFICATION( "toto" ) + developpeur.write( dir()+'\n' ) + developpeur.write( "import du package effectué !" +'\n' ) diff --git a/Utilites/appels.py b/Utilites/appels.py index efc9a6d9..d4638a4a 100644 --- a/Utilites/appels.py +++ b/Utilites/appels.py @@ -4,52 +4,115 @@ Module appels le module appels ... """ -import sys -sortie=sys.stderr -sortie.write( "import de "+__name__+" : $Id$" ) -sortie.write( "\n" ) +try : + from developpeur import DEVELOPPEUR +except : + DEVELOPPEUR=None +def NULL( *l_args, **d_args ) : pass -def APPELS() : +if DEVELOPPEUR : - """ - Fonction APPELS - --------------- - La fonction APPELS ... - .. + import developpeur + developpeur.sortie.write( "import de "+__name__+" : $Id$" ) + developpeur.sortie.write( "\n" ) + import sys + import re + import ici + import funcname + + + def Alonge( chaine , longueur ) : + return chaine+' ' # provisoirement on ne complete pas la chaine + k=len(chaine) + while( k2 : + decalage += '\t' + + # Recherche du plus long nom de fichier pour la mise en forme + lmax=0 + for e in trace[2:-1] : + fic,numero,fonc,inst = e + position=fic+":"+str(numero)+":" + if len(position)>lmax : lmax=len(position) + lmax += 1 # Pour eloigner les informations du nom du fichier + + for e in trace[1:-1] : + fic,numero,fonc,inst = e + position = chaine=fic+":"+str(numero)+":" + position = Alonge( chaine=position , longueur=lmax ) + developpeur.sortie.write( decalage+position) + developpeur.sortie.flush() + fname=funcname.FUNCNAME(fic,numero) + developpeur.sortie.write( str(fname) ) + developpeur.sortie.write( ' : ' ) + developpeur.sortie.write( inst ) + developpeur.sortie.write( '\n' ) + developpeur.sortie.flush() + decalage += "" + + fic,numero,fonc,inst = trace[-1] + position = chaine=fic+":"+str(numero)+":" + position = Alonge( chaine=position , longueur=lmax ) + developpeur.sortie.write( decalage+position) + developpeur.sortie.flush() + fname="__main__" + developpeur.sortie.write( str(fname) ) + developpeur.sortie.write( ' : ' ) + developpeur.sortie.write( inst ) + developpeur.sortie.write( 3*'\n' ) + developpeur.sortie.flush() + + + return - Usage : - from appels import APPELS - APPELS() - """ +else : + APPELS = NULL - print "Passage dans APPELS" -### try : -### 1/0 -### except : -### import traceback -### trace=traceback.extract_stack() -### print trace - - import traceback - trace=traceback.extract_stack() - - trace.reverse() - - decalage="" - if len(trace)>2 : - for e in trace[2:-1] : - fic,numero,fonc,inst = e - print decalage+fic+":"+str(numero)+": "+fonc,inst - decalage += "\t" - - fic,numero,fonc,inst = trace[-1] - print decalage+fic+":"+str(numero)+": "+"__main__",inst - - - return if __name__ == "__main__" : - APPELS() + TOTO=NULL + TOTO( dec="" ) diff --git a/Utilites/developpeur.py b/Utilites/developpeur.py new file mode 100644 index 00000000..6fc7bf41 --- /dev/null +++ b/Utilites/developpeur.py @@ -0,0 +1,36 @@ +""" + Ce module permet de définir la variable DEVELOPPEUR indiquant + que l'utilisateur courant fait partie de la liste des développeurs. + Ce qui lui donne un accès aux versions actives des fonctions + ICI, MESSAGE, SCRUTE, ... définies dans le module Utilites + à condition qu'ils utilisent le module sur une station cli*. + + Pour ajouter un nouveau développeur, il faut modifier le dictionaire + d_dev ci-dessous +""" + + +DEVELOPPEUR=None + +import os +def hostname() : + return os.uname()[1] +group_eficas=108 +group_salome=107 + + +# Test pour identifier un utilisateur développeur d'Eficas +groups = os.getgroups() +test_devel = hostname()[0:3]=="cli" and ( group_eficas in groups or group_salome in groups ) +if test_devel : + d_dev = { 10618 : "antoine" , 10621 : "Pascale" , 20132 : "chris" , 10214 : "salome" } + if os.getuid() in d_dev.keys() : + DEVELOPPEUR=d_dev[ os.getuid() ] + import sys + sortie=sys.stderr + sortie.write( "import de "+__name__+" : $Id$" ) + sortie.write( "\n" ) + + +if __name__ == "__main__" : + print DEVELOPPEUR diff --git a/Utilites/execute.py b/Utilites/execute.py new file mode 100644 index 00000000..8e18e4d2 --- /dev/null +++ b/Utilites/execute.py @@ -0,0 +1,71 @@ +""" +Module exec +----------- + le module exec ... +""" + +try : + from developpeur import DEVELOPPEUR +except : + DEVELOPPEUR=None + +if DEVELOPPEUR : + + import message + import scrute + import types + import developpeur + developpeur.sortie.write( "import de "+__name__+" : $Id$" ) + developpeur.sortie.write( "\n" ) + developpeur.sortie.flush() + + + class EXEC : + + def __init__ ( self, texte, contexte=None, verbeux=1 ) : + + assert( type(texte) == types.StringType ) + if contexte == None : + contexte = globals() + + if verbeux : + message.MESSAGE( "execution de "+texte ) + try : + exec texte in contexte + except Exception,e : + if verbeux : + import traceback + traceback.print_exc() + developpeur.sortie.write( "\n\n\n" ) + message.MESSAGE( "Exception interceptee" ) + scrute.SCRUTE( texte ) + scrute.SCRUTE( contexte ) + scrute.SCRUTE( e.__class__.__name__ ) + scrute.SCRUTE( str(e) ) + developpeur.sortie.write( "\n\n\n" ) + developpeur.sortie.flush() + raise + + +else : + class EXEC : pass + + + + +if __name__ == "__main__" : + class Ex(Exception) : pass + def toto() : + print "toto" + raise Ex( "y a bel et bien un erreur" ) + + def tutu() : + s = "toto()" + EXEC( s , verbeux=1) + + try : + tutu() + except Exception,ee : + scrute.SCRUTE(str(ee)) + scrute.SCRUTE(ee.__class__) + pass diff --git a/Utilites/funcname.py b/Utilites/funcname.py new file mode 100644 index 00000000..bd272912 --- /dev/null +++ b/Utilites/funcname.py @@ -0,0 +1,100 @@ +import re,types +import sys + +sortie=sys.stderr +sortie.write( "import de "+__name__+" : $Id$" ) +sortie.write( "\n" ) + +def get_nombre_de_blancs( str ) : + nombre_de_blancs=0 + if str : + nombre_de_blancs=len(re.sub( "[^ ].*$" , "" , str )) + return nombre_de_blancs + + + +def get_classname( filename, lineno ) : + """ + Cette méthode sert à trouver dans quelle classe (le cas échéant) + se trouve l'instruction numéro lineno dans le fichier filename. + """ + classname = "" + current_func = "" + assert(type(filename)==types.StringType) + ####print "RECHERCHE de la classe de "+filename+" ligne : ",lineno + if lineno>0 : + try : + f=open( filename , 'r' ) + except Exception,e : + print ">>>>",str(e) + sys.stdout.flush() + sys.exit(17) + + s = f.read() + f.close() + l_lines = s.split( '\n' ) + k=1 + inst = l_lines[lineno] + nb_blancs= get_nombre_de_blancs( inst ) + + for line in l_lines : + if k == lineno : + break + elif re.search( "^ *def ", line ) != None : + if get_nombre_de_blancs( line ) < nb_blancs : + current_func=re.sub( "^ *def *" , "" , line ) + current_func=re.sub( " *\(.*$" , "" , current_func ) + elif re.search( "^class ", line ) != None : + classname = re.sub( "^class *" , "" , line ) + classname = re.sub( " *[(:].*$" , "" , classname ) + current_func = "" + elif current_func != "" and re.search( "^[^ \t]", line ) != None : + current_func = "" + classname = "" + k = k+1 + if current_func == "" : current_func="__main__" + return classname ,current_func + + + + +class FUNCNAME : + + """ + Conversion des 3 informations nom de méthode, nom de fichier + numéro de ligne en un nom complet de méthode + """ + + def __init__ ( self , *args ) : + + # le premier argument est optionnel (c'est un nom de fonction + # qu'on peut reconstituer avec le nom du fichier et le numéro de ligne. + k=0 + self.name = None + if len(args)>2 : + if args[k] != "" : self.name = args[k] + k = k+1 + + assert(args[k]!=None) + assert(args[k]!="") + self.filename = args[k] # recuperation du nom du fichier source + + k = k+1 + assert(args[k]>0) + self.lineno = args[k] # recupération du numero de ligne + + self.classname,funcname = get_classname( self.filename, self.lineno ) + if self.name == None : self.name = funcname + ###assert(funcname==self.name or self.name=="main" or self.name=="" ), "attendue '"+self.name+"' - trouvee '"+funcname+"'" + + def __str__ ( self ) : + if self.classname != "" : + name=self.classname+"."+self.name + else : + name=self.name + return name + + +if __name__ == "__main__" : + print 'FUNCNAME("","funcname.py", 68)='+str(FUNCNAME("","funcname.py", 63) ) + print 'FUNCNAME("funcname.py", 68)='+str(FUNCNAME("funcname.py", 63) ) diff --git a/Utilites/ici.py b/Utilites/ici.py index fdfa8c9c..cd79c6ac 100644 --- a/Utilites/ici.py +++ b/Utilites/ici.py @@ -5,52 +5,67 @@ Module ici le fichier courant et le numéro de la ligne courante. """ -import sys -sortie=sys.stderr -sortie.write( "import de "+__name__+" : $Id$" ) -sortie.write( "\n" ) +try : + from developpeur import DEVELOPPEUR +except : + DEVELOPPEUR=None -def ICI(offset=1) : +def NULL( *l_args, **d_args ) : pass - """ - Fonction ICI - ------------ - La fonction ICI affiche sur la stderr, le nom du fichier qui l'appelle, - le numéro de la ligne ou elle est appelée et retourne ces deux informations. +if DEVELOPPEUR : - Usage : - from ici import ICI - ICI() - filename,lineno=ICI() - """ + import developpeur + developpeur.sortie.write( "import de "+__name__+" : $Id$" ) + developpeur.sortie.write( "\n" ) - sortie=sys.stderr + import sys - sys.stdout.flush() - sys.stderr.flush() - try : - 1/0 - except : + def ICI(offset=1) : + + """ + Fonction ICI + ------------ + La fonction ICI affiche sur la stderr, le nom du fichier qui l'appelle, + le numéro de la ligne ou elle est appelée et retourne ces deux informations. + + Usage : + from ici import ICI + ICI() + filename,lineno=ICI() - ###f=sys.exc_info()[2].tb_frame.f_back - ###lineno=f.f_lineno - ###code=f.f_code - ###filename=code.co_filename + N.B. : la fonction ICI n'est opérante que pour les développeurs + """ + + sys.stdout.flush() + sys.stderr.flush() + try : + 1/0 + except : + ###f=sys.exc_info()[2].tb_frame.f_back + ###lineno=f.f_lineno + ###code=f.f_code + ###filename=code.co_filename + + import traceback + trace=traceback.extract_stack() + + indice = len(trace)-(2+offset) + if indice<0 : indice=0 + + + assert( indice0) or (func_name=="?") ) + if func_name=="?" : func_name = "main" + + if offset >= 0 : + import funcname + developpeur.sortie.write( file_name+':'+str(lineno)+': ('+str(funcname.FUNCNAME(func_name,file_name,lineno))+') : ' ) + developpeur.sortie.flush() + + return file_name,lineno - import traceback - trace=traceback.extract_stack() - indice = len(trace)-(2+offset) - if indice<0 : indice=0 - - - assert( indice0) or (funcname=="?") ) - if funcname=="?" : funcname = "main" - - sortie.write( file+':'+str(lineno)+': ('+funcname+') : ' ) - sortie.flush() - - return file,lineno +else : + ICI = NULL diff --git a/Utilites/message.py b/Utilites/message.py index 90b41c3a..fa94124a 100644 --- a/Utilites/message.py +++ b/Utilites/message.py @@ -3,70 +3,88 @@ Module message -------------- le module message propose la fonction MESSAGE pour afficher sur la stderr, le texte passé en argument. + N.B. : la fonction MESSAGE n'est opérante que pour les développeurs + (la variable DEVELOPPEUR doit être définie) """ -import sys -sortie=sys.stderr -sortie.write( "import de "+__name__+" : $Id$" ) -sortie.write( "\n" ) +try : + from developpeur import DEVELOPPEUR +except : + DEVELOPPEUR=None -def MESSAGE( text , offset=1 ) : +def NULL( *l_args, **d_args ) : pass - """ - Fonction MESSAGE - ---------------- - La fonction MESSAGE affiche sur la stderr, le texte passé en argument. - Elle précise également le nom du fichier et le numéro de la ligne où - elle a été appelée. +if DEVELOPPEUR : - Usage : + import developpeur + developpeur.sortie.write( "import de "+__name__+" : $Id$" ) + developpeur.sortie.write( "\n" ) + + import sys + import ici + + def MESSAGE( text , offset=1 ) : + + """ + Fonction MESSAGE + ---------------- + La fonction MESSAGE affiche sur la stderr, le texte passé en argument. + Elle précise également le nom du fichier et le numéro de la ligne où + elle a été appelée. + + Usage : from message import MESSAGE MESSAGE("debut du traitement") MESSAGE( "Exception interceptée "+str(e) ) - """ + """ + + ici.ICI( offset ) + developpeur.sortie.write( str(text)+'\n' ) + developpeur.sortie.flush() + return - sortie=sys.stderr - import ici - ici.ICI( offset ) - sortie.write( str(text)+'\n' ) - sortie.flush() - return + def DEBUT() : + """ + Fonction DEBUT + -------------- + La fonction DEBUT affiche sur la stderr, le texte signalant le début + d'un traitement -def DEBUT() : + Usage : + from message import * + DEBUT() + N.B. : la fonction DEBUT n'est opérante que pour les développeurs + """ - """ - Fonction DEBUT - -------------- - La fonction DEBUT affiche sur la stderr, le texte signalant le début - d'un traitement + developpeur.sortie.write( '\n\n' ) + MESSAGE("DEBUT du traitement [",offset=2) + return - Usage : - from message import * - DEBUT() - """ - MESSAGE("DEBUT du traitement",offset=2) - return + def FIN() : + """ + Fonction FIN + ------------ + La fonction FIN affiche sur la stderr, le texte signalant la fin + d'un traitement -def FIN() : + Usage : + from message import * + FIN() - """ - Fonction FIN - ------------ - La fonction FIN affiche sur la stderr, le texte signalant la fin - d'un traitement + N.B. : la fonction FIN n'est opérante que pour les développeurs + """ - Usage : - from message import * - FIN() - """ + MESSAGE("] FIN du traitement",offset=2) + return - print - MESSAGE("FIN du traitement",offset=2) - return +else : + MESSAGE= NULL + DEBUT = NULL + FIN = NULL diff --git a/Utilites/modification.py b/Utilites/modification.py new file mode 100644 index 00000000..f5f8e6b6 --- /dev/null +++ b/Utilites/modification.py @@ -0,0 +1,46 @@ +""" +Module intervention +------------------- + Permet aux développeurs de signer leur intervention à + destination des autres développeurs. +""" + +try : + from developpeur import DEVELOPPEUR +except : + DEVELOPPEUR=None + +def NULL( *l_args, **d_args ) : pass + + +if DEVELOPPEUR : + + import developpeur + developpeur.sortie.write( "import de "+__name__+" : $Id$" ) + developpeur.sortie.write( "\n" ) + import ici + + def MODIFICATION( text , offset=1 ) : + + """ + Fonction MODIFICATION + --------------------- + + Usage : + from utilites import MODIFICATION + + utilites.MODIFICATION("auteur,date et intention") + """ + + ici.ICI( offset ) + developpeur.sortie.write( "MODIFICATION "+str(text)+'\n' ) + developpeur.sortie.flush() + return + + +else : + MODIFICATION = NULL + + +if __name__ == "__main__" : + MODIFICATION( "baratin inutile" ) diff --git a/Utilites/pause.py b/Utilites/pause.py index 40d23a8e..d7dcafa8 100644 --- a/Utilites/pause.py +++ b/Utilites/pause.py @@ -4,42 +4,54 @@ Module pause le module pause propose la fonction PAUSE pour effectuer une attente. """ +try : + from developpeur import DEVELOPPEUR +except : + DEVELOPPEUR=None -import sys -sortie=sys.stderr -sortie.write( "import de "+__name__+" : $Id$" ) -sortie.write( "\n" ) +def NULL( *l_args, **d_args ) : pass -def PAUSE( secondes ) : +if DEVELOPPEUR : - """ + import developpeur + developpeur.sortie.write( "import de "+__name__+" : $Id$" ) + developpeur.sortie.write( "\n" ) - Fonction PAUSE - ---------------- - La fonction PAUSE permet d'interrompre le traitement pendant un délai - passé en argument. La localisation de l'appel est tracée sur la stderr + import sys + import ici + + def PAUSE( secondes ) : + + """ + + Fonction PAUSE + ---------------- + La fonction PAUSE permet d'interrompre le traitement pendant un délai + passé en argument. La localisation de l'appel est tracée sur la stderr + + Usage : + from pause import PAUSE + + PAUSE(secondes=5) + """ + + if secondes > 0 : + developpeur.sortie.write( "\n\n\n" ) + ici.ICI() + + developpeur.sortie.write( "pause de "+str(secondes)+" secondes" ) + developpeur.sortie.write( "\n\n\n" ) + developpeur.sortie.flush() + + import time + time.sleep( secondes ) + + developpeur.sortie.flush() + + return - Usage : - from pause import PAUSE - - PAUSE(secondes=5) - """ - - if secondes > 0 : - sortie.write( "\n\n\n" ) - import ici - ici.ICI() - - sortie.write( "pause de "+str(secondes)+" secondes" ) - sortie.write( "\n\n\n" ) - sortie.flush() - - import time - time.sleep( secondes ) - - sortie.flush() - - return +else : + PAUSE = NULL if __name__ == "__main__" : diff --git a/Utilites/scrute.py b/Utilites/scrute.py index 151155ea..90ade356 100644 --- a/Utilites/scrute.py +++ b/Utilites/scrute.py @@ -1,66 +1,130 @@ """ Module scrute ------------- - le module scrute propose la fonction SCRUTE qui affiche sur + Le module scrute propose la fonction SCRUTE qui affiche sur la stderr, la valeur de l'objet (passé en argument) précédée le nom de l'objet. + Il propose également la fonction EXAMINE qui détaille sur + la stderr le contenu d'un objet + + N.B. : les fonctions SCRUTE e EXAMINE ne sont opérantes que pour les développeurs + (la variable DEVELOPPEUR doit être définie) """ -import sys -sortie=sys.stderr -sortie.write( "import de "+__name__+" : $Id$" ) -sortie.write( "\n" ) +try : + from developpeur import DEVELOPPEUR +except : + DEVELOPPEUR=None +def NULL( *l_args, **d_args ) : pass -def SCRUTE( valeur ) : +if DEVELOPPEUR : - """ - Fonction SCRUTE - --------------- - La fonction SCRUTE affiche sur la stderr, la valeur (passée en argument) - d'une variable précédée de son nom. - L'affichage précise également le nom du fichier et le numéro - de la ligne où la fonction SCRUTE a été appelée. + import developpeur + developpeur.sortie.write( "import de "+__name__+" : $Id$" ) + developpeur.sortie.write( "\n" ) + import re + import linecache + import ici + import sys + + def SCRUTE( valeur ) : + + """ + Fonction SCRUTE + --------------- + La fonction SCRUTE affiche sur la stderr, la valeur (passée en argument) + d'une variable précédée de son nom. + L'affichage précise également le nom du fichier et le numéro + de la ligne où la fonction SCRUTE a été appelée. - N.B. : le type de la variable doit posséder de préférence une méthode __str__ + N.B. : le type de la variable doit posséder de préférence une méthode __str__ - Usage : + Usage : from scrute import SCRUTE r=1.0 SCRUTE(r) SCRUTE(r+1) SCRUTE(f(r)) - Erreur : + Erreur : SCRUTE(r) ; SCRUTE(f(r)) # ==> ERREUR - """ + """ - import re - import linecache - import ici - filename,lineno=ici.ICI() + filename,lineno=ici.ICI() - line = linecache.getline( filename, lineno ) + line = linecache.getline( filename, lineno ) - ll=re.sub( "\s*#.*$" , '' ,line) - l_occurrences=[] - l_occurrences=re.findall( "SCRUTE" , ll ) - assert(len(l_occurrences)>0),__name__+" : pas de SCRUTE trouvé !" - assert(len(l_occurrences)<=1),\ + ll=re.sub( "\s*#.*$" , '' ,line) + + l_occurrences=[] + l_occurrences=re.findall( "SCRUTE" , ll ) + assert(len(l_occurrences)>0),__name__+" : pas de SCRUTE trouvé !" + assert(len(l_occurrences)<=1),\ __name__+" : "+str(len(l_occurrences))+" SCRUTE sur la même ligne ; c'est LIMITE à 1 !" - ll=re.sub( "\s*;.*$" , '' ,line) - regex='^.*SCRUTE[^(]*\(' - l=re.sub( regex , '' ,ll) - regex='\)[^)]*$' - nom_objet=re.sub( regex , '' ,l) - - try : - sortie.write( nom_objet+'=' ) - sortie.write( str(valeur) ) - sortie.write( " ("+str(type(valeur))+")" ) - except : pass - sortie.write( '\n' ) - sortie.flush() - - return + ll=re.sub( "\s*;.*$" , '' ,line) + regex='^.*SCRUTE[^(]*\(' + l=re.sub( regex , '' ,ll) + regex='\)[^)]*$' + nom_objet=re.sub( regex , '' ,l) + + try : + developpeur.sortie.write( nom_objet+'=' ) + s=str(valeur) + developpeur.sortie.write( s ) + developpeur.sortie.write( " ("+str(type(valeur))+")" ) + except : pass + developpeur.sortie.write( '\n' ) + developpeur.sortie.flush() + + return + + def makeClassName( ob ) : + import types + if type(ob) == types.InstanceType : + return str(ob.__class__) + else : + return str(type(ob)) + + + def EXAMINE( ob ) : + """ + Affiche sur la developpeur.sortie le contenu d'un objet + + Usage : + class KLASS : pass + import Utilites + object=KLASS() + Utilites.EXAMINE(object) + """ + + appel_EXAMINE=1 + f = sys._getframe( appel_EXAMINE ) + context=f.f_locals + + filename,lineno=ici.ICI() + line = linecache.getline( filename, lineno ) + nom=re.sub( "^.*EXAMINE *\(", "" , line ) + nom=re.sub( " *[,\)].*$", "" , nom ) + nom=re.sub( "\n", "" , nom ) + developpeur.sortie.write( "Examen de "+nom+" de type "+makeClassName(ob)+"\n" ) + + for att in dir(ob) : + st=nom+'.'+att + developpeur.sortie.write( '\t'+st+' = ' ) + developpeur.sortie.flush() + commande="import developpeur;developpeur.sortie.write( str("+st+")+'\\n' )" + try : + exec commande in context + except : + commande="import sys; sys.stderr.write( str("+st+")+'\\n' )" + exec commande in context + + return + + +else : + + SCRUTE = NULL + EXAMINE = NULL -- 2.30.2