appel MS-DOS a partir de os

Version imprimable

22/03/2010, 07h31
KINENVEU

appel MS-DOS a partir de os
bonjour,

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

je fais par exemple :
Code:

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.
22/03/2010, 18h48
miawaw
Dans l'invite de commande de W. si tu tapes

Code:

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:

1 2 cmd= "start cmd /K file.bat" os.system(cmd)
:mrgreen:
23/03/2010, 05h14
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. :ccool:
merci.
23/03/2010, 08h09
PauseKawa

Bonjour,

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

@+
25/03/2010, 05h04
KINENVEU

non, ce n'est pas cela que je cherche.
:cry:
25/03/2010, 22h59
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:

os.system('cmd')

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

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)

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:

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:

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 :roll:

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:

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:

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:

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()