सबप्रोसेस से रियलटाइम में स्टडआउट पकड़ना

Question 1

मैं subprocess.Popen()विंडोज में rsync.exe करना चाहता हूं , और पायथन में स्टडआउट प्रिंट करता हूं ।

मेरा कोड काम करता है, लेकिन यह तब तक प्रगति को नहीं पकड़ता है जब तक कि फाइल ट्रांसफर न हो जाए! मैं वास्तविक समय में प्रत्येक फ़ाइल के लिए प्रगति प्रिंट करना चाहता हूं।

पायथन 3.1 का उपयोग करते हुए अब मैंने सुना है कि आईओ को संभालने में बेहतर होना चाहिए।

import subprocess, time, os, sys

cmd = "rsync.exe -vaz -P source/ dest/"
p, line = True, 'start'


p = subprocess.Popen(cmd,
                     shell=True,
                     bufsize=64,
                     stdin=subprocess.PIPE,
                     stderr=subprocess.PIPE,
                     stdout=subprocess.PIPE)

for line in p.stdout:
    print(">>> " + str(line.rstrip()))
    p.stdout.flush()

Question 2

के लिए अंगूठे के कुछ नियम subprocess।

कभी उपयोग न करें shell=True। यह अनावश्यक रूप से आपके प्रोग्राम को कॉल करने के लिए एक अतिरिक्त शेल प्रक्रिया को आमंत्रित करता है।
कॉल करने की प्रक्रिया के दौरान, तर्कों को सूचियों के रूप में पास किया जाता है। sys.argvअजगर में एक सूची है, और इसलिए argvसी में है। तो आप एक स्ट्रिंग नहीं उप-वर्गों को कॉल करने के लिए एक सूची पास करते हैं Popen।
रीडायरेक्ट न करें stderrएक करने के लिए PIPEजब आप इसे पढ़ नहीं रहे हैं।
stdinजब आप इसे नहीं लिख रहे हैं तो पुनर्निर्देशित न करें ।

उदाहरण:

import subprocess, time, os, sys
cmd = ["rsync.exe", "-vaz", "-P", "source/" ,"dest/"]

p = subprocess.Popen(cmd,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.STDOUT)

for line in iter(p.stdout.readline, b''):
    print(">>> " + line.rstrip())

उस ने कहा, यह संभावित है कि rsync अपने आउटपुट को बफ़र करता है जब यह पता लगाता है कि यह टर्मिनल के बजाय पाइप से जुड़ा है। यह डिफ़ॉल्ट व्यवहार है - जब पाइप से जुड़ा होता है, तो प्रोग्राम को वास्तविक समय के परिणामों के लिए स्पष्ट रूप से फ्लशआउट करना चाहिए, अन्यथा मानक सी लाइब्रेरी बफर हो जाएगी।

इसके लिए परीक्षण करने के लिए, इसके बजाय इसे चलाने का प्रयास करें:

cmd = [sys.executable, 'test_out.py']

और test_out.pyसामग्री के साथ एक फ़ाइल बनाएँ :

import sys
import time
print ("Hello")
sys.stdout.flush()
time.sleep(10)
print ("World")

यह कहते हुए कि उपप्रकार आपको "हैलो" देना चाहिए और "दुनिया" देने से पहले 10 सेकंड प्रतीक्षा करें। यदि ऐसा ऊपर के अजगर कोड के साथ होता है और इसके साथ नहीं होता है rsync, तो इसका मतलब rsyncहै कि इसका आउटपुट बफ़र कर रहा है, इसलिए आप भाग्य से बाहर हैं।

एक समाधान के लिए प्रत्यक्ष कनेक्ट करने के लिए होगा pty, जैसे कुछ का उपयोग कर pexpect।

Question 3

मुझे पता है कि यह एक पुराना विषय है, लेकिन अब एक समाधान है। Rsync को विकल्प --outbuf = L के साथ कॉल करें। उदाहरण:

cmd=['rsync', '-arzv','--backup','--outbuf=L','source/','dest']
p = subprocess.Popen(cmd,
                     stdout=subprocess.PIPE)
for line in iter(p.stdout.readline, b''):
    print '>>> {}'.format(line.rstrip())

Question 4

