Python - ¿Cómo paso una cadena al subproceso.Popen (usando el argumento stdin)?

Question

Si hago lo siguiente:

import subprocess 
from cStringIO import StringIO 
subprocess.Popen(['grep','f'],stdout=subprocess.PIPE,stdin=StringIO('one\ntwo\nthree\nfour\nfive\nsix\n')).communicate()[0] 

me sale:

Traceback (most recent call last): 
    File "<stdin>", line 1, in ? 
    File "/build/toolchain/mac32/python-2.4.3/lib/python2.4/subprocess.py", line 533, in __init__ 
    (p2cread, p2cwrite, 
    File "/build/toolchain/mac32/python-2.4.3/lib/python2.4/subprocess.py", line 830, in _get_handles 
    p2cread = stdin.fileno() 
AttributeError: 'cStringIO.StringI' object has no attribute 'fileno' 

parecer un objeto cStringIO.StringIO no Quack lo suficientemente cerca de un pato archivo para que se adapte subprocess.Popen. ¿Cómo trabajo alrededor de esto?

Answer 1

Popen.communicate() documentación:

Tenga en cuenta que si desea enviar datos a entrada estándar del proceso, es necesario crear el objeto Popen con entrada estándar = PIPE. De forma similar, para obtener que no sea None en la tupla de resultado, , debe indicar stdout = PIPE y/o stderr = PIPE también.

Sustitución os.popen *

pipe = os.popen(cmd, 'w', bufsize) 
    # ==> 
    pipe = Popen(cmd, shell=True, bufsize=bufsize, stdin=PIPE).stdin 

Advertencia Uso comunicarse() en lugar de stdin.write(), stdout.read() o stderr.read() para evitar interbloqueos debido a a cualquiera de las otras memorias intermedias de canal del sistema operativo llenando y bloqueando el proceso secundario.

Así que su ejemplo se podría escribir de la siguiente manera:

from subprocess import Popen, PIPE, STDOUT 

p = Popen(['grep', 'f'], stdout=PIPE, stdin=PIPE, stderr=STDOUT)  
grep_stdout = p.communicate(input=b'one\ntwo\nthree\nfour\nfive\nsix\n')[0] 
print(grep_stdout.decode()) 
# -> four 
# -> five 
# -> 

---

En la versión actual de Python 3, se puede usar subprocess.run, para pasar de entrada como una cadena a un comando externo y obtener su estado de salida, y su salida como una cadena de nuevo en una llamada:

#!/usr/bin/env python3 
from subprocess import run, PIPE 

p = run(['grep', 'f'], stdout=PIPE, 
     input='one\ntwo\nthree\nfour\nfive\nsix\n', encoding='ascii') 
print(p.returncode) 
# -> 0 
print(p.stdout) 
# -> four 
# -> five 
# -> 

Answer 2

me di cuenta de esta solución:

>>> p = subprocess.Popen(['grep','f'],stdout=subprocess.PIPE,stdin=subprocess.PIPE) 
>>> p.stdin.write(b'one\ntwo\nthree\nfour\nfive\nsix\n') #expects a bytes type object 
>>> p.communicate()[0] 
'four\nfive\n' 
>>> p.stdin.close() 

¿Hay una mejor?

Answer 3

"Al parecer un objeto cStringIO.StringIO no charlatán lo suficientemente cerca de un pato archivo para que se adapte subprocess.Popen"

:-)

no tengo miedo. El conducto es un concepto de sistema operativo de bajo nivel, por lo que requiere absolutamente un objeto de archivo que esté representado por un descriptor de archivo de nivel de sistema operativo. Su solución alternativa es la correcta.

Answer 4

p = Popen(['grep', 'f'], stdout=PIPE, stdin=PIPE, stderr=STDOUT)  
p.stdin.write('one\n') 
time.sleep(0.5) 
p.stdin.write('two\n') 
time.sleep(0.5) 
p.stdin.write('three\n') 
time.sleep(0.5) 
testresult = p.communicate()[0] 
time.sleep(0.5) 
print(testresult) 

Answer 5

from subprocess import Popen, PIPE 
from tempfile import SpooledTemporaryFile as tempfile 
f = tempfile() 
f.write('one\ntwo\nthree\nfour\nfive\nsix\n') 
f.seek(0) 
print Popen(['/bin/grep','f'],stdout=PIPE,stdin=f).stdout.read() 
f.close() 

Answer 6

""" 
Ex: Dialog (2-way) with a Popen() 
""" 

p = subprocess.Popen('Your Command Here', 
       stdout=subprocess.PIPE, 
       stderr=subprocess.STDOUT, 
       stdin=PIPE, 
       shell=True, 
       bufsize=0) 
p.stdin.write('START\n') 
out = p.stdout.readline() 
while out: 
    line = out 
    line = line.rstrip("\n") 

    if "WHATEVER1" in line: 
     pr = 1 
     p.stdin.write('DO 1\n') 
     out = p.stdout.readline() 
     continue 

    if "WHATEVER2" in line: 
     pr = 2 
     p.stdin.write('DO 2\n') 
     out = p.stdout.readline() 
     continue 
""" 
.......... 
""" 

out = p.stdout.readline() 

p.wait() 

Answer 7

Mira que Popen.communicate(input=s) le puede dar problemas si s es demasiado grande, porque al parecer el proceso padre amortiguará que antes bifurcar el subproceso niño, lo que significa que necesita "dos veces más" que se utiliza la memoria en ese momento (al menos de acuerdo con la explicación "debajo del capó" y la documentación vinculada encontró here). En mi caso particular, s era un generador que fue primero completamente expandido y sólo entonces escrito a stdin por lo que el proceso padre era enorme justo antes de que el niño fue engendrado, y sin memoria fue dejado al tenedor que:

File "/opt/local/stow/python-2.7.2/lib/python2.7/subprocess.py", line 1130, in _execute_child self.pid = os.fork() OSError: [Errno 12] Cannot allocate memory

Answer 8

estoy usando python3 y descubrí que lo que necesita para codificar la cadena antes de pasarlo a la entrada estándar:

p = Popen(['grep', 'f'], stdout=PIPE, stdin=PIPE, stderr=PIPE) 
out, err = p.communicate(input='one\ntwo\nthree\nfour\nfive\nsix\n'.encode()) 
print(out) 

Answer 9

estoy un poco sorprendido de que nadie sugirió la creación de una tubería, que es en mi opinión el extremo forma más sencilla de pasar una cadena a stdin de un subproceso:

read, write = os.pipe() 
os.write(write, "stdin input here") 
os.close(write) 

subprocess.check_call(['your-command'], stdin=read) 

Answer 10

Existe una hermosa solución si usa Python 3.4 o superior. Utilice el argumento input en lugar del argumento stdin, que acepta un argumento de bytes:

output = subprocess.check_output(
    ["sed", "s/foo/bar/"], 
    input=b"foo", 
)