अनुरोध - अपलोड कैसे करें - आंशिक फ़ाइल

Question

मेरा लक्ष्य अनुरोध का उपयोग करके फ़ाइल के हिस्से का एक पुट करना है और फ़ाइल को स्ट्रीम करना है (यानी, इसे स्मृति में लोड न करें और फिर PUT करें)।

This page बताते हैं आपको लगता है कि कैसे करेंगे एक पूरी फ़ाइल के लिए:

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

with open('massive-body', 'rb') as f: 
    requests.post('http://some.url/streamed', data=f) 

हालांकि मेरे मामले में मैं केवल फ़ाइल में से एक हिस्सा भेजना चाहते हैं। क्या इसको मदद देने का कोई तरीका है?

अवधारणा में, कुछ की तरह:

with open('massive-body', 'rb') as f: 
    requests.post('http://some.url/streamed', data=f.read(chunksize)) 

Answer 1

मैं सिर्फ 2 अन्य उत्तर फेंक कर रहा हूँ एक साथ तो मेरे साथ सहन करता है, तो यह बॉक्स से बाहर काम नहीं करता है - मैं इस परीक्षण के कोई साधन नहीं है:

Lazy Method for Reading Big File in Python?

http://docs.python-requests.org/en/latest/user/advanced/#chunk-encoded-requests

def read_in_chunks(file_object, blocksize=1024, chunks=-1): 
    """Lazy function (generator) to read a file piece by piece. 
    Default chunk size: 1k.""" 
    while chunks: 
     data = file_object.read(blocksize) 
     if not data: 
      break 
     yield data 
     chunks -= 1 

requests.post('http://some.url/chunked', data=read_in_chunks(f)) 

Answer 2

ग्रेग के मेरे सवालों के जवाब बंद आधार पर मुझे लगता है कि निम्नलिखित सबसे अच्छा काम करेगा:

सबसे पहले आप कुछ की आवश्यकता होगी आपकी फ़ाइल खोलने रैप करने के लिए इतना है कि यह सीमित करता है कितना डेटा पढ़ा जा सकता है:

class FileLimiter(object): 
    def __init__(self, file_obj, read_limit): 
     self.read_limit = read_limit 
     self.amount_seen = 0 
     self.file_obj = file_obj 

     # So that requests doesn't try to chunk the upload but will instead stream it: 
     self.len = read_limit 

    def read(self, amount=-1): 
     if self.amount_seen >= self.read_limit: 
      return b'' 
     remaining_amount = self.read_limit - self.amount_seen 
     data = self.file_obj.read(min(amount, remaining_amount)) 
     self.amount_seen += len(data) 
     return data 

यह मोटे तौर पर एक अच्छी रैपर वस्तु के रूप में काम करना चाहिए। तो फिर तुम इतना है कि यह प्रयोग करेंगे:

with open('my_large_file', 'rb') as file_obj: 
    file_obj.seek(my_offset) 
    upload = FileLimiter(file_obj, my_chunk_limit) 
    r = requests.post(url, data=upload, headers={'Content-Type': 'application/octet-stream'}) 

हेडर स्पष्ट रूप से वैकल्पिक हैं, लेकिन जब एक सर्वर से डेटा स्ट्रीमिंग, यह एक अच्छा विचार एक विचारशील उपयोगकर्ता हो सकता है और सर्वर क्या वाली सामग्री के प्रकार है बताने के लिए है आप भेज रहे हैं