Scarica file di grandi dimensioni in Python con richieste

Requests è davvero una bella libreria. Vorrei usarlo per scaricare file di grandi dimensioni (> 1 GB). Il problema è che non è possibile mantenere l'intero file in memoria. Ho bisogno di leggerlo a pezzi. E questo è un problema con il seguente codice

import requests

def DownloadFile(url)
    local_filename = url.split('/')[-1]
    r = requests.get(url)
    f = open(local_filename, 'wb')
    for chunk in r.iter_content(chunk_size=512 * 1024): 
        if chunk: # filter out keep-alive new chunks
            f.write(chunk)
    f.close()
    return 

Per qualche motivo non funziona in questo modo. Carica ancora la risposta in memoria prima di salvarla in un file.

AGGIORNARE

Se hai bisogno di un piccolo client (Python 2.x /3.x) in grado di scaricare file di grandi dimensioni da FTP, puoi trovarlo qui . Supporta il multithreading e le riconnessioni (monitora le connessioni) e ottimizza i parametri socket per l'attività di download.

Con il seguente codice di streaming, l'utilizzo della memoria di Python è limitato indipendentemente dalle dimensioni del file scaricato:

def download_file(url):
    local_filename = url.split('/')[-1]
    # NOTE the stream=True parameter below
    with requests.get(url, stream=True) as r:
        r.raise_for_status()
        with open(local_filename, 'wb') as f:
            for chunk in r.iter_content(chunk_size=8192): 
                # If you have chunk encoded response uncomment if
                # and set chunk_size parameter to None.
                #if chunk: 
                f.write(chunk)
    return local_filename

Si noti che il numero di byte restituiti utilizzando iter_contentnon è esattamente il chunk_size; si prevede che sia un numero casuale che è spesso molto più grande e che dovrebbe essere diverso in ogni iterazione.

Vedi https://requests.readthedocs.io/en/latest/user/advanced/#body-content-workflow e https://requests.readthedocs.io/en/latest/api/#requests.Response.iter_content per ulteriori riferimento.

È molto più semplice se si utilizza Response.rawe shutil.copyfileobj():

import requests
import shutil

def download_file(url):
    local_filename = url.split('/')[-1]
    with requests.get(url, stream=True) as r:
        with open(local_filename, 'wb') as f:
            shutil.copyfileobj(r.raw, f)

    return local_filename

Questo esegue lo streaming del file su disco senza utilizzare memoria eccessiva e il codice è semplice.

Non esattamente quello che stava chiedendo OP, ma ... è ridicolmente facile farlo con urllib:

from urllib.request import urlretrieve
url = 'http://mirror.pnl.gov/releases/16.04.2/ubuntu-16.04.2-desktop-amd64.iso'
dst = 'ubuntu-16.04.2-desktop-amd64.iso'
urlretrieve(url, dst)

O in questo modo, se si desidera salvarlo in un file temporaneo:

from urllib.request import urlopen
from shutil import copyfileobj
from tempfile import NamedTemporaryFile
url = 'http://mirror.pnl.gov/releases/16.04.2/ubuntu-16.04.2-desktop-amd64.iso'
with urlopen(url) as fsrc, NamedTemporaryFile(delete=False) as fdst:
    copyfileobj(fsrc, fdst)

Ho visto il processo:

watch 'ps -p 18647 -o pid,ppid,pmem,rsz,vsz,comm,args; ls -al *.iso'

E ho visto crescere il file, ma l'utilizzo della memoria è rimasto a 17 MB. Mi sto perdendo qualcosa?

La dimensione del tuo blocco potrebbe essere troppo grande, hai provato a farlo cadere - forse 1024 byte alla volta? (inoltre, è possibile utilizzare withper riordinare la sintassi)

def DownloadFile(url):
    local_filename = url.split('/')[-1]
    r = requests.get(url)
    with open(local_filename, 'wb') as f:
        for chunk in r.iter_content(chunk_size=1024): 
            if chunk: # filter out keep-alive new chunks
                f.write(chunk)
    return 

Per inciso, come stai deducendo che la risposta è stata caricata in memoria?

Sembra come se python non è vampate di calore i dati in un file, da altre domande in modo si potrebbe provare f.flush()e os.fsync()per forzare il file di scrittura e memoria libera;

    with open(local_filename, 'wb') as f:
        for chunk in r.iter_content(chunk_size=1024): 
            if chunk: # filter out keep-alive new chunks
                f.write(chunk)
                f.flush()
                os.fsync(f.fileno())