Entrée / sortie interactive en utilisant python

J'ai un programme qui interagit avec l'utilisateur (agit comme un shell), et je veux l'exécuter à l'aide de python sous-processus module de manière interactive.
Cela signifie que, je veux la possibilité d'écrire sur stdin et obtenir immédiatement la sortie de la sortie standard stdout. J'ai essayé plusieurs solutions, mais aucune ne semble fonctionner pour mes besoins.

Le code que j'ai rédigé sur la base L'exécution d'une commande interactive de l'intérieur python

import Queue
import threading
import subprocess
def enqueue_output(out, queue):
    for line in iter(out.readline, b''):
        queue.put(line)
    out.close()

def getOutput(outQueue):
    outStr = ''
    try:
        while True: #Adds output from the Queue until it is empty
            outStr+=outQueue.get_nowait()

    except Queue.Empty:
        return outStr

p = subprocess.Popen("./a.out", stdin=subprocess.PIPE, stout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize = 1)
#p = subprocess.Popen("./a.out", stdin=subprocess.PIPE, stout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False, universal_newlines=True)

outQueue = Queue()
errQueue = Queue()

outThread = Thread(target=enqueue_output, args=(p.stdout, outQueue))
errThread = Thread(target=enqueue_output, args=(p.stderr, errQueue))

outThread.daemon = True
errThread.daemon = True

outThread.start()
errThread.start()

p.stdin.write("1\n")
p.stdin.flush()
errors = getOutput(errQueue)
output = getOutput(outQueue)

p.stdin.write("5\n")
p.stdin.flush()
erros = getOutput(errQueue)
output = getOutput(outQueue)

Le problème est que la file d'attente est vide, comme si il n'y a pas de sortie.
Seulement si j'écris à stdin tous les commentaires que le programme doit s'exécuter et de mettre fin, puis-je obtenir la sortie (ce qui n'est pas ce que je veux). Par exemple, si je fais quelque chose comme:

p.stdin.write("1\n5\n")
errors = getOutput(errQueue)
output = getOutput(outQueue)

Est-il possible de faire ce que je veux faire?

EDIT:
Le script sera exécuté sur une machine Linux.
J'ai modifié mon script et supprimé le universal_newlines=Vrai + définir la bufsize à 1 et vidées stdin immédiatement après wrtie. Encore je n'ai pas de sortie.

Deuxième essai:
J'ai essayé cette solution et ça fonctionne pour moi:

from subprocess import Popen, PIPE

fw = open("tmpout", "wb")
fr = open("tmpout", "r")
p = Popen("./a.out", stdin = PIPE, stdout = fw, stderr = fw, bufsize = 1)
p.stdin.write("1\n")
out = fr.read()
p.stdin.write("5\n")
out = fr.read()
fw.close()
fr.close()

source d'informationauteur Talor Abramovich | 2013-11-09

  1. 12

    Deux solutions pour ce problème sur Linux:

    Première est d'utiliser un fichier d'écrire la sortie de, et de lire simultanément:

    from subprocess import Popen, PIPE

fw = open("tmpout", "wb")
fr = open("tmpout", "r")
p = Popen("./a.out", stdin = PIPE, stdout = fw, stderr = fw, bufsize = 1)
p.stdin.write("1\n")
out = fr.read()
p.stdin.write("5\n")
out = fr.read()
fw.close()
fr.close()

    Seconde, comme J. F. Sebastian offert, est de faire de la p.stdout et p.stderr tuyaux non-bloquant à l'aide de fnctl module:

    import os
import fcntl
from subprocess import Popen, PIPE  
def setNonBlocking(fd):
    """
    Set the file description of the given file descriptor to non-blocking.
    """
    flags = fcntl.fcntl(fd, fcntl.F_GETFL)
    flags = flags | os.O_NONBLOCK
    fcntl.fcntl(fd, fcntl.F_SETFL, flags)

p = Popen("./a.out", stdin = PIPE, stdout = PIPE, stderr = PIPE, bufsize = 1)
setNonBlocking(p.stdout)
setNonBlocking(p.stderr)

p.stdin.write("1\n")
while True:
    try:
        out1 = p.stdout.read()
    except IOError:
        continue
    else:
        break
out1 = p.stdout.read()
p.stdin.write("5\n")
while True:
    try:
        out2 = p.stdout.read()
    except IOError:
        continue
    else:
        break