Как воспроизвести поведение тройника в Python при использовании подпроцесса?

Я вижу, что это довольно старый пост, но на всякий случай кто-то все еще ищет способ сделать это:

proc = subprocess.Popen(["ping", "localhost"], 
                        stdout=subprocess.PIPE, 
                        stderr=subprocess.PIPE)

with open("logfile.txt", "w") as log_file:
  while proc.poll() is None:
     line = proc.stderr.readline()
     if line:
        print "err: " + line.strip()
        log_file.write(line)
     line = proc.stdout.readline()
     if line:
        print "out: " + line.strip()
        log_file.write(line)

Если требование python 3.6 не является проблемой, теперь есть способ сделать это с помощью asyncio. Этот метод позволяет вам захватывать stdout и stderr по отдельности, но при этом оба потока будут передаваться на tty без использования потоков. Вот примерный план:

class RunOutput():
    def __init__(self, returncode, stdout, stderr):
        self.returncode = returncode
        self.stdout = stdout
        self.stderr = stderr

async def _read_stream(stream, callback):
    while True:
        line = await stream.readline()
        if line:
            callback(line)
        else:
            break

async def _stream_subprocess(cmd, stdin=None, quiet=False, echo=False) -> RunOutput:
    if isWindows():
        platform_settings = {'env': os.environ}
    else:
        platform_settings = {'executable': '/bin/bash'}

    if echo:
        print(cmd)

    p = await asyncio.create_subprocess_shell(cmd,
                                              stdin=stdin,
                                              stdout=asyncio.subprocess.PIPE,
                                              stderr=asyncio.subprocess.PIPE,
                                              **platform_settings)
    out = []
    err = []

    def tee(line, sink, pipe, label=""):
        line = line.decode('utf-8').rstrip()
        sink.append(line)
        if not quiet:
            print(label, line, file=pipe)

    await asyncio.wait([
        _read_stream(p.stdout, lambda l: tee(l, out, sys.stdout)),
        _read_stream(p.stderr, lambda l: tee(l, err, sys.stderr, label="ERR:")),
    ])

    return RunOutput(await p.wait(), out, err)


def run(cmd, stdin=None, quiet=False, echo=False) -> RunOutput:
    loop = asyncio.get_event_loop()
    result = loop.run_until_complete(
        _stream_subprocess(cmd, stdin=stdin, quiet=quiet, echo=echo)
    )

    return result

Приведенный выше код основан на этом сообщении в блоге: https://kevinmccarthy.org/2016/07/25/streaming-subprocess-stdin-and-stdout-with-asyncio-in-python/

Это простой перенос tee на Python.

import sys
sinks = sys.argv[1:]
sinks = [open(sink, "w") for sink in sinks]
sinks.append(sys.stderr)
while True:
  input = sys.stdin.read(1024)
  if input:
    for sink in sinks:
      sink.write(input)
  else:
    break

Я сейчас работаю на Linux, но это должно работать на большинстве платформ.

Теперь что касается части subprocess, я не знаю, как вы хотите «связать» stdin, stdout и stderr подпроцесса с вашими stdin, stdout, stderr и приемниками файлов, но я знаю, что вы можете сделать это:

import subprocess
callee = subprocess.Popen( ["python", "-i"],
                           stdin = subprocess.PIPE,
                           stdout = subprocess.PIPE,
                           stderr = subprocess.PIPE
                         )

Теперь вы можете получить доступ к callee.stdin, _ 12_ и _ 13_ как обычные файлы, позволяя вышеуказанному" решению "работать. Если вы хотите получить callee.returncode, вам необходимо сделайте дополнительный вызов callee.poll().

Будьте осторожны при записи в callee.stdin: если процесс завершился, когда вы это сделаете, может возникнуть ошибка (в Linux я получаю IOError: [Errno 32] Broken pipe).

Вот как это можно сделать

import sys
from subprocess import Popen, PIPE

with open('log.log', 'w') as log:
    proc = Popen(["ping", "google.com"], stdout=PIPE, encoding='utf-8')
    while proc.poll() is None:
        text = proc.stdout.readline() 
        log.write(text)
        sys.stdout.write(text)

Если вы не хотите взаимодействовать с процессом, вы можете использовать модуль подпроцесса.

Пример:

tester.py

import os
import sys

for file in os.listdir('.'):
    print file

sys.stderr.write("Oh noes, a shrubbery!")
sys.stderr.flush()
sys.stderr.close()

testing.py

import subprocess

p = subprocess.Popen(['python', 'tester.py'], stdout=subprocess.PIPE,
                     stdin=subprocess.PIPE, stderr=subprocess.PIPE)

stdout, stderr = p.communicate()
print stdout, stderr

В вашей ситуации вы можете просто сначала записать stdout / stderr в файл. Вы также можете отправлять аргументы своему процессу с помощью связи, хотя я не мог понять, как постоянно взаимодействовать с подпроцессом.

Мое решение не изящно, но работает.

Вы можете использовать powershell, чтобы получить доступ к «тройнику» под WinOS.

import subprocess
import sys

cmd = ['powershell', 'ping', 'google.com', '|', 'tee', '-a', 'log.txt']

if 'darwin' in sys.platform:
    cmd.remove('powershell')

p = subprocess.Popen(cmd)
p.wait()