Simuler l'éxécution en mode console d'un fichier Python

Version imprimable

30/08/2009, 16h53
rambc

Simuler l'éxécution en mode console d'un fichier Python
Bonjour,
voici mon problème du jour. Considérons le code très simple suivant :
Code:

1 2 3 4 5 6 #!/usr/bin/env python #coding=utf-8 a = 5 print a a = 2*a print a
Je voudrais faire un petit code Python qui simulerait le mode console, à savoir qui pour le fichier exemple ci-dessus me renverrait :
Code:

1 2 3 4 5 6 >>> a = 5 >>> print a 5 >>> a = 2*a >>> print a 10
Quelque voit-il comment faire sachant que le souci est ici est de récupérer chacune des sorties et les lignes qui les ont produites ?

Une proposition :

Code:

1
2
3
4
5
6
7
8
9
10
11
import code
 
console = code.InteractiveConsole()
 
def run(str):
    print ">>> " + str
    console.push(str)
 
with open("exemple.py") as f:
    for l in f:
        run(l.rstrip())

03/09/2009, 16h14
rambc
Génial ! :ccool: J'ai testé le code suivant et aucun souci... :mrgreen:
Code:

1 2 3 4 5 #!/usr/bin/env python #coding=utf-8 from sympy import * x=Symbol("x") limit(sin(x)/x, x, 0)
03/09/2009, 16h32
rambc

En fait, j'ai un souci. :calim2: Comment faire pour récupérer dans une chaîne ce qui est écrit dans la console Python ?

Il faut remplacer sys.stdout par une instance d'une classe avec la méthode write.
Par exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
 
tt = str_stdout()
 
print "blabla"
 
tt.close()
 
# affiche blabla
print str(tt)

04/09/2009, 00h27
rambc
J'ai dû zapper quelque chose.

Quand je lance le code suivant, j'obtiens 1 dans la console Python :
Code:

1 2 3 4 5 #!/usr/bin/env python #coding=utf-8 from sympy import * x=Symbol("x") limit(sin(x)/x, x, 0)
Quand j'utilise la 1ère méthode, on récupère juste les lignes du fichier à savoir :
Code:

1 2 3 4 5 >>> #!/usr/bin/env python >>> #coding=utf-8 >>> from sympy import * >>> x=Symbol("x") >>> limit(sin(x)/x, x, 0)
Il faudrait que j'arrive à récupérer cette valeur 1... Autrement dit, il me faut la ligne et ce qui sort éventuellement, et le tout sous forme de chaîne manipulable.

Si quelqu'un a-t-il une idée ?

En mettant les 2 codes ensemble, je n'ai pas de souci (avec Python 2.6.2).

Code:

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
import code
import sys
 
def run(str):
    print ">>> " + str
    console.push(str)
 
console = code.InteractiveConsole()
 
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
 
tt = str_stdout()
 
with open("exemple.py") as f:
    for l in f:
        run(l.rstrip())
 
tt.close()
print str( tt)

J'obtiens bien la sortie :

Citation:

>>> #!/usr/bin/env python
>>> #coding=utf-8
>>> from sympy import *
>>> x=Symbol("x")
>>> limit(sin(x)/x, x, 0)
1

J'avais 5 min ce matin. Voilà comment combiner les infos données par manur0 :

Code:

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
#!/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()
 
with open("exemple.py") as f:
    for l in f:
        l = l.rstrip()
        tt = str_stdout()
        text.append(">>> " + l)
        console.push(l)
        tt.close()
        tt = str(tt).strip() # Pour éviter de récupérer des lignes vides.
        if tt:
            text.append(tt)
 
print '\n'.join(text)

Voici un fichier exemple.py suivi de ce que l'on obtient.

Code:

1
2
3
4
5
#!/usr/bin/env python
#coding=utf-8
from sympy import *
x=Symbol("x")
limit(sin(x)/x, x, 0)

Chaîne renvoyée par le script :

Code:

