Descargar archivos grandes en python con solicitudes

Requests es una biblioteca realmente bonita. Me gustaría usarlo para descargar archivos grandes (> 1 GB). El problema es que no es posible mantener todo el archivo en la memoria. Necesito leerlo en fragmentos. Y este es un problema con el siguiente código

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 

Por alguna razón no funciona de esta manera. Todavía carga la respuesta en la memoria antes de guardarla en un archivo.

ACTUALIZAR

Si necesita un cliente pequeño (Python 2.x /3.x) que puede descargar archivos grandes desde FTP, puede encontrarlo aquí . Admite subprocesos múltiples y reconexiones (supervisa las conexiones) y también ajusta los parámetros de socket para la tarea de descarga.

Con el siguiente código de transmisión, el uso de la memoria Python está restringido independientemente del tamaño del archivo descargado:

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

Tenga en cuenta que el número de bytes devueltos usando iter_contentno es exactamente el chunk_size; se espera que sea un número aleatorio que a menudo es mucho más grande, y se espera que sea diferente en cada iteración.

Ver https://requests.readthedocs.io/en/latest/user/advanced/#body-content-workflow y https://requests.readthedocs.io/en/latest/api/#requests.Response.iter_content para más información referencia.

Es mucho más fácil si usa Response.rawy 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

Esto transmite el archivo al disco sin usar memoria excesiva, y el código es simple.

No es exactamente lo que OP preguntaba, pero ... es ridículamente fácil hacer eso 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 de esta manera, si desea guardarlo en un archivo temporal:

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)

Vi el proceso:

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

Y vi crecer el archivo, pero el uso de memoria se mantuvo en 17 MB. ¿Me estoy perdiendo de algo?

El tamaño de tu fragmento podría ser demasiado grande, ¿has intentado soltarlo, quizás 1024 bytes a la vez? (también, podría usar withpara ordenar la sintaxis)

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 

Por cierto, ¿cómo deduce que la respuesta se ha cargado en la memoria?

Parece que Python no está vaciando los datos al archivo, de otras preguntas SO que podría intentar f.flush()y os.fsync()forzar la escritura del archivo y la memoria libre;

    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())