Comment passer une chaîne dans subprocess.Popen (en utilisant l'argument stdin)?

Si je fais ce qui suit:

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

Je reçois:

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'

Apparemment, un objet cStringIO.StringIO ne s'active pas assez près d'un canard de fichier pour convenir à subprocess.Popen. Comment contourner cela?

Popen.communicate() Documentation:

Notez que si vous souhaitez envoyer des données au stdin du processus, vous devez créer l'objet Popen avec stdin = PIPE. De même, pour obtenir autre chose que None dans le tuple de résultat, vous devez également indiquer stdout = PIPE et / ou stderr = PIPE.

Remplacement de os.popen *

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

Avertissement Utilisez communic () plutôt que stdin.write (), stdout.read () ou stderr.read () pour éviter les blocages dus à l'un des autres tampons de tuyau du système d'exploitation qui se remplissent et bloquent le processus enfant.

Ainsi, votre exemple pourrait être écrit comme suit:

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
# ->

Sur la version actuelle de Python 3, vous pouvez utiliser subprocess.run, pour passer l'entrée sous forme de chaîne à une commande externe et obtenir son état de sortie, et sa sortie sous forme de chaîne en un seul appel:

#!/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
# -> 

J'ai compris cette solution de contournement:

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

Y en a t-il un meilleur?

Je suis un peu surpris que personne n'ait suggéré de créer un pipe, ce qui est à mon avis le moyen le plus simple de passer une chaîne à stdin d'un sous-processus:

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

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

Il existe une belle solution si vous utilisez Python 3.4 ou mieux. Utilisez l' inputargument au lieu de l' stdinargument, qui accepte un argument octets:

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

Cela fonctionne pour check_outputet run, mais pas callou check_callpour une raison quelconque.

J'utilise python3 et j'ai découvert que vous devez encoder votre chaîne avant de pouvoir la passer dans 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)

Apparemment, un objet cStringIO.StringIO ne s'active pas assez près d'un canard de fichier pour convenir au sous-processus.

J'ai bien peur que non. Le canal est un concept de système d'exploitation de bas niveau, il nécessite donc absolument un objet fichier qui est représenté par un descripteur de fichier de niveau système d'exploitation. Votre solution de contournement est la bonne.

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

Attention, cela Popen.communicate(input=s)peut vous poser des problèmes s'il sest trop volumineux, car apparemment le processus parent le tamponnera avant de bifurquer le sous-processus enfant, ce qui signifie qu'il a besoin de "deux fois plus" de mémoire utilisée à ce stade (au moins selon l'explication "sous le capot") et la documentation liée trouvée ici ). Dans mon cas particulier, sétait un générateur qui a d'abord été entièrement développé et ensuite seulement écrit, de stdinsorte que le processus parent était énorme juste avant la naissance de l'enfant, et aucune mémoire n'était laissée pour le bifurquer:

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)

Sur Python 3.7+, procédez comme suit:

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

et vous voudrez probablement ajouter capture_output=Truepour obtenir la sortie de l'exécution de la commande sous forme de chaîne.

Sur les anciennes versions de Python, remplacez text=Truepar universal_newlines=True:

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