मैं पाइथन इटरेटर से उपप्रोसेस के मानक इनपुट को कैसे खिला सकता हूं?

Question

मैं मानक इनपुट पढ़ने और स्ट्रीमिंग फैशन में मानक आउटपुट लिखने वाली प्रक्रिया के साथ संवाद करने के लिए पायथन में subprocess मॉड्यूल का उपयोग करने का प्रयास कर रहा हूं। मैं एक पुनरावर्तक से subprocess पढ़ने लाइनों को चाहते हैं जो इनपुट उत्पन्न करता है, और फिर उपप्रोसेसर से आउटपुट लाइनों को पढ़ता है। इनपुट और आउटपुट लाइनों के बीच एक-से-एक पत्राचार नहीं हो सकता है। मैं एक मनमानी इटरेटर से एक उपप्रोसेसर कैसे खिला सकता हूं जो स्ट्रिंग देता है?

यहाँ कुछ उदाहरण कोड है कि एक साधारण परीक्षण का मामला देता है, और कुछ तरीकों मैंने कोशिश की है कि किसी न किसी कारण के लिए काम नहीं करते:

#!/usr/bin/python 
from subprocess import * 
# A really big iterator 
input_iterator = ("hello %s\n" % x for x in xrange(100000000)) 

# I thought that stdin could be any iterable, but it actually wants a 
# filehandle, so this fails with an error. 
subproc = Popen("cat", stdin=input_iterator, stdout=PIPE) 

# This works, but it first sends *all* the input at once, then returns 
# *all* the output as a string, rather than giving me an iterator over 
# the output. This uses up all my memory, because the input is several 
# hundred million lines. 
subproc = Popen("cat", stdin=PIPE, stdout=PIPE) 
output, error = subproc.communicate("".join(input_iterator)) 
output_lines = output.split("\n") 

तो मेरी उपप्रक्रिया एक से पढ़ा कि कैसे मैं कर सकते हैं रेखा से इटरेटर लाइन जब मैं लाइन से अपनी stdout लाइन से पढ़ा?

Answer 1

आसान तरीका कांटा लग रहा है और बाल प्रक्रिया से इनपुट हैंडल फ़ीड करता है। क्या कोई ऐसा करने के किसी भी संभावित डाउनसाइड्स पर विस्तार कर सकता है? या क्या पाइथन मॉड्यूल हैं जो इसे आसान और सुरक्षित बनाते हैं?

#!/usr/bin/python 
from subprocess import * 
import os 

def fork_and_input(input, handle): 
    """Send input to handle in a child process.""" 
    # Make sure input is iterable before forking 
    input = iter(input) 
    if os.fork(): 
     # Parent 
     handle.close() 
    else: 
     # Child 
     try: 
      handle.writelines(input) 
      handle.close() 
     # An IOError here means some *other* part of the program 
     # crashed, so don't complain here. 
     except IOError: 
      pass 
     os._exit() 

# A really big iterator 
input_iterator = ("hello %s\n" % x for x in xrange(100000000)) 

subproc = Popen("cat", stdin=PIPE, stdout=PIPE) 
fork_and_input(input_iterator, subproc.stdin) 

for line in subproc.stdout: 
    print line, 

Answer 2

this recipe का पालन करें यह उप-प्रोसेस पर एक ऐड-ऑन है जो एसिंक्रोनस I/O का समर्थन करता है। यह अभी भी आवश्यक है कि आपका सबप्रोसेस प्रत्येक इनपुट लाइन या लाइनों के समूह को इसके आउटपुट के हिस्से के साथ प्रतिक्रिया दे।

Answer 3

एक अजगर पुनरावर्तक से एक उपप्रक्रिया के मानक इनपुट फ़ीड करने के लिए:

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

with Popen("sink", stdin=PIPE, bufsize=-1) as process: 
    for chunk in input_iterator: 
     process.stdin.write(chunk) 

आप एक ही समय तो कम से उत्पादन की जरूरत threads या async.io में पढ़ना चाहते हैं:

#!/usr/bin/env python3 
import asyncio 
import sys 
from asyncio.subprocess import PIPE 
from contextlib import closing 

async def writelines(writer, lines): 
    # NOTE: can't use writer.writelines(lines) here because it tries to write 
    # all at once 
    with closing(writer): 
     for line in lines: 
      writer.write(line) 
      await writer.drain() 

async def main(): 
    input_iterator = (b"hello %d\n" % x for x in range(100000000)) 
    process = await asyncio.create_subprocess_exec("cat", stdin=PIPE, stdout=PIPE) 
    asyncio.ensure_future(writelines(process.stdin, input_iterator)) 
    async for line in process.stdout: 
     sys.stdout.buffer.write(line) 
    return await process.wait() 

if sys.platform == 'win32': 
    loop = asyncio.ProactorEventLoop() # for subprocess' pipes on Windows 
    asyncio.set_event_loop(loop) 
else: 
    loop = asyncio.get_event_loop() 
with closing(loop): 
    sys.exit(loop.run_until_complete(main()))