¿Cómo paso una cadena en subprocess.Popen (usando el argumento stdin)?

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]

Yo obtengo:

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'

Aparentemente, un objeto cStringIO.StringIO no se acerca lo suficientemente cerca de un archivo duck como para adaptarse al subproceso. ¿Cómo evito esto?

Popen.communicate() documentación:

Tenga en cuenta que si desea enviar datos al stdin del proceso, debe crear el objeto Popen con stdin = PIPE. Del mismo modo, para obtener algo más que Ninguno en la tupla de resultados, debe proporcionar stdout = PIPE y / o stderr = PIPE también.

Sustitución de os.popen *

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

Advertencia Utilice comunicar () en lugar de stdin.write (), stdout.read () o stderr.read () para evitar puntos muertos debido a que cualquiera de los otros buffers de tuberías del sistema operativo se llenan y bloquean el proceso secundario.

Entonces su ejemplo podría escribirse 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, puede usar subprocess.run, para pasar la 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
# -> 

Descubrí esta solución alternativa:

>>> 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 alguno mejor?

Estoy un poco sorprendido de que nadie haya sugerido crear una tubería, que en mi opinión es la forma más simple 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)

Hay una solución hermosa si estás usando Python 3.4 o mejor. Use el inputargumento en lugar del stdinargumento, que acepta un argumento de bytes:

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

Esto funciona para check_outputy run, pero no callo check_callpor alguna razón.

Estoy usando python3 y descubrí que necesitas codificar tu cadena antes de poder pasarla a stdin:

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)

Aparentemente, un objeto cStringIO.StringIO no se acerca demasiado a un pato de archivo como para adaptarse al subproceso.

Me temo que no. La canalización 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 es la correcta.

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

Tenga en cuenta que Popen.communicate(input=s)puede causarle problemas si ses demasiado grande, porque aparentemente el proceso principal lo amortiguará antes de bifurcar el subproceso secundario, lo que significa que necesita "el doble" de memoria usada en ese momento (al menos de acuerdo con la explicación "bajo el capó" y documentación vinculada que se encuentra aquí ). En mi caso particular, sfue un generador que primero se expandió por completo y solo luego se escribió para stdinque el proceso principal fuera enorme justo antes de que se generara el hijo, y no quedara memoria para bifurcarlo:

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

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

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)

En Python 3.7+ haz esto:

my_data = "whatever you want\nshould match this f"
subprocess.run(["grep", "f"], text=True, input=my_data)

y probablemente desee agregar capture_output=Truepara obtener el resultado de ejecutar el comando como una cadena.

En versiones anteriores de Python, reemplace text=Truecon universal_newlines=True:

subprocess.run(["grep", "f"], universal_newlines=True, input=my_data)