1
2
3
4
5
6
>>> #!/usr/bin/env python
>>> #coding=utf-8
>>> from sympy import *
>>> x=Symbol("x")
>>> limit(sin(x)/x, x, 0)
1

Merci manur0. :lol:

Il reste à gérer les erreurs. Voici un code contenant une erreur :

Code:

1
2
3
4
5
6
7
8
#!/usr/bin/env python
#coding=utf-8
a = 5
print a
a = 2*a
c
print a
print c

J'ai essayé ceci mais cela ne marche pas.

Code:

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
#!/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()

L'erreur n'est pas attrapée. Pourquoi ?

L'idéal serait de récupérer le message d'erreur quelque soit le type d'erreur.

Toute info. est la bienvenue.

04/09/2009, 14h14
rambc

Je posterais ce week-end une solution consistant à tester tout le script (on m'a donné la réponse sur un autre post, il faut juste que je la retrouve) en renvoyant l'erreur dans une chaîne, et si tout fonctionne alors on crée le mode console.

Ma version finale avec récupération d'erreur :

Code:

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
import code
import sys
 
def run(str):
    print ">>> " + str
    console.push(str)
 
class catch_stdout_stderr:
    def __init__(self):
        self.stdout = sys.stdout
        self.stderr = sys.stderr
        self.buffer = ''
        sys.stderr = sys.stdout = self
    def write(self, str):
        self.buffer += str
    def __str__(self):
        return self.buffer
    def close(self):
        sys.stdout = self.stdout
        sys.stderr = self.stderr
 
console = code.InteractiveConsole()
 
tt = catch_stdout_stderr()
 
with open(sys.argv[1]) as f:
    for l in f:
        try:
            run(l.rstrip())
        except:
            console.showtraceback()
 
tt.close()
print str( tt)

J'ai enfin compris où tu voulais en venir : tout ceci permet de donner les chaines à exécuter pour doctest !!!
Bonne idée :ccool:

04/09/2009, 19h09
rambc

Citation:

Envoyé par manur0

J'ai enfin compris où tu voulais en venir : tout ceci permet de donner les chaines à exécuter pour doctest !!!

Ce n'est pas que pour cela... Je travaille sur un projet pour taper des maths et des tutos infos pour les formats HTML et PDF via LaTeX.
Du coup, je voudrais disposer d'un outil simulant le mode console sur des scripts où je n'aurai qu'à donner les lignes de code sans avoir à taper ou copier les lignes de sortie mo même.

Ceci étant dit, merci pour ton code mais je n'ai pas reéussi à la faire fonctionner avec un chemin de fichier donné. Dès que j'ai 20min de libre, je m'y mets.

Voilà ce que l'on peut faire. Le code est brouillon mais il y a les grandes lignes et de nouveau merci à manur0.

Code:

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
50
#!/usr/bin/env python
#coding=utf-8
import sys
import subprocess
 
def testfile(filepath):
    x = subprocess.Popen(["python.exe", filepath], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 
    return x.stderr.read()
 
 
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
 
 
pathFile = "exemple2.py"
 
test = testfile(pathFile)
 
if test:
    print 'Errors found :'
    print test
else:
    console = code.InteractiveConsole()
    text = []
    with open(pathFile) 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).strip() # Pour éviter de récupérer des lignes vides.
                if tt:
                    text.append(tt)
 
    text = '\n'.join(text)
    print text

L'inconvénient est que l'on lance deux fois le script mais bon...
Autre inconvénient que je corrigerais dès que possible et qui lui est gênant : la solution ne fonctionne que sous Windows mais on m'avait donné un snippet pour l'adaptation à Linux. Je ferais cela dans le week-end et je testerais.

04/09/2009, 20h11
Antoine_935

Citation:

Envoyé par rambc

la solution ne fonctionne que sous Windows mais on m'avait donné un snippet pour l'adaptation à Linux.

Peut-être en changeant "python.exe" par "python" ?
05/09/2009, 00h20
rambc

Citation:

Envoyé par Antoine_935

Peut-être en changeant "python.exe" par "python" ?

Tout simplement oui. Merci.