Discussion :

[KINENVEU]

bonjour,

voila, je voudrais executer des commandes ms-dos a partir de python.

je fais par exemple :

Code :

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

1
2
3
4
 
import os
cmd = "echo toto"
os.system(cmd)

mais si je veux en effectuer plusieurs et garder la fenetre MS-dos ouverte,
comment puis-je faire ?
un peu comme un "batch file" ou je mets une serie de commande et je fini par un 'pause'.
(je n'ai pas trouve le separateur de commande en Ms-dos)

une idee ?

merci.

[miawaw]

Dans l'invite de commande de W. si tu tapes

Code :

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

start cmd /K file.bat

une nouvelle fenetre s'ouvre, les commandes dans file.bat sont executées et la fenêtre reste ouverte, prete à recevoir de nouvelles commandes.
Je sais plus comment à quel endroit du 'help' j'ai trouvé l'option '/K'. Si la fenêtre reste ouverte, ça doit être à cause du 'start'.

Dans python, il suffit donc d'écrire

Code :

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

1
2
cmd= "start cmd /K file.bat"
os.system(cmd)

[KINENVEU]

merci miawaw pour ta reponse.

en fait, ce n'est pas ca que je veux faire. :-(
je voudrais pouvoir executer plusieurs instructions dans la meme fenetre.

- soit en utilisant un separateur de commande.
- soit avec un genre de fonction "hold" qui maintient la fenetre. (solution que je prefererai)

et je ne voudrais passer par des 'batchs' que si je n'ai pas d'autres solutions.

Par contre, l'option '/K', je ne connaissais pas,
et ca va m'etre utile.
merci.

[PauseKawa]

Bonjour,

C'est cela que tu recherche ?
Il te suffit d'adapter le code.

@+

[KINENVEU]

non, ce n'est pas cela que je cherche.

[miawaw]

Dans la documentation de python, on lit sur la page http://docs.python.org/library/subprocess.html:
The subprocess module allows you to spawn new processes, connect to their input/output/error pipes, and obtain their return codes. This module intends to replace several other, older modules and functions, such as:
os.system
os.spawn*
os.popen*
popen2.*
commands.*

Mais je ne sais pas si ça resout le problème. On dirait que tu veux être capable d'introduire des commandes dans une console ouverte... Perso, je n'ai pas d'idées dsl.
En tapant

Code :

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

os.system('cmd')

dans la console python, tu fais apparaitre l'invite de commande:

Code :

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

1
2
3
4
5
>>> system('cmd')
Microsoft Windows XP blablabla
(C) blablabla blablabla
 
C:\Documents and Settings\Propriétaire>

mais je doute que ça soit ce que tu cherche. (on va y arriver)

[PauseKawa]

Bonsoir KINENVEU,

Dans un premier temps désolé pour le lien. Rien à voir avec ta question (multitâche off ).

Dans l'attente d'une réponse plus pro voici ce que j'ai a te proposer : Utiliser subprocess (stdout, stderr... ) pour faire un frontend avec tkinter.
En gros une fenêtre 'console' Tk.

pyconsole.py

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
# -*- coding: utf-8 -*-
#
#
#
from sys import version_info
import string
from subprocess import Popen, PIPE
 
if version_info[0] == 2:
    from Tkinter import *
else:
    from tkinter import *
 
class pyConsole(Tk):
    """ Fenêtre console """
    def __init__(self, width=80, fg='white', bg='black'):
        Tk.__init__(self)
        self.title("pyConsole 0.1")
        self.prompt='\n> '
        self.textconsole=Text(self, width=width, fg=fg, bg=bg, state=NORMAL, wrap=CHAR)
        scrollconsole = Scrollbar(self, command = self.textconsole)
        self.textconsole.configure(yscrollcommand = scrollconsole.set)
        self.textconsole.bind("<Return>", self.traite_Return)
        self.textconsole.bind("<KP_Enter>", self.traite_KP_Enter)
        self.textconsole.bind("<BackSpace>", self.traite_backspace)
        self.textconsole.pack(side=LEFT, fill=BOTH)
        scrollconsole.pack(side=RIGHT, fill=Y)
        self.textconsole.insert(END, self.prompt)
 
    """ Gestions EVENTS """
    def traite_KP_Enter(self, event):
        """ Gestion de KP_Enter """
        self.execute()
        self.textconsole.insert(END, self.prompt)
 
    def traite_Return(self, event):
        """ Gestion de Return. A corriger """
        self.execute()
        self.textconsole.insert(END, self.prompt)
 
    def traite_backspace(self, event):
        """ Gestion backspace. A corriger """
        cindex = self.getindex(CURRENT)
        print cindex
        print type(cindex)
        if int(cindex[1]) > 3:
            self.textconsole.delete("%s-0c" % INSERT, INSERT)
        else:
            nindex = str(cindex[0]) + '.0'
            self.textconsole.delete(nindex, END)
            self.textconsole.insert(END, self.prompt)
 
    """ Traitements """
    def clean(self):
        """ Traitement cls/clear """
        self.textconsole.delete(1.0, END)
        self.textconsole.insert(END, self.prompt)
 
    def quit(self):
        """ Traitement exit/quit """
        self.destroy()
 
    def getindex(self, index):
        return self.textconsole.index(index).split('.')
 
    def execute(self):
        """ A corriger """
        cindex = self.getindex(CURRENT)
        nindexs = str(cindex[0]) + '.0'
        nindexf = str(cindex[0])+'.end'
        commande = self.textconsole.get(nindexs, nindexf)[2:]
        self.traite(commande)
 
    def traite(self, commande):
        if commande == 'cls' or commande == 'clear': self.clean()
        elif commande.lower == 'exit' or commande == 'quit': self.quit()
        else:
            self.textconsole.insert(END, self.prompt)
            p = Popen([commande], shell=True,stdout=PIPE)
            retour = []
            for elems in p.stdout:
                self.textconsole.insert(END, elems)
                elems=elems.replace("\n","")
                retour.append(elems)
            return retour
 
    """ Appels externes """
    def insercmd(self, commande):
        retour = self.traite(commande)
        return retour
 
 
if __name__== '__main__':     
    fen=pyConsole(80, 'white', 'black')    
    fen.mainloop()

Code :

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

1
2
3
4
5
6
from pyconsole import pyConsole
pyc=pyConsole()
pyc.insercmd('dir')
# ou encore
retour = pyc.insercmd('dir')
print 'retour', retour

Et cela donne en console:

Python 2.6.4 (r264:75708, Oct 26 2009, 08:23:19) [MSC v.1500 32 bit (Intel)] on
win32
Type "help", "copyright", "credits" or "license" for more information.
>>> from pyconsole import pyConsole
>>> pyc = pyConsole()
>>> pyc.insercmd('dir')
[ blabla ]
>>> retour = pyc.insercmd('dir')

Tu te retrouve donc avec une fenêtre 'pseudo' dos qui te retourne stdin, stdout et stderr et est utilisable en direct.

C'est juste une idée mais chez moi le code marche.

@+

Edit : j'avais foiré mon copier/coller

[PauseKawa]

Bonjour KINENVEU,

Regarde du coté des expect écris en python.

Voici un exemple, malheureusement limité à Linux du fait de l'utilisation de tty. Je suis sur que quelqu'un a fais de même pour Windows mais il vas falloir chercher.

Voila ce que cela donne a l'utilisation:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
   import pexpect
   child = pexpect.spawn ('ftp ftp.openbsd.org')
   child.expect ('Name .*: ')
   child.sendline ('anonymous')
   child.expect ('Password:')
   child.sendline ('noah@example.com')
   child.expect ('ftp> ')
   child.sendline ('ls /pub/OpenBSD/')
   child.expect ('ftp> ')
   print child.before   # Print the result of the ls command.
   child.interact()     # Give control of the child to the user.

Ou encore ici en tcl/tk pour Windows avec pour résultat :

Code :

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

1
2
3
4
 spawn cmd.exe
 exp_send "ftp.exe\r"
 expect ">"
 exp_send "open ftp.example.com\r"

Sinon comme dit plus haut subprocess + Text de tkinter donne quelque chose de proche de ce que tu recherche.
Regarde du coté du virtualconsol.py du projet ohraimer de vincent.mbg.

En gros cela donne dans ton cas :

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
#! /usr/bin/env/ python
# -*- coding: utf-8 -*-
 
 
from platform import python_version
is_version_3 = python_version().startswith( '3' )
 
if is_version_3 :
    from tkinter import Text, StringVar, TclError
else :
    from Tkinter import Text, StringVar, TclError    
 
from subprocess import Popen, PIPE
import re
 
class pyConsole(Text) :
    def __init__( self, master=None, prompt = "> ", width=80, fg='white', bg='black') :
        Text.__init__( self, master, width=width, fg=fg, bg=bg, insertbackground=fg)
        self.prompt = prompt
        self.bind( "<BackSpace>", self.backspace)
        self.bind( "<Key-Return>",self.execute)
        self.bind( "<Key-Left>", self.left)
        self.bind( "<Key-Up>", self.rappelerLigne)
        self.bind( "<Key-Down>", self.rappelerLigne)
        self.bind( "<1>", self.button_1)
        self.bind( "<B1-Motion>", self.button_1)
        self.bind( "<B1-Leave>", lambda event : "break")
        self.bind( "<Double-1>", lambda event : "break") 
        self.bind( "<Triple-1>", lambda event : "break")
        self.bind( "<<Paste>>", self.insert_commande)
        self.insert( "end", self.prompt )
        self.start_commande = '1.0 + %d chars' % len( self.prompt )
        self.lignes = []
        self.numeroligne = 0
 
    def backspace( self, event ) :
        if int( self.index( "insert" ).split(".")[1] ) > len( self.prompt ) :
             self.delete('insert - 1 chars', 'insert')
        return "break"
 
 
    def button_1( self, event ) :
        last_index = self.index( "insert" )
        def testPosition( index ):
            if self.compare( "insert", "<=", "%d.%d" % ( float( self.index( "end" ) ), len( self.prompt ) ) ) :
                self.mark_set( "insert", index )  
        self.after_idle( testPosition, last_index )
 
    def execute( self, event, *args ) :
        commande = self.get()[:-1]
        if self.lignes == [] or self.lignes[-1] != commande and commande != "" :
            self.lignes.append( commande )
            self.numeroligne = len( self.lignes )
        self.insert(END, "\n")
        self.traite(commande)
        self.event_generate('<<command_interpreted>>')
        self.mark_start_commande()
        self.see( "end" )
        self.mark_set( "insert", "end" )
        return "break"
 
    def insert_commande(self, commande) :
        """ A corriger """
        if is_version_3 :
            if type(commande) is not str :
                try :
                    commande = self.clipboard_get()
                except TclError as e :
                    commande = "" 
        else :
            if type(commande) is not unicode :
                try :
                    commande = self.clipboard_get()
                except TclError as e :
                    commande = "" 
        self.insert(END, '\n'+self.prompt+commande+'\n')
        self.traite(commande)
        return "break"
 
    def left( self, event ) :
        if int(self.index("insert").split(".")[1]) <= len(self.prompt) :
            return "break"
 
    def mark_start_commande( self ):
        self.start_commande = self.index('end - 1 chars')
 
 
    def get( self, index1 = None, index2 = None ):
            if index1 is None :
                commande = Text.get(self, self.start_commande, 'end')
                return(commande)
            else :
                return(Text.get(self, index1, index2))
 
    def rappelerLigne(self, event) :
        if self.numeroligne != [] :
            if event.keysym == "Up" :
                self.numeroligne -= 1 
            else :
                self.numeroligne += 1
 
            if self.numeroligne < 0 :
                self.numeroligne = 0
            elif self.numeroligne > len(self.lignes) -1 :
                self.numeroligne = len(self.lignes) -1
            else :
                self.delete("end - 1 line", "end - 1 char")
                self.insert("end", self.prompt + self.lignes[self.numeroligne])                
        return "break"
 
    def traite(self, commande):
        if commande == 'cls' or commande == 'clear': self.clean()
        elif commande.lower == 'exit' or commande == 'quit': self.quit()
        else:
            p = Popen([commande], shell=True, stdout=PIPE, stderr=PIPE)
            output, errors = p.communicate()
            retour = []
            if errors: leretour=errors
            else: leretour=output
            self.insert(END, leretour)
            leretour = leretour.split('\n')
            for elems in leretour:
                retour.append(elems)
            self.insert(END, self.prompt)
            return retour
 
    def clean(self):
        """ Traitement cls/clear """
        self.delete(1.0, END)
        self.insert(END, self.prompt)
 
    def quit(self):
        """ Traitement exit/quit """
        self.destroy()
 
    """ Appels externes """
    def insercmd(self, cmd):
        self.insert(END, '\n'+self.prompt)
        self.insert(END, cmd+'\n')
        retour = self.traite(cmd)
        return retour
 
if __name__ == '__main__' :
    if is_version_3 :
        from tkinter import *
    else :
        from Tkinter import *
 
    def mescommandes():
        reponse1 = pyc.insercmd('dir')
        reponse2 = pyc.insercmd('cls')
        print (reponse1)
        print (reponse2)
 
    root = Tk()
    pyc = pyConsole(root)
    pyc.pack()
    Button(root, text='Test', command=mescommandes).pack()
    root.mainloop()

@+