使用Python实现可恢复式多线程下载器

import os
import requests
from tqdm import tqdm
 
class ResumableDownloader:
    def __init__(self, url, save_path):
        self.url = url
        self.save_path = save_path
        self.file_size = self._get_file_size()
        self.downloaded = 0
 
    def _get_file_size(self):
        response = requests.head(self.url)
        return int(response.headers['Content-Length'])
 
    def _check_resume_point(self):
        if os.path.exists(self.save_path):
            self.downloaded = os.path.getsize(self.save_path)
            return True
        return False
 
    def download(self):
        headers = {'Range': f'bytes={self.downloaded}-'}
        response = requests.get(self.url, headers=headers, stream=True)
        
        with open(self.save_path, 'ab') as f, tqdm(
            total=self.file_size,
            desc="下载进度",
            initial=self.downloaded,
            unit='B',
            unit_scale=True
        ) as bar:
            for chunk in response.iter_content(chunk_size=8192):
                if chunk:
                    f.write(chunk)
                    bar.update(len(chunk))

from concurrent.futures import ThreadPoolExecutor
 
class MultiThreadDownloader(ResumableDownloader):
    def __init__(self, url, save_path, threads=4):
        super().__init__(url, save_path)
        self.threads = threads
        self.chunk_size = self.file_size // threads
 
    def _download_chunk(self, start, end, thread_id):
        headers = {'Range': f'bytes={start}-{end}'}
        response = requests.get(self.url, headers=headers, stream=True)
        
        with open(self.save_path, 'r+b') as f:
            f.seek(start)
            f.write(response.content)
        return end - start + 1
 
    def download(self):
        if not self._check_resume_point():
            self._create_empty_file()
 
        with ThreadPoolExecutor(max_workers=self.threads) as executor:
            futures = []
            for i in range(self.threads):
                start = i * self.chunk_size
                end = start + self.chunk_size - 1
                if i == self.threads - 1:
                    end = self.file_size - 1
                futures.append(executor.submit(
                    self._download_chunk, start, end, i))
            
            with tqdm(total=self.file_size, desc="多线程下载") as bar:
                for future in futures:
                    bar.update(future.result())

import time
 
class SpeedLimiter:
    def __init__(self, max_speed):
        self.max_speed = max_speed  # 单位：KB/s
        self.last_check = time.time()
        self.downloaded = 0
 
    def throttle(self, chunk_size):
        now = time.time()
        elapsed = now - self.last_check
        self.downloaded += chunk_size
        
        if elapsed > 0:
            current_speed = (self.downloaded / 1024) / elapsed
            if current_speed > self.max_speed:
                sleep_time = (self.downloaded / (self.max_speed * 1024)) - elapsed
                if sleep_time > 0:
                    time.sleep(sleep_time)
        self.last_check = time.time()
        self.downloaded = 0

from rich.console import Console
from rich.panel import Panel
from rich.progress import (
    Progress,
    TextColumn,
    BarColumn,
    DownloadColumn,
    TransferSpeedColumn,
    TimeRemainingColumn,
)
 
class TerminalUI:
    def __init__(self):
        self.console = Console()
        self.progress = Progress(
            TextColumn("[bold blue]{task.description}"),
            BarColumn(),
            TextColumn("{task.completed}/{task.total}"),
            DownloadColumn(),
            TransferSpeedColumn(),
            TimeRemainingColumn(),
        )
 
    def display_dashboard(self, downloader):
        self.console.clear()
        self.progress.start()
        task = self.progress.add_task(
            description="初始化下载...",
            total=downloader.file_size,
            start=downloader.downloaded
        )
        
        while not downloader.is_complete():
            self.progress.update(task, 
                completed=downloader.downloaded,
                description=f"下载速度: {downloader.get_speed():.2f}KB/s"
            )
            time.sleep(0.5)
            
        self.progress.stop()
        self.console.print(Panel("[green]下载完成！文件保存至：[/]" + downloader.save_path))

if __name__ == "__main__":
    downloader = MultiThreadDownloader(
        url="https://example.com/bigfile.zip",
        save_path="./downloads/bigfile.zip",
        threads=8
    )
    
    ui = TerminalUI()
    ui.display_dashboard(downloader)

import json
 
config = {
    "max_speed": 512,  # 限制512KB/s
    "threads": 12,
    "retry_times": 3
}
 
with open("download_config.json", "w") as f:
    json.dump(config, f)