मैं कैसे 'वास्तविक समय की जानकारी वापस एक subprocess.Popen से अजगर में मिलता है (2.5)

Question

मैं निम्नलिखित तरीके से उपप्रक्रिया मॉड्यूल का उपयोग करना चाहते हैं:

1. है कि संभावित एक नई प्रक्रिया बनाने निष्पादित करने में लंबा समय लगता है।
2. कब्जा stdout (या stderr, या संभवतः दोनों, या तो एक साथ या अलग से)
3. उपप्रक्रिया से प्रक्रिया डेटा के रूप में यह में आता है, हर लाइन पर शायद फायरिंग की घटनाओं प्राप्त (wxPython में कहते हैं) या बस उन्हें बाहर मुद्रण अभी के लिए।

मैंने पॉपन के साथ प्रक्रियाएं बनाई हैं, लेकिन अगर मैं संचार का उपयोग करता हूं() प्रक्रिया समाप्त हो जाने के बाद, डेटा एक बार में आता है।

अगर मैं एक अलग थ्रेड कि एक अवरुद्ध myprocess.stdout की readline() (stdout = subprocess.PIPE उपयोग करते हुए) मैं या तो इस विधि के साथ किसी भी लाइनों नहीं मिलता, जब तक प्रक्रिया समाप्त हो जाता है करता है बनाएँ। (कोई फर्क नहीं पड़ता कि मैंने bufsize के रूप में क्या सेट किया है)

क्या इससे डरने का कोई तरीका है जो भयानक नहीं है, और कई प्लेटफार्मों पर अच्छा काम करता है?

Answer 1

stdout buffered किया जाएगा - तो आपको उस बफर भरने तक कुछ भी नहीं मिलेगा, या उपप्रोसेस निकलता है।

आप उप-प्रक्रिया से stdout फ़्लश करने या stderr का उपयोग करने, या गैर-बफर मोड पर stdout बदलने का प्रयास कर सकते हैं।

Answer 2

ऐसा लगता है कि समस्या उपप्रोसेसर द्वारा buffered आउटपुट का उपयोग हो सकती है - अगर अपेक्षाकृत कम मात्रा में आउटपुट बनाया जाता है, तो इसे उपप्रोसेस से बाहर तक बफर किया जा सकता है। कुछ पृष्ठभूमि here पाया जा सकता है: काम करने के लिए नहीं (खिड़कियों पर वैसे भी) प्रतीत होता है कि कोड के साथ

Answer 3

अद्यतन

class ThreadWorker(threading.Thread): 
    def __init__(self, callable, *args, **kwargs): 
     super(ThreadWorker, self).__init__() 
     self.callable = callable 
     self.args = args 
     self.kwargs = kwargs 
     self.setDaemon(True) 

    def run(self): 
     try: 
      self.callable(*self.args, **self.kwargs) 
     except wx.PyDeadObjectError: 
      pass 
     except Exception, e: 
      print e 



if __name__ == "__main__": 
    import os 
    from subprocess import Popen, PIPE 

    def worker(pipe): 
     while True: 
      line = pipe.readline() 
      if line == '': break 
      else: print line 

    proc = Popen("python subprocess_test.py", shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE) 

    stdout_worker = ThreadWorker(worker, proc.stdout) 
    stderr_worker = ThreadWorker(worker, proc.stderr) 
    stdout_worker.start() 
    stderr_worker.start() 
    while True: pass 

Answer 4

मैं इसके लिए pexpect मॉड्यूल का उपयोग किया है, यह ठीक से काम करने लगता है। http://sourceforge.net/projects/pexpect/

Answer 5

यहाँ क्या मेरे लिए काम किया है:

cmd = ["./tester_script.bash"] 
p = subprocess.Popen(cmd, shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE) 
while p.poll() is None: 
    out = p.stdout.readline() 
    do_something_with(out, err) 