लिनक्स पर, मुझे बफरिंग से छुटकारा पाने की समान समस्या थी। मैंने आखिरकार PIPE बफरिंग से छुटकारा पाने के लिए "stdbuf -o0" (या, उम्मीद से असहमत) का इस्तेमाल किया।

proc = Popen(['stdbuf', '-o0'] + cmd, stdout=PIPE, stderr=PIPE)
stdout = proc.stdout

मैं तब stdout पर select.select का उपयोग कर सकता था।

Https://unix.stackexchange.com/questions/25372/ भी देखें

Question 5

उपयोग के मामले के आधार पर, आप उपप्रकार में बफ़रिंग को भी अक्षम करना चाह सकते हैं।

यदि सबप्रोसेस एक पायथन प्रक्रिया होगी, तो आप कॉल से पहले ऐसा कर सकते हैं:

os.environ["PYTHONUNBUFFERED"] = "1"

या वैकल्पिक रूप से इस envतर्क में पास Popen।

अन्यथा, यदि आप लिनक्स / यूनिक्स पर हैं, तो आप stdbufटूल का उपयोग कर सकते हैं । जैसे:

cmd = ["stdbuf", "-oL"] + cmd

अन्य विकल्पों के बारे में भी यहां देखें stdbuf।

Question 6

for line in p.stdout:
  ...

हमेशा अगली पंक्ति की फ़ीड तक ब्लॉक करें।

"वास्तविक समय" व्यवहार के लिए आपको कुछ इस तरह करना होगा:

while True:
  inchar = p.stdout.read(1)
  if inchar: #neither empty string nor None
    print(str(inchar), end='') #or end=None to flush immediately
  else:
    print('') #flush for implicit line-buffering
    break

जब बच्चे की प्रक्रिया अपने स्टडआउट को बंद कर देती है या बाहर निकल जाती है, तो लूप-लूप छोड़ दिया जाता है। read()/read(-1)तब तक ब्लॉक रहेगा जब तक कि बाल प्रक्रिया अपने स्टडआउट या बाहर नहीं निकल जाती।

Question 7

आपकी समस्या यह है:

for line in p.stdout:
    print(">>> " + str(line.rstrip()))
    p.stdout.flush()

इट्रेटर में अतिरिक्त बफ़रिंग है।

इस तरह करने की कोशिश करें:

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

Question 8

आपको पाइप से अटूट प्रिंट करने के लिए स्टडआउट नहीं मिल सकता है (जब तक कि आप प्रोग्राम को फिर से प्रिंट करने के लिए नहीं लिखते हैं), तो यहाँ मेरा समाधान है:

Strout को sterrout पर पुनर्निर्देशित करें, जो बफर नहीं है। '<cmd> 1>&2'करना चाहिए। प्रक्रिया इस प्रकार खोलें: myproc = subprocess.Popen('<cmd> 1>&2', stderr=subprocess.PIPE)
आप stdout या stderr से अंतर नहीं कर सकते, लेकिन आपको तुरंत सभी आउटपुट मिलते हैं।

आशा है कि यह किसी को भी इस समस्या से निपटने में मदद करता है।

Question 9

Rsync प्रक्रिया से स्टैडआउट को परिवर्तित न किया जाए।

p = subprocess.Popen(cmd,
                     shell=True,
                     bufsize=0,  # 0=unbuffered, 1=line-buffered, else buffer-size
                     stdin=subprocess.PIPE,
                     stderr=subprocess.PIPE,
                     stdout=subprocess.PIPE)

Question 10

आउटपुट के कैशिंग से बचने के लिए आप pexpect की कोशिश कर सकते हैं,

child = pexpect.spawn(launchcmd,args,timeout=None)
while True:
    try:
        child.expect('\n')
        print(child.before)
    except pexpect.EOF:
        break

पुनश्च : मुझे पता है कि यह प्रश्न बहुत पुराना है, फिर भी मेरे लिए काम करने वाले समाधान प्रदान करता है।

PPS : एक अन्य प्रश्न से यह उत्तर मिला

Question 11

    p = subprocess.Popen(command,
                                bufsize=0,
                                universal_newlines=True)

मैं अजगर में rsync के लिए एक GUI लिख रहा हूं, और एक ही जांच कर रहा हूं। इस समस्या ने मुझे कई दिनों तक परेशान किया, जब तक कि मैंने इसे pyDoc में नहीं पाया।

