Persistant python sous-processus

Est-il un moyen de faire un sous-processus d'appel en python "persistante"? Je suis d'appeler un programme qui prend un certain temps à charger plusieurs fois. Donc, ce serait formidable si je pouvais quitter le programme de l'ouvrir et de communiquer avec lui sans le tuer.

Le dessin animé version de mon script python ressemble à ceci:

for text in textcollection:
    myprocess = subprocess.Popen(["myexecutable"],
                stdin = subprocess.PIPE, stdout = subprocess.PIPE,
                stderr = None)
    myoutputtext, err = myprocess.communicate(input=text)

J'ai besoin de traiter chaque texte séparément, afin de rejoindre tous en un seul gros fichier texte, puis de les traiter une fois n'est pas une option.

De préférence, si il y a une option de ce genre

myprocess = subprocess.Popen(["myexecutable"],
            stdin = subprocess.PIPE, stdout = subprocess.PIPE,
            stderr = None)    for text in textcollection:
for text in textcollection:
    myoutputtext, err = myprocess.communicate(input=text)

où je peux laisser ouvert le processus, j'apprécierais vraiment.

OriginalL'auteur JasonMond | 2012-01-23

python subprocess

24

Vous pouvez utiliser myprocess.stdin.write() et myprocess.stdout.read() à communiquer avec votre sous-processus, vous avez juste besoin d'être prudent et assurez-vous de la poignée de mise en mémoire tampon correctement pour éviter que vos appels à partir de blocage.

Si la sortie de votre sous-processus bien défini, vous devriez être en mesure de communiquer de manière fiable à l'aide de la ligne de mise en mémoire tampon et myprocess.stdout.readline().

Voici un exemple:
```
>>> p = subprocess.Popen(['cat'], bufsize=1, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
>>> p.stdin.write('hello world\n')
>>> p.stdout.readline()
'hello world\n'
>>> p.stdout.readline()        # THIS CALL WILL BLOCK
```
Une alternative à cette méthode pour Unix est de mettre le descripteur de fichier en mode sans blocage, ce qui vous permettra d'appeler des fonctions comme myprocess.stdout.read() et de l'avoir de retour de données si elle existe, ou de soulever une IOError si il n'y a pas toutes les données:
```
>>> p = subprocess.Popen(['cat'], stdin=subprocess.PIPE, stdout=subprocess.PIPE)
>>> import fcntl, os
>>> fcntl.fcntl(p.stdout.fileno(), fcntl.F_SETFL, os.O_NONBLOCK)
0
>>> p.stdout.read()         # raises an exception instead of blocking
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IOError: [Errno 11] Resource temporarily unavailable
```
Cela vous permettrait de faire quelque chose comme ceci:
```
fcntl.fcntl(p.stdout.fileno(), fcntl.F_SETFL, os.O_NONBLOCK)
for text in textcollection:
    myprocess.stdin.write(text + '\n')
    while True:
        myoutputtext = ''
        try:
            myoutputtext += myprocess.stdout.read()
        except IOError:
            pass
        if validate_output(myoutputtext):
            break
        time.sleep(.1)    # short sleep before attempting another read
```
Dans cet exemple, validate_output() est une fonction que vous auriez besoin d'écrire qui renvoie True si les données que vous avez reçues jusqu'à présent sont tous de sortie que vous prévoyez d'obtenir.

Merci! J'aime votre solution la meilleure, car il ne nécessite pas de téléchargement de tiers. Malheureusement, il ne fonctionne pas pour moi. Après avoir essayé un certain nombre de choses, je suis sûr que c'est un problème avec le programme java je vais appeler plutôt que de votre solution, de sorte que votre solution est la bonne.
Pourquoi la baisse de vote?
C'était par erreur. Mon upvote est inactif jusqu'à ce que quelque chose va être édité, mais je ne vois rien à améliorer ou à ne pas faire de mal. Réponse parfaite.
pas de problème, merci pour la réponse 🙂 Juste fait une modification mineure.

OriginalL'auteur Andrew Clark
5

C'est l'appel à communicate() qui est en train de tuer votre sous-processus. Selon le sous-processus de la documentation la communicate() méthode:

Interagir avec les processus: Envoyer des données à l'entrée standard. Lire des données à partir de stdout et stderr, jusqu'à la fin de fichier est atteinte. Attendre la fin du processus.

Ce que vous voulez faire est d'interagir directement avec le POpen de l'objet stdin et stdout propriétés de communiquer directement avec les sous-processus. Toutefois, la documentation déconseille ce dicton:

Avertissement: l'Utilisation de communiquer() plutôt que .stdin.écrire, .la sortie standard stdout.lire ou .stderr.lire pour éviter les blocages dus à l'un des autres OS pipe tampons de remplissage et le blocage du processus enfant.

Donc, vous avez besoin pour mettre en œuvre vos propres solutions pour contourner les blocages potentiels, ou dans l'espoir que quelqu'un a écrit un asynchrone sous-processus module pour vous.

Edit: Voici un rapide n'dirty exemple de la façon asynchrone sous-processus module peut être utilisé:
```
import asyncsubprocess

textcollection = ['to', 'be', 'or', 'not', 'to be', 'that is the', 'question']

myprocess = asyncsubprocess.Popen(["cat"],
     stdin = asyncsubprocess.PIPE,
     stdout = asyncsubprocess.PIPE,
     stderr = None)

for text in textcollection:
    bytes_sent, myoutput, err = myprocess.listen(text)
    print text, bytes_sent, myoutput, err
```
Lorsque je l'exécute, il imprime:
```
to 2 to 
be 2 be 
or 2 or 
not 3 not 
to be 5 to be 
that is the 11 that is the 
question 8 question 
```
OriginalL'auteur srgerg
1

Je pense que vous êtes à la recherche pour
```
myprocess.stdin.write(text)
```
vous pouvez créer une liste de Popens et ensuite appeler communiquer sur chaque élément dans une autre boucle.
quelque chose comme ceci
```
processes=[]
for text in textcollection:
    myprocess = subprocess.Popen(["myexecutable"],
                stdin = subprocess.PIPE, stdout = subprocess.PIPE,
                stderr = None)
    myprocess.stdin.write(text)
    processes.append(myprocess)

for proc in processes:
    myoutput, err=proc.communicate()
    #do something with the output here
```
de cette façon, il n'aura pas à attendre jusqu'à ce que tous les Popens ont commencé

Malheureusement, cela ne fonctionne pas pour moi parce que c'est un programme java qui mange à propos de la 3G de mémoire sur chaque course. C'est pourquoi il faut tellement de temps à charger. Je ne peux pas avoir de 5000 cas de 3G processus.
Je crois que je comprends. Après la saisie du texte, il affiche quelque chose et puis quitte? ou faut-il attendre pour vous de saisir quelque chose d'autre
Il génère ensuite des sorties.

OriginalL'auteur Ryan Haining

-2

if os.name == 'nt':
 startupinfo = subprocess.STARTUPINFO()
 startupinfo.dwFlags |= subprocess._subprocess.STARTF_USESHOWWINDOW
 subprocess.call(os.popen(tempFileName), shell=True)
 os.remove(tempFileName)

OriginalL'auteur imp

Vous devez vous connecter pour publier un commentaire.