Télécharger un gros fichier en python avec des requêtes

Requests est une bibliothèque vraiment sympa. Je voudrais l'utiliser pour télécharger de gros fichiers (> 1 Go). Le problème est qu'il n'est pas possible de conserver le fichier entier en mémoire, j'ai besoin de le lire en morceaux. Et c'est un problème avec le code suivant

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 

Pour une raison quelconque, cela ne fonctionne pas de cette façon. Il charge toujours la réponse en mémoire avant de l'enregistrer dans un fichier.

MISE À JOUR

Si vous avez besoin d'un petit client (Python 2.x /3.x) qui peut télécharger de gros fichiers depuis FTP, vous pouvez le trouver ici . Il prend en charge le multithreading et les reconnexions (il surveille les connexions) et ajuste les paramètres de socket pour la tâche de téléchargement.

Avec le code de streaming suivant, l'utilisation de la mémoire Python est limitée quelle que soit la taille du fichier téléchargé:

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

Notez que le nombre d'octets retournés en utilisant iter_contentn'est pas exactement le chunk_size; il devrait être un nombre aléatoire qui est souvent beaucoup plus grand et devrait être différent à chaque itération.

Voir https://requests.readthedocs.io/en/latest/user/advanced/#body-content-workflow et https://requests.readthedocs.io/en/latest/api/#requests.Response.iter_content pour plus d'informations référence.

C'est beaucoup plus facile si vous utilisez Response.rawet 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

Cela diffuse le fichier sur le disque sans utiliser de mémoire excessive et le code est simple.

Pas exactement ce qu'OP demandait, mais ... c'est ridiculement facile de le faire avec 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)

Ou de cette façon, si vous souhaitez l'enregistrer dans un fichier temporaire:

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)

J'ai regardé le processus:

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

Et j'ai vu le fichier augmenter, mais l'utilisation de la mémoire est restée à 17 Mo. Suis-je en train de manquer quelque chose?

Votre taille de bloc peut être trop grande, avez-vous essayé de supprimer cela - peut-être 1024 octets à la fois? (vous pouvez également utiliser withpour ranger la syntaxe)

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 

Soit dit en passant, comment déduisez-vous que la réponse a été chargée en mémoire?

Il semble que python n'est pas le rinçage des données dans un fichier, d'autres questions SO vous pouvez essayer f.flush()et os.fsync()forcer la écriture de fichiers et de la mémoire 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())