Как скачать большой файл в Python с запросами.
Requests - это действительно хорошая библиотека. Я хотел бы использовать его для загрузки больших файлов (>1 ГБ). Проблема в том, что невозможно сохранить весь файл в памяти, мне нужно прочитать его порциями. И это проблема со следующим кодом
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
По какой-то причине это не работает таким образом. Он по-прежнему загружает ответ в память, прежде чем сохранить его в файл.
ОБНОВИТЬ
Если вам нужен маленький клиент (Python 2.x /3.x), который может загружать большие файлы с FTP, вы можете найти его здесь. Он поддерживает многопоточность и повторное соединение (он контролирует соединения), а также настраивает параметры сокета для задачи загрузки.
9 ответов
Я понял, что должно быть изменено. Трюк должен был установить stream = True в get() метод.
После этого процесс python остановился, чтобы высосать память (остается около 30 КБ независимо от размера загружаемого файла).
Спасибо @danodonovan за ваш синтаксис, я использую его здесь:
def download_file(url):
local_filename = url.split('/')[-1]
# NOTE the stream=True parameter
r = requests.get(url, stream=True)
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() commented by recommendation from J.F.Sebastian
return local_filename
См. http://docs.python-requests.org/en/latest/user/advanced/ для дальнейшего ознакомления.
Это намного проще, если вы используете Response.raw а также shutil.copyfileobj():
import requests
import shutil
def download_file(url):
local_filename = url.split('/')[-1]
r = requests.get(url, stream=True)
with open(local_filename, 'wb') as f:
shutil.copyfileobj(r.raw, f)
return local_filename
Это передает файл на диск без использования чрезмерной памяти, и код прост.
Не совсем то, о чем спрашивал ОП, но... это смехотворно легко сделать с 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)
Или так, если вы хотите сохранить его во временный файл:
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)
Я наблюдал за процессом:
watch 'ps -p 18647 -o pid,ppid,pmem,rsz,vsz,comm,args; ls -al *.iso'
И я увидел, что файл растет, но использование памяти осталось на 17 МБ. Я что-то пропустил?
Ваш размер куска может быть слишком большим, вы пытались сбросить его - может быть, 1024 байта за раз? (также вы можете использовать with привести в порядок синтаксис)
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
Кстати, как вы определяете, что ответ был загружен в память?
Похоже, что Python не сбрасывает данные в файл, из других вопросов SO вы можете попробовать f.flush() а также os.fsync() форсировать запись файла и освободить память;
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())
Использовать
wgetмодуль python вместо этого. Вот отрывок
import wget
wget.download(url)
Основываясь на комментариях Романа, получивших наибольшее количество голосов выше, вот моя реализация, включая механизм "скачать как" и "повторные попытки":
def download(url: str, file_path='', attempts=2):
"""Downloads a URL content into a file (with large file support by streaming)
:param url: URL to download
:param file_path: Local file name to contain the data downloaded
:param attempts: Number of attempts
:return: New file path. Empty string if the download failed
"""
if not file_path:
file_path = os.path.realpath(os.path.basename(url))
logger.info(f'Downloading {url} content to {file_path}')
url_sections = urlparse(url)
if not url_sections.scheme:
logger.debug('The given url is missing a scheme. Adding http scheme')
url = f'http://{url}'
logger.debug(f'New url: {url}')
for attempt in range(1, attempts+1):
try:
if attempt > 1:
time.sleep(10) # 10 seconds wait time between downloads
with requests.get(url, stream=True) as response:
response.raise_for_status()
with open(file_path, 'wb') as out_file:
for chunk in response.iter_content(chunk_size=1024*1024): # 1MB chunks
out_file.write(chunk)
logger.info('Download finished successfully')
return file_path
except Exception as ex:
logger.error(f'Attempt #{attempt} failed with error: {ex}')
return ''
Вот дополнительный подход для случая использования асинхронной загрузки по частям без чтения всего содержимого файла в память.
Это означает, что как чтение из URL, так и запись в файл реализованы сasyncioбиблиотеки (aiohttpчитать из URL иaiofilesдля записи файла).
Следующий код должен работать наPython 3.7и позже.
Просто отредактируйтеSRC_URLиDEST_FILEпеременные перед копированием и вставкой.
import aiofiles
import aiohttp
import asyncio
async def async_http_download(src_url, dest_file, chunk_size=65536):
async with aiofiles.open(dest_file, 'wb') as fd:
async with aiohttp.ClientSession() as session:
async with session.get(src_url) as resp:
async for chunk in resp.content.iter_chunked(chunk_size):
await fd.write(chunk)
SRC_URL = "/path/to/url"
DEST_FILE = "/path/to/file/on/local/machine"
asyncio.run(async_http_download(SRC_URL, DEST_FILE))
requests хорошо, но как насчет
socket решение?
def stream_(host):
import socket
import ssl
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
context = ssl.create_default_context(Purpose.CLIENT_AUTH)
with context.wrap_socket(sock, server_hostname=host) as wrapped_socket:
wrapped_socket.connect((socket.gethostbyname(host), 443))
wrapped_socket.send(
"GET / HTTP/1.1\r\nHost:thiscatdoesnotexist.com\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9\r\n\r\n".encode())
resp = b""
while resp[-4:-1] != b"\r\n\r":
resp += wrapped_socket.recv(1)
else:
resp = resp.decode()
content_length = int("".join([tag.split(" ")[1] for tag in resp.split("\r\n") if "content-length" in tag.lower()]))
image = b""
while content_length > 0:
data = wrapped_socket.recv(2048)
if not data:
print("EOF")
break
image += data
content_length -= len(data)
with open("image.jpeg", "wb") as file:
file.write(image)
Еще один вариант загрузки больших файлов. Это позволит вам остановиться и продолжить позже (нажмите клавишу, Enterчтобы остановиться), а также продолжить с того места, где вы остановились, если в противном случае ваше соединение прервется.
import datetime
import os
import requests
import threading as th
keep_going = True
def key_capture_thread():
global keep_going
input()
keep_going = False
pkey_capture = th.Thread(target=key_capture_thread, args=(), name='key_capture_process', daemon=True).start()
def download_file(url, local_filepath):
#assumptions:
# headers contain Content-Length:
# headers contain Accept-Ranges: bytes
# stream is not encoded (otherwise start bytes are not known, unless this is stored seperately)
chunk_size = 1048576 #1MB
# chunk_size = 8096 #8KB
# chunk_size = 1024 #1KB
decoded_bytes_downloaded_this_session = 0
start_time = datetime.datetime.now()
if os.path.exists(local_filepath):
decoded_bytes_downloaded = os.path.getsize(local_filepath)
else:
decoded_bytes_downloaded = 0
with requests.Session() as s:
with s.get(url, stream=True) as r:
#check for required headers:
if 'Content-Length' not in r.headers:
print('STOP: request headers do not contain Content-Length')
return
if ('Accept-Ranges','bytes') not in r.headers.items():
print('STOP: request headers do not contain Accept-Ranges: bytes')
with s.get(url) as r:
print(str(r.content, encoding='iso-8859-1'))
return
content_length = int(r.headers['Content-Length'])
if decoded_bytes_downloaded>=content_length:
print('STOP: file already downloaded. decoded_bytes_downloaded>=r.headers[Content-Length]; {}>={}'.format(decoded_bytes_downloaded,r.headers['Content-Length']))
return
if decoded_bytes_downloaded>0:
s.headers['Range'] = 'bytes={}-{}'.format(decoded_bytes_downloaded, content_length-1) #range is inclusive
print('Retrieving byte range (inclusive) {}-{}'.format(decoded_bytes_downloaded, content_length-1))
with s.get(url, stream=True) as r:
r.raise_for_status()
with open(local_filepath, mode='ab') as fwrite:
for chunk in r.iter_content(chunk_size=chunk_size):
decoded_bytes_downloaded+=len(chunk)
decoded_bytes_downloaded_this_session+=len(chunk)
time_taken:datetime.timedelta = (datetime.datetime.now() - start_time)
seconds_per_byte = time_taken.total_seconds()/decoded_bytes_downloaded_this_session
remaining_bytes = content_length-decoded_bytes_downloaded
remaining_seconds = seconds_per_byte * remaining_bytes
remaining_time = datetime.timedelta(seconds=remaining_seconds)
#print updated statistics here
fwrite.write(chunk)
if not keep_going:
break
output_folder = '/mnt/HDD1TB/DownloadsBIG'
# url = 'https://file-examples.com/storage/fea508993d645be1b98bfcf/2017/10/file_example_JPG_100kB.jpg'
# url = 'https://file-examples.com/storage/fe563fce08645a90397f28d/2017/10/file_example_JPG_2500kB.jpg'
url = 'https://ftp.ncbi.nlm.nih.gov/blast/db/nr.00.tar.gz'
local_filepath = os.path.join(output_folder, os.path.split(url)[-1])
download_file(url, local_filepath)