Discussion :

[rambc]

Bonjour,
le script suivant permet de voir la progression d'un script très basique sans identation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#!/usr/bin/env python
#coding=utf-8
import sys
 
class str_stdout:
    def __init__(self):
        self.stdout = sys.stdout
        self.buffer = ''
        sys.stdout = self
    def write(self, str):
        self.buffer += str
    def __str__(self):
        return self.buffer
    def close(self):
        sys.stdout = self.stdout
 
import code
 
text = []
 
console = code.InteractiveConsole()
 
try:
    with open("exemple.py") as f:
        for l in f:
            l = l.rstrip()
            if l:
                tt = str_stdout()
                text.append(">>> " + l)
                console.push(l)
                tt.close()
                tt = str(tt).rstrip() # Pour éviter de récupérer des lignes vides.
                if tt:
                    text.append(tt)
 
except:
    print 'ERROR'
 
text = '\n'.join(text)
 
print text.strip()

Le problème est que pour le script suivant, cela ne fonctionne plus à cause de la boucle :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
#!/usr/bin/env python
#coding=utf-8
for a in range(5):
    print a
 
print '4'

Y aurait-il un moyen relativement simple de contourner ce problème ?

Peut-être suffirait-il de mettre tout le bloc for dans la variable l pour console.push(l) (je n'ai pas Python pour essayer) ?

Une méthode un peu brutale qui me vient à l'esprit serait de créer des fichiers Python intermédiaires qui seraient obtenus avec la ligne No1, puis avec les lignes N°1 et 2, puis ensuite avec les lignes 1 à 3,...etc. On lancerait alors via un processus les fichiers obtenus (du plus petit au plus grand) en récupérant les sorties. Ne serait affiché que ce qui ne produirait pas d'erreur, en prenant soin de ne garder que les nouvelles lignes.

En espérant avoir été clair.

Toute info. est la bienvenue.

[N.tox]

Excuses-moi mais j'arrive pas à voir le rapport entre les deux scripts, et encore moins le problème... pourrais-tu décrire plus en détails le souci rencontré ? Ainsi que le moment où tu le rencontre ?

[pierjean]

Bonjour,
En effet, avec le script en exemple, il n'y a pas de problème...
Par contre, si on enlève la ligne vide au-dessus de "print '4'", cela ne fonctionne plus.
Pour moi, il faudrait voir du coté de "tokenize", pour l'indentation.
Ex:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#!/usr/bin/env python
#coding=utf-8
import sys
import tokenize,token
 
class str_stdout:
    def __init__(self):
        self.stdout = sys.stdout
        self.buffer = ''
        sys.stdout = self
    def write(self, str):
        self.buffer += str
    def __str__(self):
        return self.buffer
    def close(self):
        sys.stdout = self.stdout
 
import code
 
text = []
 
console = code.InteractiveConsole()
 
with open("exemple.py") as f:
    tok=tokenize.generate_tokens(f.readline)
    l=[]
    for num, val ,_,_,_ in tok:
        if num==6:                  #si Dédentation (je ne sais pas si ce terme existe...)
            l.append((54,"\n"))     #on ajoute une ligne vide
        l.append((num,val))
 
    result= tokenize.untokenize(l)
    for l in result.split("\n"):
        try:
            l = l.rstrip()
            tt = str_stdout()
            if l:
                text.append(">>> " + l)
            console.push(l)
            tt.close()
            tt = str(tt).strip()
            if tt:
                text.append(tt)
        except:
            print 'ERROR'
            break
text = '\n'.join(text)
 
print text

[rambc]

Excuses-moi mais j'arrive pas à voir le rapport entre les deux scripts, et encore moins le problème... pourrais-tu décrire plus en détails le souci rencontré ? Ainsi que le moment où tu le rencontre ?

Je précise le problème qui maintenant est résolu. Le tout premier script appliqué au script tout bête renvoie :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
>>> #!/usr/bin/env python
>>> #coding=utf-8
>>> for a in range(5):
>>>     print a
>>> print '4'
  File "<console>", line 3
    print '4'
        ^
SyntaxError: invalid syntax

La méthode tapée par pierjean renvoie :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
>>> #!/usr/bin/env python
>>> #coding=utf-8
>>> for a in range (5 ):
>>>     print a
0
1
2
3
4
>>> print '4'
4

Un grand merci à toi pierjean.

[tyrtamos]

Bonjour,

Je ne suis pas sûr d'avoir compris ce que tu voulais faire, mais si tu veux pouvoir tracer les lignes en cours d'exécution pour voir le déroulement d'un script, tu peux utiliser sys.settrace. Par exemple:

http://www.dalkescientific.com/writi...thon_code.html

Sur le principe, ça permet de reprendre la main à la fin de l'exécution de chaque ligne de code, comme on le fait en debugging. J'ai déjà utilisé cette technique pour arréter un thread:

http://python.jpvweb.com/mesrecettespython/arret_thread

Tyrtamos

[rambc]

Je ne suis pas sûr d'avoir compris ce que tu voulais faire, mais si tu veux pouvoir tracer les lignes en cours d'exécution pour voir le déroulement d'un script, tu peux utiliser sys.settrace.

Ce n'est pas pour du debugging que je fais cela. En fait, je bosse sur un outil perso. pour taper des documents scientifiques et aussi d'autres liés à la programmation. J'ai donc besoin d'un outil pour montrer quelques lignes tapées en ligne de commande sous Python pour montrer comment utiliser en ligne de commande un logiciel, un module...

Ta méthode permettrait-elle de faire cela ?

[tyrtamos]

Je ne sais pas. Mais je ne l'utilise pas en debugging. Je l'utilise pour arrêter un thread de calculs mathématiques (ma calculext), lorsque les calculs sont trop longs. C'est la seule méthode que j'ai trouvée.

Regarde à la fin de mon tuto sur l'arrêt des threads, il y a un exemple de ce qu'on peut faire.

En résumé (et sans qu'on ait besoin de thread):
- on lance un début de script après avoir initialisé la trace.
- tant que la trace est active, l'interpréteur donne la main à la fonction trace à la fin de l'exécution de chaque ligne de code (y compris dans une boucle: c'est bien une trace d'exécution)
- à la fin du script, on désactive la trace pour retrouver le fonctionnement normal de l'interpréteur.

La fonction trace qui reçoit la main à chaque ligne de script peut faire ce qu'on veut. Regarde mon tuto sur l'arrêt des threads, il y a plusieurs exemples de ce qu'on peut faire. Dans le dernier exemple, il est affiché le numéro de ligne avec le code de la ligne en question. Dans le 2ème exemple, je m'en sert pour arrêter un thread en déclenchant une exception.

Tyrtamos