यदि Universal_newlines सत्य है, तो फ़ाइल ऑब्जेक्ट्स stdout और stderr को सार्वभौमिक newlines मोड में पाठ फ़ाइलों के रूप में खोला जाता है। लाइनों को किसी भी '\ n', यूनिक्स के अंत-लाइन सम्मेलन, '\ r', पुराने मैकिन्टोश सम्मेलन या '\ r \ n', विंडोज सम्मेलन द्वारा समाप्त किया जा सकता है। इन सभी बाहरी अभ्यावेदन को पायथन प्रोग्राम द्वारा '\ n' के रूप में देखा जाता है।

ऐसा लगता है कि अनुवाद चालू होने पर rsync '\ r' आउटपुट करेगा।

Question 12

मैंने देखा है कि मध्यवर्ती के रूप में एक अस्थायी फ़ाइल का उपयोग करने का कोई उल्लेख नहीं है। निम्नलिखित एक अस्थायी फ़ाइल में आउटपुट करके बफरिंग मुद्दों के आसपास हो जाता है और आपको pty से कनेक्ट किए बिना rsync से आने वाले डेटा को पार्स करने की अनुमति देता है। मैंने एक लिनक्स बॉक्स पर निम्नलिखित का परीक्षण किया, और rsync का आउटपुट प्लेटफ़ॉर्म पर भिन्न होता है, इसलिए आउटपुट को पार्स करने के लिए नियमित भाव भिन्न हो सकते हैं:

import subprocess, time, tempfile, re

pipe_output, file_name = tempfile.TemporaryFile()
cmd = ["rsync", "-vaz", "-P", "/src/" ,"/dest"]

p = subprocess.Popen(cmd, stdout=pipe_output, 
                     stderr=subprocess.STDOUT)
while p.poll() is None:
    # p.poll() returns None while the program is still running
    # sleep for 1 second
    time.sleep(1)
    last_line =  open(file_name).readlines()
    # it's possible that it hasn't output yet, so continue
    if len(last_line) == 0: continue
    last_line = last_line[-1]
    # Matching to "[bytes downloaded]  number%  [speed] number:number:number"
    match_it = re.match(".* ([0-9]*)%.* ([0-9]*:[0-9]*:[0-9]*).*", last_line)
    if not match_it: continue
    # in this case, the percentage is stored in match_it.group(1), 
    # time in match_it.group(2).  We could do something with it here...

Question 13

यदि आप एक धागे में कुछ इस तरह से चलाते हैं और एक विधि की संपत्ति में ffmpeg_time संपत्ति को बचाते हैं, तो आप इसे एक्सेस कर सकते हैं, यह बहुत अच्छा काम करेगा मुझे इस तरह से आउटपुट मिलते हैं: आउटपुट ऐसा होता है यदि आप टिंकर में थ्रेडिंग का उपयोग करते हैं

input = 'path/input_file.mp4'
output = 'path/input_file.mp4'
command = "ffmpeg -y -v quiet -stats -i \"" + str(input) + "\" -metadata title=\"@alaa_sanatisharif\" -preset ultrafast -vcodec copy -r 50 -vsync 1 -async 1 \"" + output + "\""
process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True, shell=True)
for line in self.process.stdout:
    reg = re.search('\d\d:\d\d:\d\d', line)
    ffmpeg_time = reg.group(0) if reg else ''
    print(ffmpeg_time)

Question 14

पायथन 3 में, यहां एक समाधान दिया गया है, जो कमांड लाइन से एक कमांड लेता है और प्राप्त होते ही वास्तविक समय में अच्छी तरह से डिकोड किए गए तारों को बचाता है।

रिसीवर ( receiver.py):

import subprocess
import sys

cmd = sys.argv[1:]
p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
for line in p.stdout:
    print("received: {}".format(line.rstrip().decode("utf-8")))

उदाहरण सरल प्रोग्राम जो वास्तविक समय आउटपुट उत्पन्न कर सकता है ( dummy_out.py):

import time
import sys

for i in range(5):
    print("hello {}".format(i))
    sys.stdout.flush()  
    time.sleep(1)

आउटपुट:

$python receiver.py python dummy_out.py
received: hello 0
received: hello 1
received: hello 2
received: hello 3
received: hello 4