आपके मामले में आप अपने कार्यकर्ता धागा करने के लिए उप-प्रक्रिया के लिए एक संदर्भ गुजरती हैं, और धागे के अंदर मतदान करने की कोशिश कर सकता है। मुझे नहीं पता कि यह कैसे व्यवहार करेगा जब दो धागे एक ही उपप्रोसेशन (और साथ बातचीत) करते हैं, लेकिन यह काम कर सकता है।

यह भी ध्यान दें कि while p.poll() is None: का इरादा है। इसे while not p.poll() के साथ प्रतिस्थापित करें जैसा कि पाइथन 0 (सफल समाप्ति के लिए रिटर्नकोड) को False माना जाता है।

Answer 6

मैं भी इस समस्या में भाग रहा हूं। समस्या तब होती है क्योंकि आप stderr को भी पढ़ने की कोशिश कर रहे हैं। अगर कोई त्रुटि नहीं है, तो stderr से पढ़ने की कोशिश ब्लॉक होगा।

विंडोज़ पर, मतदान() फ़ाइल डिस्क्रिप्टर (केवल विंसॉक सॉकेट) के लिए कोई आसान तरीका नहीं है।

तो समाधान एक समाधान से कोशिश करने और पढ़ने के लिए नहीं है।

Answer 7

गैर-अवरुद्ध रीडलाइन के साथ pexpect [http://www.noah.org/wiki/Pexpect] का उपयोग इस समस्या को हल करेगा। यह इस तथ्य से उत्पन्न होता है कि पाइपों को बफर किया जाता है, और इसलिए आपके ऐप का आउटपुट पाइप द्वारा बफर किया जा रहा है, इसलिए जब तक बफर भरता है या प्रक्रिया मर जाती है तब तक आप उस आउटपुट तक नहीं पहुंच सकते हैं।

Answer 8

यह एक प्रसिद्ध पायथन सीमा प्रतीत होता है, PEP 3145 और शायद अन्य देखें। एक समय में

Answer 9

पढ़ें एक चरित्र: http://blog.thelinuxkid.com/2013/06/get-python-subprocess-output-without.html

import contextlib 
import subprocess 

# Unix, Windows and old Macintosh end-of-line 
newlines = ['\n', '\r\n', '\r'] 
def unbuffered(proc, stream='stdout'): 
    stream = getattr(proc, stream) 
    with contextlib.closing(stream): 
     while True: 
      out = [] 
      last = stream.read(1) 
      # Don't loop forever 
      if last == '' and proc.poll() is not None: 
       break 
      while last not in newlines: 
       # Don't loop forever 
       if last == '' and proc.poll() is not None: 
        break 
       out.append(last) 
       last = stream.read(1) 
      out = ''.join(out) 
      yield out 

def example(): 
    cmd = ['ls', '-l', '/'] 
    proc = subprocess.Popen(
     cmd, 
     stdout=subprocess.PIPE, 
     stderr=subprocess.STDOUT, 
     # Make all end-of-lines '\n' 
     universal_newlines=True, 
    ) 
    for line in unbuffered(proc): 
     print line 

example() 

Answer 10

subprocess.Popen का उपयोग करना, मैं अपने सी # परियोजनाओं में से एक की .exe चलाने के लिए और मेरी अजगर फाइल करने के लिए उत्पादन अनुप्रेषित कर सकते हैं। मैं अब पाइथन कंसोल पर print() सी # कंसोल (Console.WriteLine() का उपयोग करके) की सभी जानकारी आउटपुट करने में सक्षम हूं।

अजगर कोड:

from subprocess import Popen, PIPE, STDOUT 

p = Popen('ConsoleDataImporter.exe', stdout = PIPE, stderr = STDOUT, shell = True) 

while True: 
    line = p.stdout.readline() 
    print(line) 
    if not line: 
     break 

इस लाइन के आधार पर अपना नेट परियोजना लाइन के कंसोल आउटपुट के रूप में यह बनाया है और संलग्नित से बाहर टूट जाता है हो जाता है, जबकि परियोजना की समाप्ति पर पाश। मुझे लगता है कि यह दो पायथन फ़ाइलों के लिए भी काम करेगा।